7 files changed, 232 insertions, 106 deletions

diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 177735f79317..6653ddbed048 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -130,17 +130,17 @@ void spu_unmap_mappings(struct spu_context *ctx)
         if (ctx->local_store)
                 unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1);
         if (ctx->mfc)
-                unmap_mapping_range(ctx->mfc, 0, 0x1000, 1);
+                unmap_mapping_range(ctx->mfc, 0, SPUFS_MFC_MAP_SIZE, 1);
         if (ctx->cntl)
-                unmap_mapping_range(ctx->cntl, 0, 0x1000, 1);
+                unmap_mapping_range(ctx->cntl, 0, SPUFS_CNTL_MAP_SIZE, 1);
         if (ctx->signal1)
-                unmap_mapping_range(ctx->signal1, 0, PAGE_SIZE, 1);
+                unmap_mapping_range(ctx->signal1, 0, SPUFS_SIGNAL_MAP_SIZE, 1);
         if (ctx->signal2)
-                unmap_mapping_range(ctx->signal2, 0, PAGE_SIZE, 1);
+                unmap_mapping_range(ctx->signal2, 0, SPUFS_SIGNAL_MAP_SIZE, 1);
         if (ctx->mss)
-                unmap_mapping_range(ctx->mss, 0, 0x1000, 1);
+                unmap_mapping_range(ctx->mss, 0, SPUFS_MSS_MAP_SIZE, 1);
         if (ctx->psmap)
-                unmap_mapping_range(ctx->psmap, 0, 0x20000, 1);
+                unmap_mapping_range(ctx->psmap, 0, SPUFS_PS_MAP_SIZE, 1);
         mutex_unlock(&ctx->mapping_lock);
 }
 
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index c81341ff75b5..99c73066b82f 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -238,11 +238,13 @@ spufs_mem_write(struct file *file, const char __user *buffer,
         return size;
 }
 
-static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma,
-                                          unsigned long address)
+static int
+spufs_mem_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct spu_context *ctx = vma->vm_file->private_data;
-        unsigned long pfn, offset, addr0 = address;
+        unsigned long address = (unsigned long)vmf->virtual_address;
+        unsigned long pfn, offset;
+
 #ifdef CONFIG_SPU_FS_64K_LS
         struct spu_state *csa = &ctx->csa;
         int psize;
@@ -260,15 +262,15 @@ static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma,
         }
 #endif /* CONFIG_SPU_FS_64K_LS */
 
-        offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
+        offset = vmf->pgoff << PAGE_SHIFT;
         if (offset >= LS_SIZE)
-                return NOPFN_SIGBUS;
+                return VM_FAULT_SIGBUS;
 
-        pr_debug("spufs_mem_mmap_nopfn address=0x%lx -> 0x%lx, offset=0x%lx\n",
-                 addr0, address, offset);
+        pr_debug("spufs_mem_mmap_fault address=0x%lx, offset=0x%lx\n",
+                        address, offset);
 
         if (spu_acquire(ctx))
-                return NOPFN_REFAULT;
+                return VM_FAULT_NOPAGE;
 
         if (ctx->state == SPU_STATE_SAVED) {
                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
@@ -283,12 +285,12 @@ static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma,
 
         spu_release(ctx);
 
-        return NOPFN_REFAULT;
+        return VM_FAULT_NOPAGE;
 }
 
 
 static struct vm_operations_struct spufs_mem_mmap_vmops = {
-        .nopfn = spufs_mem_mmap_nopfn,
+        .fault = spufs_mem_mmap_fault,
 };
 
 static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
@@ -351,20 +353,19 @@ static const struct file_operations spufs_mem_fops = {
 #endif
 };
 
-static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
-                                    unsigned long address,
+static int spufs_ps_fault(struct vm_area_struct *vma,
+                                    struct vm_fault *vmf,
                                     unsigned long ps_offs,
                                     unsigned long ps_size)
 {
         struct spu_context *ctx = vma->vm_file->private_data;
-        unsigned long area, offset = address - vma->vm_start;
+        unsigned long area, offset = vmf->pgoff << PAGE_SHIFT;
         int ret = 0;
 
-        spu_context_nospu_trace(spufs_ps_nopfn__enter, ctx);
+        spu_context_nospu_trace(spufs_ps_fault__enter, ctx);
 
-        offset += vma->vm_pgoff << PAGE_SHIFT;
         if (offset >= ps_size)
-                return NOPFN_SIGBUS;
+                return VM_FAULT_SIGBUS;
 
         /*
          * Because we release the mmap_sem, the context may be destroyed while
@@ -378,7 +379,7 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
          * pages to hand out to the user, but we don't want to wait
          * with the mmap_sem held.
          * It is possible to drop the mmap_sem here, but then we need
-         * to return NOPFN_REFAULT because the mappings may have
+         * to return VM_FAULT_NOPAGE because the mappings may have
          * hanged.
          */
         if (spu_acquire(ctx))
@@ -386,14 +387,15 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
 
         if (ctx->state == SPU_STATE_SAVED) {
                 up_read(&current->mm->mmap_sem);
-                spu_context_nospu_trace(spufs_ps_nopfn__sleep, ctx);
+                spu_context_nospu_trace(spufs_ps_fault__sleep, ctx);
                 ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
-                spu_context_trace(spufs_ps_nopfn__wake, ctx, ctx->spu);
+                spu_context_trace(spufs_ps_fault__wake, ctx, ctx->spu);
                 down_read(&current->mm->mmap_sem);
         } else {
                 area = ctx->spu->problem_phys + ps_offs;
-                vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT);
-                spu_context_trace(spufs_ps_nopfn__insert, ctx, ctx->spu);
+                vm_insert_pfn(vma, (unsigned long)vmf->virtual_address,
+                                        (area + offset) >> PAGE_SHIFT);
+                spu_context_trace(spufs_ps_fault__insert, ctx, ctx->spu);
         }
 
         if (!ret)
@@ -401,18 +403,18 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
 
 refault:
         put_spu_context(ctx);
-        return NOPFN_REFAULT;
+        return VM_FAULT_NOPAGE;
 }
 
 #if SPUFS_MMAP_4K
-static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct *vma,
-                                           unsigned long address)
+static int spufs_cntl_mmap_fault(struct vm_area_struct *vma,
+                                           struct vm_fault *vmf)
 {
-        return spufs_ps_nopfn(vma, address, 0x4000, 0x1000);
+        return spufs_ps_fault(vma, vmf, 0x4000, SPUFS_CNTL_MAP_SIZE);
 }
 
 static struct vm_operations_struct spufs_cntl_mmap_vmops = {
-        .nopfn = spufs_cntl_mmap_nopfn,
+        .fault = spufs_cntl_mmap_fault,
 };
 
 /*
@@ -1097,23 +1099,23 @@ static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
         return 4;
 }
 
-static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct *vma,
-                                              unsigned long address)
+static int
+spufs_signal1_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-#if PAGE_SIZE == 0x1000
-        return spufs_ps_nopfn(vma, address, 0x14000, 0x1000);
-#elif PAGE_SIZE == 0x10000
+#if SPUFS_SIGNAL_MAP_SIZE == 0x1000
+        return spufs_ps_fault(vma, vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE);
+#elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
          * signal 1 and 2 area
          */
-        return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
+        return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
 #else
 #error unsupported page size
 #endif
 }
 
 static struct vm_operations_struct spufs_signal1_mmap_vmops = {
-        .nopfn = spufs_signal1_mmap_nopfn,
+        .fault = spufs_signal1_mmap_fault,
 };
 
 static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
@@ -1234,23 +1236,23 @@ static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
 }
 
 #if SPUFS_MMAP_4K
-static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct *vma,
-                                              unsigned long address)
+static int
+spufs_signal2_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-#if PAGE_SIZE == 0x1000
-        return spufs_ps_nopfn(vma, address, 0x1c000, 0x1000);
-#elif PAGE_SIZE == 0x10000
+#if SPUFS_SIGNAL_MAP_SIZE == 0x1000
+        return spufs_ps_fault(vma, vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE);
+#elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
          * signal 1 and 2 area
          */
-        return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
+        return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
 #else
 #error unsupported page size
 #endif
 }
 
 static struct vm_operations_struct spufs_signal2_mmap_vmops = {
-        .nopfn = spufs_signal2_mmap_nopfn,
+        .fault = spufs_signal2_mmap_fault,
 };
 
 static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
@@ -1362,14 +1364,14 @@ DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
                        spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE);
 
 #if SPUFS_MMAP_4K
-static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct *vma,
-                                          unsigned long address)
+static int
+spufs_mss_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-        return spufs_ps_nopfn(vma, address, 0x0000, 0x1000);
+        return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_MSS_MAP_SIZE);
 }
 
 static struct vm_operations_struct spufs_mss_mmap_vmops = {
-        .nopfn = spufs_mss_mmap_nopfn,
+        .fault = spufs_mss_mmap_fault,
 };
 
 /*
@@ -1424,14 +1426,14 @@ static const struct file_operations spufs_mss_fops = {
         .mmap    = spufs_mss_mmap,
 };
 
-static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct *vma,
-                                            unsigned long address)
+static int
+spufs_psmap_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-        return spufs_ps_nopfn(vma, address, 0x0000, 0x20000);
+        return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_PS_MAP_SIZE);
 }
 
 static struct vm_operations_struct spufs_psmap_mmap_vmops = {
-        .nopfn = spufs_psmap_mmap_nopfn,
+        .fault = spufs_psmap_mmap_fault,
 };
 
 /*
@@ -1484,14 +1486,14 @@ static const struct file_operations spufs_psmap_fops = {
 
 
 #if SPUFS_MMAP_4K
-static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct *vma,
-                                          unsigned long address)
+static int
+spufs_mfc_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-        return spufs_ps_nopfn(vma, address, 0x3000, 0x1000);
+        return spufs_ps_fault(vma, vmf, 0x3000, SPUFS_MFC_MAP_SIZE);
 }
 
 static struct vm_operations_struct spufs_mfc_mmap_vmops = {
-        .nopfn = spufs_mfc_mmap_nopfn,
+        .fault = spufs_mfc_mmap_fault,
 };
 
 /*
@@ -2553,22 +2555,74 @@ void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx,
         wake_up(&ctx->switch_log->wait);
 }
 
-struct tree_descr spufs_dir_contents[] = {
+static int spufs_show_ctx(struct seq_file *s, void *private)
+{
+        struct spu_context *ctx = s->private;
+        u64 mfc_control_RW;
+
+        mutex_lock(&ctx->state_mutex);
+        if (ctx->spu) {
+                struct spu *spu = ctx->spu;
+                struct spu_priv2 __iomem *priv2 = spu->priv2;
+
+                spin_lock_irq(&spu->register_lock);
+                mfc_control_RW = in_be64(&priv2->mfc_control_RW);
+                spin_unlock_irq(&spu->register_lock);
+        } else {
+                struct spu_state *csa = &ctx->csa;
+
+                mfc_control_RW = csa->priv2.mfc_control_RW;
+        }
+
+        seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)"
+                " %c %lx %lx %lx %lx %x %x\n",
+                ctx->state == SPU_STATE_SAVED ? 'S' : 'R',
+                ctx->flags,
+                ctx->sched_flags,
+                ctx->prio,
+                ctx->time_slice,
+                ctx->spu ? ctx->spu->number : -1,
+                !list_empty(&ctx->rq) ? 'q' : ' ',
+                ctx->csa.class_0_pending,
+                ctx->csa.class_0_dar,
+                ctx->csa.class_1_dsisr,
+                mfc_control_RW,
+                ctx->ops->runcntl_read(ctx),
+                ctx->ops->status_read(ctx));
+
+        mutex_unlock(&ctx->state_mutex);
+
+        return 0;
+}
+
+static int spufs_ctx_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx);
+}
+
+static const struct file_operations spufs_ctx_fops = {
+        .open           = spufs_ctx_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+struct spufs_tree_descr spufs_dir_contents[] = {
         { "capabilities", &spufs_caps_fops, 0444, },
-        { "mem",  &spufs_mem_fops,  0666, },
-        { "regs", &spufs_regs_fops,  0666, },
+        { "mem",  &spufs_mem_fops,  0666, LS_SIZE, },
+        { "regs", &spufs_regs_fops,  0666, sizeof(struct spu_reg128[128]), },
         { "mbox", &spufs_mbox_fops, 0444, },
         { "ibox", &spufs_ibox_fops, 0444, },
         { "wbox", &spufs_wbox_fops, 0222, },
-        { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
-        { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
-        { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
+        { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
+        { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
+        { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
         { "signal1", &spufs_signal1_fops, 0666, },
         { "signal2", &spufs_signal2_fops, 0666, },
         { "signal1_type", &spufs_signal1_type, 0666, },
         { "signal2_type", &spufs_signal2_type, 0666, },
         { "cntl", &spufs_cntl_fops,  0666, },
-        { "fpcr", &spufs_fpcr_fops, 0666, },
+        { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), },
         { "lslr", &spufs_lslr_ops, 0444, },
         { "mfc", &spufs_mfc_fops, 0666, },
         { "mss", &spufs_mss_fops, 0666, },
@@ -2578,29 +2632,31 @@ struct tree_descr spufs_dir_contents[] = {
         { "decr_status", &spufs_decr_status_ops, 0666, },
         { "event_mask", &spufs_event_mask_ops, 0666, },
         { "event_status", &spufs_event_status_ops, 0444, },
-        { "psmap", &spufs_psmap_fops, 0666, },
+        { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
         { "phys-id", &spufs_id_ops, 0666, },
         { "object-id", &spufs_object_id_ops, 0666, },
-        { "mbox_info", &spufs_mbox_info_fops, 0444, },
-        { "ibox_info", &spufs_ibox_info_fops, 0444, },
-        { "wbox_info", &spufs_wbox_info_fops, 0444, },
-        { "dma_info", &spufs_dma_info_fops, 0444, },
-        { "proxydma_info", &spufs_proxydma_info_fops, 0444, },
+        { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), },
+        { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), },
+        { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), },
+        { "dma_info", &spufs_dma_info_fops, 0444,
+                sizeof(struct spu_dma_info), },
+        { "proxydma_info", &spufs_proxydma_info_fops, 0444,
+                sizeof(struct spu_proxydma_info)},
         { "tid", &spufs_tid_fops, 0444, },
         { "stat", &spufs_stat_fops, 0444, },
         { "switch_log", &spufs_switch_log_fops, 0444 },
         {},
 };
 
-struct tree_descr spufs_dir_nosched_contents[] = {
+struct spufs_tree_descr spufs_dir_nosched_contents[] = {
         { "capabilities", &spufs_caps_fops, 0444, },
-        { "mem",  &spufs_mem_fops,  0666, },
+        { "mem",  &spufs_mem_fops,  0666, LS_SIZE, },
         { "mbox", &spufs_mbox_fops, 0444, },
         { "ibox", &spufs_ibox_fops, 0444, },
         { "wbox", &spufs_wbox_fops, 0222, },
-        { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
-        { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
-        { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
+        { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
+        { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
+        { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
         { "signal1", &spufs_signal1_nosched_fops, 0222, },
         { "signal2", &spufs_signal2_nosched_fops, 0222, },
         { "signal1_type", &spufs_signal1_type, 0666, },
@@ -2609,7 +2665,7 @@ struct tree_descr spufs_dir_nosched_contents[] = {
         { "mfc", &spufs_mfc_fops, 0666, },
         { "cntl", &spufs_cntl_fops,  0666, },
         { "npc", &spufs_npc_ops, 0666, },
-        { "psmap", &spufs_psmap_fops, 0666, },
+        { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
         { "phys-id", &spufs_id_ops, 0666, },
         { "object-id", &spufs_object_id_ops, 0666, },
         { "tid", &spufs_tid_fops, 0444, },
@@ -2617,6 +2673,11 @@ struct tree_descr spufs_dir_nosched_contents[] = {
         {},
 };
 
+struct spufs_tree_descr spufs_dir_debug_contents[] = {
+        { ".ctx", &spufs_ctx_fops, 0444, },
+        {},
+};
+
 struct spufs_coredump_reader spufs_coredump_read[] = {
         { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])},
         { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) },
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index f407b2471855..7123472801d9 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -42,10 +42,19 @@
 
 #include "spufs.h"
 
+struct spufs_sb_info {
+        int debug;
+};
+
 static struct kmem_cache *spufs_inode_cache;
 char *isolated_loader;
 static int isolated_loader_size;
 
+static struct spufs_sb_info *spufs_get_sb_info(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
 static struct inode *
 spufs_alloc_inode(struct super_block *sb)
 {
@@ -109,7 +118,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, int mode,
-                struct spu_context *ctx)
+                size_t size, struct spu_context *ctx)
 {
         static struct inode_operations spufs_file_iops = {
                 .setattr = spufs_setattr,
@@ -125,6 +134,7 @@ spufs_new_file(struct super_block *sb, struct dentry *dentry,
         ret = 0;
         inode->i_op = &spufs_file_iops;
         inode->i_fop = fops;
+        inode->i_size = size;
         inode->i_private = SPUFS_I(inode)->i_ctx = get_spu_context(ctx);
         d_add(dentry, inode);
 out:
@@ -177,7 +187,7 @@ static int spufs_rmdir(struct inode *parent, struct dentry *dir)
         return simple_rmdir(parent, dir);
 }
 
-static int spufs_fill_dir(struct dentry *dir, struct tree_descr *files,
+static int spufs_fill_dir(struct dentry *dir, struct spufs_tree_descr *files,
                           int mode, struct spu_context *ctx)
 {
         struct dentry *dentry, *tmp;
@@ -189,7 +199,7 @@ static int spufs_fill_dir(struct dentry *dir, struct tree_descr *files,
                 if (!dentry)
                         goto out;
                 ret = spufs_new_file(dir->d_sb, dentry, files->ops,
-                                        files->mode & mode, ctx);
+                                        files->mode & mode, files->size, ctx);
                 if (ret)
                         goto out;
                 files++;
@@ -279,6 +289,13 @@ spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
         if (ret)
                 goto out_free_ctx;
 
+        if (spufs_get_sb_info(dir->i_sb)->debug)
+                ret = spufs_fill_dir(dentry, spufs_dir_debug_contents,
+                                mode, ctx);
+
+        if (ret)
+                goto out_free_ctx;
+
         d_instantiate(dentry, inode);
         dget(dentry);
         dir->i_nlink++;
@@ -639,18 +656,19 @@ out:
 
 /* File system initialization */
 enum {
-        Opt_uid, Opt_gid, Opt_mode, Opt_err,
+        Opt_uid, Opt_gid, Opt_mode, Opt_debug, Opt_err,
 };
 
 static match_table_t spufs_tokens = {
-        { Opt_uid,  "uid=%d" },
-        { Opt_gid,  "gid=%d" },
-        { Opt_mode, "mode=%o" },
-        { Opt_err,   NULL  },
+        { Opt_uid,   "uid=%d" },
+        { Opt_gid,   "gid=%d" },
+        { Opt_mode,  "mode=%o" },
+        { Opt_debug, "debug" },
+        { Opt_err,    NULL  },
 };
 
 static int
-spufs_parse_options(char *options, struct inode *root)
+spufs_parse_options(struct super_block *sb, char *options, struct inode *root)
 {
         char *p;
         substring_t args[MAX_OPT_ARGS];
@@ -678,6 +696,9 @@ spufs_parse_options(char *options, struct inode *root)
                                 return 0;
                         root->i_mode = option | S_IFDIR;
                         break;
+                case Opt_debug:
+                        spufs_get_sb_info(sb)->debug = 1;
+                        break;
                 default:
                         return 0;
                 }
@@ -736,7 +757,7 @@ spufs_create_root(struct super_block *sb, void *data)
         SPUFS_I(inode)->i_ctx = NULL;
 
         ret = -EINVAL;
-        if (!spufs_parse_options(data, inode))
+        if (!spufs_parse_options(sb, data, inode))
                 goto out_iput;
 
         ret = -ENOMEM;
@@ -754,6 +775,7 @@ out:
 static int
 spufs_fill_super(struct super_block *sb, void *data, int silent)
 {
+        struct spufs_sb_info *info;
         static struct super_operations s_ops = {
                 .alloc_inode = spufs_alloc_inode,
                 .destroy_inode = spufs_destroy_inode,
@@ -765,11 +787,16 @@ spufs_fill_super(struct super_block *sb, void *data, int silent)
 
         save_mount_options(sb, data);
 
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
         sb->s_maxbytes = MAX_LFS_FILESIZE;
         sb->s_blocksize = PAGE_CACHE_SIZE;
         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
         sb->s_magic = SPUFS_MAGIC;
         sb->s_op = &s_ops;
+        sb->s_fs_info = info;
 
         return spufs_create_root(sb, data);
 }
diff --git a/arch/powerpc/platforms/cell/spufs/run.c b/arch/powerpc/platforms/cell/spufs/run.c
index b7493b865812..f7edba6cb795 100644
--- a/arch/powerpc/platforms/cell/spufs/run.c
+++ b/arch/powerpc/platforms/cell/spufs/run.c
@@ -27,7 +27,6 @@ void spufs_stop_callback(struct spu *spu, int irq)
                 switch(irq) {
                 case 0 :
                         ctx->csa.class_0_pending = spu->class_0_pending;
-                        ctx->csa.class_0_dsisr = spu->class_0_dsisr;
                         ctx->csa.class_0_dar = spu->class_0_dar;
                         break;
                 case 1 :
@@ -51,18 +50,22 @@ int spu_stopped(struct spu_context *ctx, u32 *stat)
         u64 dsisr;
         u32 stopped;
 
-        *stat = ctx->ops->status_read(ctx);
-
-        if (test_bit(SPU_SCHED_NOTIFY_ACTIVE, &ctx->sched_flags))
-                return 1;
-
         stopped = SPU_STATUS_INVALID_INSTR | SPU_STATUS_SINGLE_STEP |
                 SPU_STATUS_STOPPED_BY_HALT | SPU_STATUS_STOPPED_BY_STOP;
-        if (!(*stat & SPU_STATUS_RUNNING) && (*stat & stopped))
+
+top:
+        *stat = ctx->ops->status_read(ctx);
+        if (*stat & stopped) {
+                /*
+                 * If the spu hasn't finished stopping, we need to
+                 * re-read the register to get the stopped value.
+                 */
+                if (*stat & SPU_STATUS_RUNNING)
+                        goto top;
                 return 1;
+        }
 
-        dsisr = ctx->csa.class_0_dsisr;
-        if (dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED))
+        if (test_bit(SPU_SCHED_NOTIFY_ACTIVE, &ctx->sched_flags))
                 return 1;
 
         dsisr = ctx->csa.class_1_dsisr;
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index 745dd51ec37f..34654743363d 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -230,19 +230,23 @@ static void spu_bind_context(struct spu *spu, struct spu_context *ctx)
         ctx->stats.slb_flt_base = spu->stats.slb_flt;
         ctx->stats.class2_intr_base = spu->stats.class2_intr;
 
+        spu_associate_mm(spu, ctx->owner);
+
+        spin_lock_irq(&spu->register_lock);
         spu->ctx = ctx;
         spu->flags = 0;
         ctx->spu = spu;
         ctx->ops = &spu_hw_ops;
         spu->pid = current->pid;
         spu->tgid = current->tgid;
-        spu_associate_mm(spu, ctx->owner);
         spu->ibox_callback = spufs_ibox_callback;
         spu->wbox_callback = spufs_wbox_callback;
         spu->stop_callback = spufs_stop_callback;
         spu->mfc_callback = spufs_mfc_callback;
-        mb();
+        spin_unlock_irq(&spu->register_lock);
+
         spu_unmap_mappings(ctx);
+
         spu_switch_log_notify(spu, ctx, SWITCH_LOG_START, 0);
         spu_restore(&ctx->csa, spu);
         spu->timestamp = jiffies;
@@ -403,6 +407,8 @@ static int has_affinity(struct spu_context *ctx)
  */
 static void spu_unbind_context(struct spu *spu, struct spu_context *ctx)
 {
+        u32 status;
+
         spu_context_trace(spu_unbind_context__enter, ctx, spu);
 
         spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
@@ -423,18 +429,22 @@ static void spu_unbind_context(struct spu *spu, struct spu_context *ctx)
         spu_unmap_mappings(ctx);
         spu_save(&ctx->csa, spu);
         spu_switch_log_notify(spu, ctx, SWITCH_LOG_STOP, 0);
+
+        spin_lock_irq(&spu->register_lock);
         spu->timestamp = jiffies;
         ctx->state = SPU_STATE_SAVED;
         spu->ibox_callback = NULL;
         spu->wbox_callback = NULL;
         spu->stop_callback = NULL;
         spu->mfc_callback = NULL;
-        spu_associate_mm(spu, NULL);
         spu->pid = 0;
         spu->tgid = 0;
         ctx->ops = &spu_backing_ops;
         spu->flags = 0;
         spu->ctx = NULL;
+        spin_unlock_irq(&spu->register_lock);
+
+        spu_associate_mm(spu, NULL);
 
         ctx->stats.slb_flt +=
                 (spu->stats.slb_flt - ctx->stats.slb_flt_base);
@@ -444,6 +454,9 @@ static void spu_unbind_context(struct spu *spu, struct spu_context *ctx)
         /* This maps the underlying spu state to idle */
         spuctx_switch_state(ctx, SPU_UTIL_IDLE_LOADED);
         ctx->spu = NULL;
+
+        if (spu_stopped(ctx, &status))
+                wake_up_all(&ctx->stop_wq);
 }
 
 /**
@@ -886,7 +899,8 @@ static noinline void spusched_tick(struct spu_context *ctx)
                         spu_add_to_rq(ctx);
         } else {
                 spu_context_nospu_trace(spusched_tick__newslice, ctx);
-                ctx->time_slice++;
+                if (!ctx->time_slice)
+                        ctx->time_slice++;
         }
 out:
         spu_release(ctx);
@@ -980,6 +994,7 @@ void spuctx_switch_state(struct spu_context *ctx,
         struct timespec ts;
         struct spu *spu;
         enum spu_utilization_state old_state;
+        int node;
 
         ktime_get_ts(&ts);
         curtime = timespec_to_ns(&ts);
@@ -1001,6 +1016,11 @@ void spuctx_switch_state(struct spu_context *ctx,
                 spu->stats.times[old_state] += delta;
                 spu->stats.util_state = new_state;
                 spu->stats.tstamp = curtime;
+                node = spu->node;
+                if (old_state == SPU_UTIL_USER)
+                        atomic_dec(&cbe_spu_info[node].busy_spus);
+                if (new_state == SPU_UTIL_USER);
+                        atomic_inc(&cbe_spu_info[node].busy_spus);
         }
 }
 
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 454c277c1457..8ae8ef9dfc22 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -32,6 +32,13 @@
 #include <asm/spu_csa.h>
 #include <asm/spu_info.h>
 
+#define SPUFS_PS_MAP_SIZE       0x20000
+#define SPUFS_MFC_MAP_SIZE      0x1000
+#define SPUFS_CNTL_MAP_SIZE     0x1000
+#define SPUFS_CNTL_MAP_SIZE     0x1000
+#define SPUFS_SIGNAL_MAP_SIZE   PAGE_SIZE
+#define SPUFS_MSS_MAP_SIZE      0x1000
+
 /* The magic number for our file system */
 enum {
         SPUFS_MAGIC = 0x23c9b64e,
@@ -228,8 +235,16 @@ struct spufs_inode_info {
 #define SPUFS_I(inode) \
         container_of(inode, struct spufs_inode_info, vfs_inode)
 
-extern struct tree_descr spufs_dir_contents[];
-extern struct tree_descr spufs_dir_nosched_contents[];
+struct spufs_tree_descr {
+        const char *name;
+        const struct file_operations *ops;
+        int mode;
+        size_t size;
+};
+
+extern struct spufs_tree_descr spufs_dir_contents[];
+extern struct spufs_tree_descr spufs_dir_nosched_contents[];
+extern struct spufs_tree_descr spufs_dir_debug_contents[];
 
 /* system call implementation */
 extern struct spufs_calls spufs_calls;
diff --git a/arch/powerpc/platforms/cell/spufs/sputrace.c b/arch/powerpc/platforms/cell/spufs/sputrace.c
index 53202422ba72..8c0e95766a62 100644
--- a/arch/powerpc/platforms/cell/spufs/sputrace.c
+++ b/arch/powerpc/platforms/cell/spufs/sputrace.c
@@ -182,10 +182,10 @@ struct spu_probe spu_probes[] = {
         { "spu_yield__enter", "ctx %p", spu_context_nospu_event },
         { "spu_deactivate__enter", "ctx %p", spu_context_nospu_event },
         { "__spu_deactivate__unload", "ctx %p spu %p", spu_context_event },
-        { "spufs_ps_nopfn__enter", "ctx %p", spu_context_nospu_event },
-        { "spufs_ps_nopfn__sleep", "ctx %p", spu_context_nospu_event },
-        { "spufs_ps_nopfn__wake", "ctx %p spu %p", spu_context_event },
-        { "spufs_ps_nopfn__insert", "ctx %p spu %p", spu_context_event },
+        { "spufs_ps_fault__enter", "ctx %p", spu_context_nospu_event },
+        { "spufs_ps_fault__sleep", "ctx %p", spu_context_nospu_event },
+        { "spufs_ps_fault__wake", "ctx %p spu %p", spu_context_event },
+        { "spufs_ps_fault__insert", "ctx %p spu %p", spu_context_event },
         { "spu_acquire_saved__enter", "ctx %p", spu_context_nospu_event },
         { "destroy_spu_context__enter", "ctx %p", spu_context_nospu_event },
         { "spufs_stop_callback__enter", "ctx %p spu %p", spu_context_event },