powerpc/vas: Update CSB and notify process for fault CRBs

Applications polls on CSB for the status update after requests are
issued. NX process these requests and update the CSB with the status.
If it encounters translation error, pastes CRB in fault FIFO and
raises an interrupt. The kernel handles fault by reading CRB from
fault FIFO and process the fault CRB.

For each fault CRB, update fault address in CRB (fault_storage_addr)
and translation error status in CSB so that user space can touch the
fault address and resend the request. If the user space passed invalid
CSB address send signal to process with SIGSEGV.

In the case of multi-thread applications, child thread may not be
available. So if the task is not running, send signal to tgid.

Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/1587017022.2275.1063.camel@hbabu-laptop

diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index 0da8358b357dba27efb11b6f749b18ca8a32a704..354577dcf2dc060f8a8fd6e952553e22579518e9 100644 (file)
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -11,6 +11,7 @@
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/kthread.h>
+#include <linux/sched/signal.h>
 #include <linux/mmu_context.h>
 #include <asm/icswx.h>
 
@@ -25,6 +26,128 @@
  */
 #define VAS_FAULT_WIN_FIFO_SIZE        (4 << 20)
 
+/*
+ * Update the CSB to indicate a translation error.
+ *
+ * User space will be polling on CSB after the request is issued.
+ * If NX can handle the request without any issues, it updates CSB.
+ * Whereas if NX encounters page fault, the kernel will handle the
+ * fault and update CSB with translation error.
+ *
+ * If we are unable to update the CSB means copy_to_user failed due to
+ * invalid csb_addr, send a signal to the process.
+ */
+static void update_csb(struct vas_window *window,
+                       struct coprocessor_request_block *crb)
+{
+       struct coprocessor_status_block csb;
+       struct kernel_siginfo info;
+       struct task_struct *tsk;
+       void __user *csb_addr;
+       struct pid *pid;
+       int rc;
+
+       /*
+        * NX user space windows can not be opened for task->mm=NULL
+        * and faults will not be generated for kernel requests.
+        */
+       if (WARN_ON_ONCE(!window->mm || !window->user_win))
+               return;
+
+       csb_addr = (void __user *)be64_to_cpu(crb->csb_addr);
+
+       memset(&csb, 0, sizeof(csb));
+       csb.cc = CSB_CC_TRANSLATION;
+       csb.ce = CSB_CE_TERMINATION;
+       csb.cs = 0;
+       csb.count = 0;
+
+       /*
+        * NX operates and returns in BE format as defined CRB struct.
+        * So saves fault_storage_addr in BE as NX pastes in FIFO and
+        * expects user space to convert to CPU format.
+        */
+       csb.address = crb->stamp.nx.fault_storage_addr;
+       csb.flags = 0;
+
+       pid = window->pid;
+       tsk = get_pid_task(pid, PIDTYPE_PID);
+       /*
+        * Process closes send window after all pending NX requests are
+        * completed. In multi-thread applications, a child thread can
+        * open a window and can exit without closing it. May be some
+        * requests are pending or this window can be used by other
+        * threads later. We should handle faults if NX encounters
+        * pages faults on these requests. Update CSB with translation
+        * error and fault address. If csb_addr passed by user space is
+        * invalid, send SEGV signal to pid saved in window. If the
+        * child thread is not running, send the signal to tgid.
+        * Parent thread (tgid) will close this window upon its exit.
+        *
+        * pid and mm references are taken when window is opened by
+        * process (pid). So tgid is used only when child thread opens
+        * a window and exits without closing it.
+        */
+       if (!tsk) {
+               pid = window->tgid;
+               tsk = get_pid_task(pid, PIDTYPE_PID);
+               /*
+                * Parent thread (tgid) will be closing window when it
+                * exits. So should not get here.
+                */
+               if (WARN_ON_ONCE(!tsk))
+                       return;
+       }
+
+       /* Return if the task is exiting. */
+       if (tsk->flags & PF_EXITING) {
+               put_task_struct(tsk);
+               return;
+       }
+
+       use_mm(window->mm);
+       rc = copy_to_user(csb_addr, &csb, sizeof(csb));
+       /*
+        * User space polls on csb.flags (first byte). So add barrier
+        * then copy first byte with csb flags update.
+        */
+       if (!rc) {
+               csb.flags = CSB_V;
+               /* Make sure update to csb.flags is visible now */
+               smp_mb();
+               rc = copy_to_user(csb_addr, &csb, sizeof(u8));
+       }
+       unuse_mm(window->mm);
+       put_task_struct(tsk);
+
+       /* Success */
+       if (!rc)
+               return;
+
+       pr_debug("Invalid CSB address 0x%p signalling pid(%d)\n",
+                       csb_addr, pid_vnr(pid));
+
+       clear_siginfo(&info);
+       info.si_signo = SIGSEGV;
+       info.si_errno = EFAULT;
+       info.si_code = SEGV_MAPERR;
+       info.si_addr = csb_addr;
+
+       /*
+        * process will be polling on csb.flags after request is sent to
+        * NX. So generally CSB update should not fail except when an
+        * application passes invalid csb_addr. So an error message will
+        * be displayed and leave it to user space whether to ignore or
+        * handle this signal.
+        */
+       rcu_read_lock();
+       rc = kill_pid_info(SIGSEGV, &info, pid);
+       rcu_read_unlock();
+
+       pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__,
+                       pid_vnr(pid), rc);
+}
+
 /*
  * Process valid CRBs in fault FIFO.
  * NX process user space requests, return credit and update the status
@@ -124,8 +247,9 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data)
                                vinst->fault_crbs);
 
                        WARN_ON_ONCE(1);
+               } else {
+                       update_csb(window, crb);
                }
-
        }
 }