[PATCH 09/14] powerpc/vas: Update CSB and notify process for fault CRBs

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

Signed-off-by: Sukadev Bhattiprolu <redacted>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
 arch/powerpc/platforms/powernv/vas-fault.c | 121 ++++++++++++++++++++++++++++-
 1 file changed, 120 insertions(+), 1 deletion(-)

diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index 7a8b2b5..dd27649 100644
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c

@@ -36,6 +36,124 @@ void vas_wakeup_fault_handler(int virq, void *arg)
 	wake_up(&vinst->fault_wq);
 }
 
+static void notify_process(pid_t pid, u64 fault_addr)
+{
+	int rc;
+	struct kernel_siginfo info;
+
+	memset(&info, 0, sizeof(info));
+
+	info.si_signo = SIGSEGV;
+	info.si_errno = EFAULT;
+	info.si_code = SEGV_MAPERR;
+
+	info.si_addr = (void *)fault_addr;
+	rcu_read_lock();
+	rc = kill_pid_info(SIGSEGV, &info, find_vpid(pid));
+	rcu_read_unlock();
+
+	pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__, pid, rc);
+}
+
+/*
+ * Update the CSB to indicate a translation error.
+ *
+ * If the fault is in the CSB address itself or if we are unable to
+ * update the CSB, send a signal to the process, because we have no
+ * other way of notifying the user process.
+ *
+ * Remaining settings in the CSB are based on wait_for_csb() of
+ * NX-GZIP.
+ */
+static void update_csb(struct vas_window *window,
+			struct coprocessor_request_block *crb)
+{
+	int rc;
+	pid_t pid;
+	int task_exit = 0;
+	void __user *csb_addr;
+	struct task_struct *tsk;
+	struct coprocessor_status_block csb;
+
+	/*
+	 * NX user space windows can not be opened for task->mm=NULL
+	 * and faults will not be generated for kernel requests.
+	 */
+	if (!window->mm || !window->user_win)
+		return;
+
+	csb_addr = (void *)__be64_to_cpu(crb->csb_addr);
+
+	csb.cc = CSB_CC_TRANSLATION;
+	csb.ce = CSB_CE_TERMINATION;
+	csb.cs = 0;
+	csb.count = 0;
+
+	/*
+	 * Returns the fault address in CPU format since it is passed with
+	 * signal. But if the user space expects BE format, need changes.
+	 * i.e either kernel (here) or user should convert to CPU format.
+	 * Not both!
+	 */
+	csb.address = crb_nx_fault_addr(crb);
+	csb.flags = 0;
+
+	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.
+	 */
+	smp_mb();
+	if (!rc) {
+		csb.flags = CSB_V;
+		rc = copy_to_user(csb_addr, &csb, sizeof(u8));
+	}
+	unuse_mm(window->mm);
+
+	/* Success */
+	if (!rc)
+		return;
+
+	/*
+	 * User space passed invalid CSB address, Notify process with
+	 * SEGV signal.
+	 */
+	tsk = get_pid_task(window->pid, PIDTYPE_PID);
+	/*
+	 * Send window will be closed after processing all NX requests
+	 * and process exits after closing all windows. In multi-thread
+	 * applications, thread may not exists, but does not close FD
+	 * (means send window) upon exit. Parent thread (tgid) can use
+	 * and close the window later.
+	 */
+	if (tsk) {
+		if (tsk->flags & PF_EXITING)
+			task_exit = 1;
+		put_task_struct(tsk);
+		pid = vas_window_pid(window);
+	} else {
+		pid = vas_window_tgid(window);
+
+		rcu_read_lock();
+		tsk = find_task_by_vpid(pid);
+		if (!tsk) {
+			rcu_read_unlock();
+			return;
+		}
+		if (tsk->flags & PF_EXITING)
+			task_exit = 1;
+		rcu_read_unlock();
+	}
+
+	/* Do not notify if the task is exiting. */
+	if (!task_exit) {
+		pr_err("Invalid CSB address 0x%p signalling pid(%d)\n",
+				csb_addr, pid);
+		notify_process(pid, (u64)csb_addr);
+	}
+}
+
 /*
  * Process CRBs that we receive on the fault window.
  */

@@ -97,7 +215,7 @@ static void process_fault_crbs(struct vas_instance *vinst)
 
 		if (IS_ERR(window)) {
 			/*
-			 * What now? We got an interrupt about a specific send
+			 * We got an interrupt about a specific send
 			 * window but we can't find that window and we can't
 			 * even clean it up (return credit).
 			 * But we should not get here.

@@ -111,6 +229,7 @@ static void process_fault_crbs(struct vas_instance *vinst)
 			return;
 		}
 
+		update_csb(window, crb);
 	} while (true);
 }
 

-- 
1.8.3.1

Shouldn't this use force_sig_fault_to_task instead?

The pid is later used for sending the signal again, why not keep the
reference?

Why does this not need a reference to the task, but the other one does?

"Linuxppc-dev" [off-list ref]
wrote on 11/27/2019 12:46:09 AM:

quoted

+static void notify_process(pid_t pid, u64 fault_addr)
+{
+   int rc;
+   struct kernel_siginfo info;
+
+   memset(&info, 0, sizeof(info));
+
+   info.si_signo = SIGSEGV;
+   info.si_errno = EFAULT;
+   info.si_code = SEGV_MAPERR;
+
+   info.si_addr = (void *)fault_addr;
+   rcu_read_lock();
+   rc = kill_pid_info(SIGSEGV, &info, find_vpid(pid));
+   rcu_read_unlock();
+
+   pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__, pid,

rc);

quoted

+}

Shouldn't this use force_sig_fault_to_task instead?

quoted

+   /*
+    * User space passed invalid CSB address, Notify process with
+    * SEGV signal.
+    */
+   tsk = get_pid_task(window->pid, PIDTYPE_PID);
+   /*
+    * Send window will be closed after processing all NX requests
+    * and process exits after closing all windows. In multi-thread
+    * applications, thread may not exists, but does not close FD
+    * (means send window) upon exit. Parent thread (tgid) can use
+    * and close the window later.
+    */
+   if (tsk) {
+      if (tsk->flags & PF_EXITING)
+         task_exit = 1;
+      put_task_struct(tsk);
+      pid = vas_window_pid(window);

The pid is later used for sending the signal again, why not keep the
reference?

Sorry, Not dropping the PID reference here, Happens only when window
closed. If the task for this PID is not available, looking for tgid in the
case of multi-thread process.

quoted

+   } else {
+      pid = vas_window_tgid(window);
+
+      rcu_read_lock();
+      tsk = find_task_by_vpid(pid);
+      if (!tsk) {
+         rcu_read_unlock();
+         return;
+      }
+      if (tsk->flags & PF_EXITING)
+         task_exit = 1;
+      rcu_read_unlock();

Why does this not need a reference to the task, but the other one does?

Window is opened with open() and ioctl(fd), will be closed either by close
(fd) explicitly or release FD during process exit.

Process closes all open windows when it exits. So we do not need to keep
the reference for this case. In multi-thread case, child thread can open a
window, but it does not release FD when it exits. Parent thread (tgid) can
continue use this window and closes it upon its exit. So taking reference
to PID in case if this pid is assigned to child thread to make sure its pid
is not reused until window is closed.

We are taking pid reference during window open and releases it when closing
the window.

Thanks
Haren

<div class="socmaildefaultfont" dir="ltr" style="font-family:Arial, Helvetica, sans-serif;font-size:10pt" ><div dir="ltr" ><font face="Default Monospace,Courier New,Courier,monospace" size="2" >&gt; &nbsp;<br>&gt; +static void notify_process(pid_t pid, u64 fault_addr)<br>&gt; +{<br>&gt; + int rc;<br>&gt; + struct kernel_siginfo info;<br>&gt; +<br>&gt; + memset(&amp;info, 0, sizeof(info));<br>&gt; +<br>&gt; + info.si_signo = SIGSEGV;<br>&gt; + info.si_errno = EFAULT;<br>&gt; + info.si_code = SEGV_MAPERR;<br>&gt; +<br>&gt; + info.si_addr = (void *)fault_addr;<br>&gt; + rcu_read_lock();<br>&gt; + rc = kill_pid_info(SIGSEGV, &amp;info, find_vpid(pid));<br>&gt; + rcu_read_unlock();<br>&gt; +<br>&gt; + pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__, pid, rc);<br>&gt; +}<br><br>Shouldn't this use force_sig_fault_to_task instead?</font><br>&nbsp;</div>
<div dir="ltr" ><font face="Default Monospace,Courier New,Courier,monospace" size="2" >User space send compression request as Coprocessor Request Block (CRB) with CSB (status block)to NX&nbsp;directly and polls on CSB address. NX updates CSB after&nbsp;processing the request. If NX sees&nbsp;fault on the request buffer or CSB,&nbsp;interrupts kernel. So generally CSB should be valid since it supposed to poll&nbsp;csb.flags.&nbsp;</font></div>
<div dir="ltr" >&nbsp;</div>
<div dir="ltr" ><font face="Default Monospace,Courier New,Courier,monospace" size="2" >If an application does not behave as expected&nbsp;or NX pastes wrong information, an error message will be printed and send signal to an application. So&nbsp;applications or libnxz can ignore SEGV signal or can have their own handlers.&nbsp;</font><br>&nbsp;</div></div><BR>