* [PATCH V2 01/13] powerpc/vas: Describe vas-port and interrupts properties
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
@ 2019-12-09 3:26 ` Haren Myneni
2019-12-09 3:27 ` [PATCH V2 02/13] powerpc/vas: Define nx_fault_stamp in coprocessor_request_block Haren Myneni
` (13 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:26 UTC (permalink / raw)
To: mpe
Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev, hbabu
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
Documentation/devicetree/bindings/powerpc/ibm,vas.txt | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/Documentation/devicetree/bindings/powerpc/ibm,vas.txt b/Documentation/devicetree/bindings/powerpc/ibm,vas.txt
index bf11d2f..12de08b 100644
--- a/Documentation/devicetree/bindings/powerpc/ibm,vas.txt
+++ b/Documentation/devicetree/bindings/powerpc/ibm,vas.txt
@@ -11,6 +11,8 @@ Required properties:
window context start and length, OS/User window context start and length,
"Paste address" start and length, "Paste window id" start bit and number
of bits)
+- ibm,vas-port : Port address for the interrupt.
+- interrupts: IRQ value for each VAS instance and level.
Example:
@@ -18,5 +20,8 @@ Example:
compatible = "ibm,vas", "ibm,power9-vas";
reg = <0x6019100000000 0x2000000 0x6019000000000 0x100000000 0x8000000000000 0x100000000 0x20 0x10>;
name = "vas";
+ interrupts = <0x1f 0>;
+ interrupt-parent = <&mpic>;
ibm,vas-id = <0x1>;
+ ibm,vas-port = <0x6010001000000>;
};
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 02/13] powerpc/vas: Define nx_fault_stamp in coprocessor_request_block
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
2019-12-09 3:26 ` [PATCH V2 01/13] powerpc/vas: Describe vas-port and interrupts properties Haren Myneni
@ 2019-12-09 3:27 ` Haren Myneni
2019-12-09 3:29 ` [PATCH V2 03/13] powerpc/vas: Read interrupts and vas-port device tree properties Haren Myneni
` (12 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:27 UTC (permalink / raw)
To: mpe
Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev, hbabu
Kernel sets fault address and status in CRB for NX page fault on user
space address after processing page fault. User space gets the signal
and handles the fault mentioned in CRB by bringing the page in to
memory and send NX request again.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/include/asm/icswx.h | 18 +++++++++++++++++-
1 file changed, 17 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/include/asm/icswx.h b/arch/powerpc/include/asm/icswx.h
index 9872f85..b233d1e 100644
--- a/arch/powerpc/include/asm/icswx.h
+++ b/arch/powerpc/include/asm/icswx.h
@@ -108,6 +108,17 @@ struct data_descriptor_entry {
__be64 address;
} __packed __aligned(DDE_ALIGN);
+/* 4.3.2 NX-stamped Fault CRB */
+
+#define NX_STAMP_ALIGN (0x10)
+
+struct nx_fault_stamp {
+ __be64 fault_storage_addr;
+ __be16 reserved;
+ __u8 flags;
+ __u8 fault_status;
+ __be32 pswid;
+} __packed __aligned(NX_STAMP_ALIGN);
/* Chapter 6.5.2 Coprocessor-Request Block (CRB) */
@@ -135,7 +146,12 @@ struct coprocessor_request_block {
struct coprocessor_completion_block ccb;
- u8 reserved[48];
+ union {
+ struct nx_fault_stamp nx;
+ u8 reserved[16];
+ } stamp;
+
+ u8 reserved[32];
struct coprocessor_status_block csb;
} __packed __aligned(CRB_ALIGN);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 03/13] powerpc/vas: Read interrupts and vas-port device tree properties
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
2019-12-09 3:26 ` [PATCH V2 01/13] powerpc/vas: Describe vas-port and interrupts properties Haren Myneni
2019-12-09 3:27 ` [PATCH V2 02/13] powerpc/vas: Define nx_fault_stamp in coprocessor_request_block Haren Myneni
@ 2019-12-09 3:29 ` Haren Myneni
2019-12-09 3:30 ` [PATCH V2 04/13] powerpc/vas: Setup fault window per VAS instance Haren Myneni
` (11 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:29 UTC (permalink / raw)
To: mpe
Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev, hbabu
Read interrupts and vas-port device tree properties per each VAS
instance. NX generates an interrupt when it sees page fault on the
request buffer. Interrupts property is used to setup IRQ for handing
the fault and set port value for each user space send window.
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas.c | 40 ++++++++++++++++++++++++++++--------
arch/powerpc/platforms/powernv/vas.h | 2 ++
2 files changed, 34 insertions(+), 8 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas.c b/arch/powerpc/platforms/powernv/vas.c
index ed9cc6d..40d8213 100644
--- a/arch/powerpc/platforms/powernv/vas.c
+++ b/arch/powerpc/platforms/powernv/vas.c
@@ -25,10 +25,11 @@
static int init_vas_instance(struct platform_device *pdev)
{
- int rc, cpu, vasid;
- struct resource *res;
- struct vas_instance *vinst;
struct device_node *dn = pdev->dev.of_node;
+ int rc, cpu, vasid, nresources = 5;
+ struct vas_instance *vinst;
+ struct resource *res;
+ uint64_t port;
rc = of_property_read_u32(dn, "ibm,vas-id", &vasid);
if (rc) {
@@ -36,7 +37,18 @@ static int init_vas_instance(struct platform_device *pdev)
return -ENODEV;
}
- if (pdev->num_resources != 4) {
+ rc = of_property_read_u64(dn, "ibm,vas-port", &port);
+ if (rc) {
+ pr_err("No ibm,vas-port property for %s?\n", pdev->name);
+ /* No interrupts property */
+ nresources = 4;
+ }
+
+ /*
+ * interrupts property is available with 'ibm,vas-port' property.
+ * 4 Resources and 1 IRQ if interrupts property is available.
+ */
+ if (pdev->num_resources != nresources) {
pr_err("Unexpected DT configuration for [%s, %d]\n",
pdev->name, vasid);
return -ENODEV;
@@ -51,6 +63,7 @@ static int init_vas_instance(struct platform_device *pdev)
mutex_init(&vinst->mutex);
vinst->vas_id = vasid;
vinst->pdev = pdev;
+ vinst->irq_port = port;
res = &pdev->resource[0];
vinst->hvwc_bar_start = res->start;
@@ -66,12 +79,23 @@ static int init_vas_instance(struct platform_device *pdev)
pr_err("Bad 'paste_win_id_shift' in DT, %llx\n", res->end);
goto free_vinst;
}
-
vinst->paste_win_id_shift = 63 - res->end;
- pr_devel("Initialized instance [%s, %d], paste_base 0x%llx, "
- "paste_win_id_shift 0x%llx\n", pdev->name, vasid,
- vinst->paste_base_addr, vinst->paste_win_id_shift);
+ /* interrupts property */
+ if (pdev->num_resources == 5) {
+ res = &pdev->resource[4];
+ vinst->virq = res->start;
+ if (vinst->virq <= 0) {
+ pr_err("IRQ resource is not available for [%s, %d]\n",
+ pdev->name, vasid);
+ vinst->virq = 0;
+ }
+ }
+
+ pr_devel("Initialized instance [%s, %d] paste_base 0x%llx paste_win_id_shift 0x%llx IRQ %d Port 0x%llx\n",
+ pdev->name, vasid, vinst->paste_base_addr,
+ vinst->paste_win_id_shift, vinst->virq,
+ vinst->irq_port);
for_each_possible_cpu(cpu) {
if (cpu_to_chip_id(cpu) == of_get_ibm_chip_id(dn))
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 5574aec..598608b 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -313,6 +313,8 @@ struct vas_instance {
u64 paste_base_addr;
u64 paste_win_id_shift;
+ u64 irq_port;
+ int virq;
struct mutex mutex;
struct vas_window *rxwin[VAS_COP_TYPE_MAX];
struct vas_window *windows[VAS_WINDOWS_PER_CHIP];
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 04/13] powerpc/vas: Setup fault window per VAS instance
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (2 preceding siblings ...)
2019-12-09 3:29 ` [PATCH V2 03/13] powerpc/vas: Read interrupts and vas-port device tree properties Haren Myneni
@ 2019-12-09 3:30 ` Haren Myneni
2019-12-12 12:55 ` Christoph Hellwig
2019-12-09 3:31 ` [PATCH V2 05/13] powerpc/vas: Setup thread IRQ handler " Haren Myneni
` (10 subsequent siblings)
14 siblings, 1 reply; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:30 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
Setup fault window for each VAS instance. When NX gets fault on request
buffer, write fault CRBs in the corresponding fault FIFO and then sends
an interrupt to the OS.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas-fault.c | 73 +++++++++++++++++++++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 3 +-
arch/powerpc/platforms/powernv/vas.c | 24 ++++++++++
arch/powerpc/platforms/powernv/vas.h | 5 ++
5 files changed, 105 insertions(+), 2 deletions(-)
create mode 100644 arch/powerpc/platforms/powernv/vas-fault.c
diff --git a/arch/powerpc/platforms/powernv/Makefile b/arch/powerpc/platforms/powernv/Makefile
index a3ac964..74c2246 100644
--- a/arch/powerpc/platforms/powernv/Makefile
+++ b/arch/powerpc/platforms/powernv/Makefile
@@ -17,6 +17,6 @@ obj-$(CONFIG_MEMORY_FAILURE) += opal-memory-errors.o
obj-$(CONFIG_OPAL_PRD) += opal-prd.o
obj-$(CONFIG_PERF_EVENTS) += opal-imc.o
obj-$(CONFIG_PPC_MEMTRACE) += memtrace.o
-obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o
+obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o vas-fault.o
obj-$(CONFIG_OCXL_BASE) += ocxl.o
obj-$(CONFIG_SCOM_DEBUGFS) += opal-xscom.o
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
new file mode 100644
index 0000000..b0258ed
--- /dev/null
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * VAS Fault handling.
+ * Copyright 2019, IBM Corporation
+ */
+
+#define pr_fmt(fmt) "vas: " fmt
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/kthread.h>
+#include <asm/icswx.h>
+
+#include "vas.h"
+
+/*
+ * The maximum FIFO size for fault window can be 8MB
+ * (VAS_RX_FIFO_SIZE_MAX). Using 4MB FIFO since each VAS
+ * instance will be having fault window.
+ * 8MB FIFO can be used if expects more faults for each VAS
+ * instance.
+ */
+#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
+
+/*
+ * Fault window is opened per VAS instance. NX pastes fault CRB in fault
+ * FIFO upon page faults.
+ */
+int vas_setup_fault_window(struct vas_instance *vinst)
+{
+ struct vas_rx_win_attr attr;
+
+ vinst->fault_fifo_size = VAS_FAULT_WIN_FIFO_SIZE;
+ vinst->fault_fifo = kzalloc(vinst->fault_fifo_size, GFP_KERNEL);
+ if (!vinst->fault_fifo) {
+ pr_err("Unable to alloc %d bytes for fault_fifo\n",
+ vinst->fault_fifo_size);
+ return -ENOMEM;
+ }
+
+ vas_init_rx_win_attr(&attr, VAS_COP_TYPE_FAULT);
+
+ attr.rx_fifo_size = vinst->fault_fifo_size;
+ attr.rx_fifo = vinst->fault_fifo;
+
+ /*
+ * Max creds is based on number of CRBs can fit in the FIFO.
+ * (fault_fifo_size/CRB_SIZE). If 8MB FIFO is used, max creds
+ * will be 0xffff since the receive creds field is 16bits wide.
+ */
+ attr.wcreds_max = vinst->fault_fifo_size / CRB_SIZE;
+ attr.lnotify_lpid = 0;
+ attr.lnotify_pid = mfspr(SPRN_PID);
+ attr.lnotify_tid = mfspr(SPRN_PID);
+
+ vinst->fault_win = vas_rx_win_open(vinst->vas_id, VAS_COP_TYPE_FAULT,
+ &attr);
+
+ if (IS_ERR(vinst->fault_win)) {
+ pr_err("VAS: Error %ld opening FaultWin\n",
+ PTR_ERR(vinst->fault_win));
+ kfree(vinst->fault_fifo);
+ return PTR_ERR(vinst->fault_win);
+ }
+
+ pr_devel("VAS: Created FaultWin %d, LPID/PID/TID [%d/%d/%d]\n",
+ vinst->fault_win->winid, attr.lnotify_lpid,
+ attr.lnotify_pid, attr.lnotify_tid);
+
+ return 0;
+}
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 0c0d27d..f07f49a 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -827,9 +827,10 @@ void vas_init_rx_win_attr(struct vas_rx_win_attr *rxattr, enum vas_cop_type cop)
rxattr->fault_win = true;
rxattr->notify_disable = true;
rxattr->rx_wcred_mode = true;
- rxattr->tx_wcred_mode = true;
rxattr->rx_win_ord_mode = true;
rxattr->tx_win_ord_mode = true;
+ rxattr->rej_no_credit = true;
+ rxattr->tc_mode = VAS_THRESH_DISABLED;
} else if (cop == VAS_COP_TYPE_FTW) {
rxattr->user_win = true;
rxattr->intr_disable = true;
diff --git a/arch/powerpc/platforms/powernv/vas.c b/arch/powerpc/platforms/powernv/vas.c
index 40d8213..ec34c06 100644
--- a/arch/powerpc/platforms/powernv/vas.c
+++ b/arch/powerpc/platforms/powernv/vas.c
@@ -23,6 +23,15 @@
static DEFINE_PER_CPU(int, cpu_vas_id);
+static int vas_irq_fault_window_setup(struct vas_instance *vinst)
+{
+ int rc = 0;
+
+ rc = vas_setup_fault_window(vinst);
+
+ return rc;
+}
+
static int init_vas_instance(struct platform_device *pdev)
{
struct device_node *dn = pdev->dev.of_node;
@@ -106,6 +115,21 @@ static int init_vas_instance(struct platform_device *pdev)
list_add(&vinst->node, &vas_instances);
mutex_unlock(&vas_mutex);
+ /*
+ * IRQ and fault handling setup is needed only for user space
+ * send windows.
+ */
+ if (vinst->virq) {
+ rc = vas_irq_fault_window_setup(vinst);
+ /*
+ * Fault window is used only for user space send windows.
+ * So if vinst->virq is NULL, tx_win_open returns -ENODEV
+ * for user space.
+ */
+ if (rc)
+ vinst->virq = 0;
+ }
+
vas_instance_init_dbgdir(vinst);
dev_set_drvdata(&pdev->dev, vinst);
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 598608b..9f08daa 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -315,6 +315,10 @@ struct vas_instance {
u64 irq_port;
int virq;
+ int fault_fifo_size;
+ void *fault_fifo;
+ struct vas_window *fault_win; /* Fault window */
+
struct mutex mutex;
struct vas_window *rxwin[VAS_COP_TYPE_MAX];
struct vas_window *windows[VAS_WINDOWS_PER_CHIP];
@@ -408,6 +412,7 @@ struct vas_winctx {
extern void vas_instance_init_dbgdir(struct vas_instance *vinst);
extern void vas_window_init_dbgdir(struct vas_window *win);
extern void vas_window_free_dbgdir(struct vas_window *win);
+extern int vas_setup_fault_window(struct vas_instance *vinst);
static inline void vas_log_write(struct vas_window *win, char *name,
void *regptr, u64 val)
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH V2 04/13] powerpc/vas: Setup fault window per VAS instance
2019-12-09 3:30 ` [PATCH V2 04/13] powerpc/vas: Setup fault window per VAS instance Haren Myneni
@ 2019-12-12 12:55 ` Christoph Hellwig
0 siblings, 0 replies; 23+ messages in thread
From: Christoph Hellwig @ 2019-12-12 12:55 UTC (permalink / raw)
To: Haren Myneni
Cc: mpe, devicetree, mikey, herbert, npiggin, hch, sukadev, linuxppc-dev
On Sun, Dec 08, 2019 at 07:30:33PM -0800, Haren Myneni wrote:
> +static int vas_irq_fault_window_setup(struct vas_instance *vinst)
> +{
> + int rc = 0;
> +
> + rc = vas_setup_fault_window(vinst);
> +
> + return rc;
> +}
No real need for the local variable here.
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH V2 05/13] powerpc/vas: Setup thread IRQ handler per VAS instance
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (3 preceding siblings ...)
2019-12-09 3:30 ` [PATCH V2 04/13] powerpc/vas: Setup fault window per VAS instance Haren Myneni
@ 2019-12-09 3:31 ` Haren Myneni
2019-12-12 12:59 ` Christoph Hellwig
2019-12-09 3:32 ` [PATCH V2 06/13] powerpc/vas: Register NX with fault window ID and IRQ port value Haren Myneni
` (9 subsequent siblings)
14 siblings, 1 reply; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:31 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
Setup thread IRQ handler per each VAS instance. When NX sees a fault
on CRB, kernel gets an interrupt and vas_fault_handler will be
executed to process fault CRBs. Read all valid CRBs from fault FIFO,
determine the corresponding send window from CRB and process fault
requests.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-fault.c | 83 +++++++++++++++++++++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 60 +++++++++++++++++++++
arch/powerpc/platforms/powernv/vas.c | 15 +++++-
arch/powerpc/platforms/powernv/vas.h | 4 ++
4 files changed, 161 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index b0258ed..e1e34c6 100644
--- 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/mmu_context.h>
#include <asm/icswx.h>
#include "vas.h"
@@ -25,6 +26,88 @@
#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
/*
+ * Process CRBs that we receive on the fault window.
+ */
+irqreturn_t vas_fault_handler(int irq, void *data)
+{
+ struct vas_instance *vinst = (struct vas_instance *)data;
+ struct coprocessor_request_block buf, *crb;
+ struct vas_window *window;
+ void *fifo;
+
+ /*
+ * VAS can interrupt with multiple page faults. So process all
+ * valid CRBs within fault FIFO until reaches invalid CRB.
+ * NX updates nx_fault_stamp in CRB and pastes in fault FIFO.
+ * kernel retrives send window from parition send window ID
+ * (pswid) in nx_fault_stamp. So pswid should be non-zero and
+ * use this to check whether CRB is valid.
+ * After reading CRB entry, it is reset with 0's in fault FIFO.
+ *
+ * In case kernel receives another interrupt with different page
+ * fault and CRBs are processed by the previous handling, will be
+ * returned from this function when it sees invalid CRB (means 0's).
+ */
+ do {
+ mutex_lock(&vinst->mutex);
+
+ /*
+ * Advance the fault fifo pointer to next CRB.
+ * Use CRB_SIZE rather than sizeof(*crb) since the latter is
+ * aligned to CRB_ALIGN (256) but the CRB written to by VAS is
+ * only CRB_SIZE in len.
+ */
+ fifo = vinst->fault_fifo + (vinst->fault_crbs * CRB_SIZE);
+ crb = (struct coprocessor_request_block *)fifo;
+
+ /*
+ * pswid returned from NX will be in _be32, but just
+ * checking non-zero value to make sure the CRB is valid.
+ * Return if reached invalid CRB.
+ */
+ if (!crb->stamp.nx.pswid) {
+ mutex_unlock(&vinst->mutex);
+ return IRQ_HANDLED;
+ }
+
+ vinst->fault_crbs++;
+ if (vinst->fault_crbs == vinst->fault_fifo_size/CRB_SIZE)
+ vinst->fault_crbs = 0;
+
+ crb = &buf;
+ memcpy(crb, fifo, CRB_SIZE);
+ memset(fifo, 0, CRB_SIZE);
+ mutex_unlock(&vinst->mutex);
+
+ pr_devel("VAS[%d] fault_fifo %p, fifo %p, fault_crbs %d\n",
+ vinst->vas_id, vinst->fault_fifo, fifo,
+ vinst->fault_crbs);
+
+ window = vas_pswid_to_window(vinst,
+ be32_to_cpu(crb->stamp.nx.pswid));
+
+ if (IS_ERR(window)) {
+ /*
+ * 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.
+ */
+ pr_err("VAS[%d] fault_fifo %p, fifo %p, pswid 0x%x, fault_crbs %d bad CRB?\n",
+ vinst->vas_id, vinst->fault_fifo, fifo,
+ be32_to_cpu(crb->stamp.nx.pswid),
+ vinst->fault_crbs);
+
+ WARN_ON_ONCE(1);
+ return IRQ_HANDLED;
+ }
+
+ } while (true);
+
+ return IRQ_HANDLED;
+}
+
+/*
* Fault window is opened per VAS instance. NX pastes fault CRB in fault
* FIFO upon page faults.
*/
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index f07f49a..cec1b41 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -1041,6 +1041,15 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
}
} else {
/*
+ * Interrupt hanlder or fault window setup failed. Means
+ * NX can not generate fault for page fault. So not
+ * opening for user space tx window.
+ */
+ if (!vinst->virq) {
+ rc = -ENODEV;
+ goto free_window;
+ }
+ /*
* A user mapping must ensure that context switch issues
* CP_ABORT for this thread.
*/
@@ -1255,3 +1264,54 @@ int vas_win_close(struct vas_window *window)
return 0;
}
EXPORT_SYMBOL_GPL(vas_win_close);
+
+struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,
+ uint32_t pswid)
+{
+ int winid;
+ struct vas_window *window;
+
+ if (!pswid) {
+ pr_devel("%s: called for pswid 0!\n", __func__);
+ return ERR_PTR(-ESRCH);
+ }
+
+ decode_pswid(pswid, NULL, &winid);
+
+ if (winid >= VAS_WINDOWS_PER_CHIP)
+ return ERR_PTR(-ESRCH);
+
+ /*
+ * If application closes the window before the hardware
+ * returns the fault CRB, we should wait in vas_win_close()
+ * for the pending requests. so the window must be active
+ * and the process alive.
+ *
+ * If its a kernel process, we should not get any faults and
+ * should not get here.
+ */
+ window = vinst->windows[winid];
+
+ if (!window) {
+ pr_err("PSWID decode: Could not find window for winid %d pswid %d vinst 0x%p\n",
+ winid, pswid, vinst);
+ return NULL;
+ }
+
+ /*
+ * Do some sanity checks on the decoded window. Window should be
+ * NX GZIP user send window. FTW windows should not incur faults
+ * since their CRBs are ignored (not queued on FIFO or processed
+ * by NX).
+ */
+ if (!window->tx_win || !window->user_win || !window->nx_win ||
+ window->cop == VAS_COP_TYPE_FAULT ||
+ window->cop == VAS_COP_TYPE_FTW) {
+ pr_err("PSWID decode: id %d, tx %d, user %d, nx %d, cop %d\n",
+ winid, window->tx_win, window->user_win,
+ window->nx_win, window->cop);
+ WARN_ON(1);
+ }
+
+ return window;
+}
diff --git a/arch/powerpc/platforms/powernv/vas.c b/arch/powerpc/platforms/powernv/vas.c
index ec34c06..f741b81 100644
--- a/arch/powerpc/platforms/powernv/vas.c
+++ b/arch/powerpc/platforms/powernv/vas.c
@@ -14,6 +14,8 @@
#include <linux/of_platform.h>
#include <linux/of_address.h>
#include <linux/of.h>
+#include <linux/irqdomain.h>
+#include <linux/interrupt.h>
#include <asm/prom.h>
#include "vas.h"
@@ -25,9 +27,20 @@
static int vas_irq_fault_window_setup(struct vas_instance *vinst)
{
+ char devname[64];
int rc = 0;
- rc = vas_setup_fault_window(vinst);
+ snprintf(devname, sizeof(devname), "vas-%d", vinst->vas_id);
+ rc = request_threaded_irq(vinst->virq, NULL, vas_fault_handler,
+ IRQF_ONESHOT, devname, vinst);
+ if (rc) {
+ pr_err("VAS[%d]: Request IRQ(%d) failed with %d\n",
+ vinst->vas_id, vinst->virq, rc);
+ } else {
+ rc = vas_setup_fault_window(vinst);
+ if (rc)
+ free_irq(vinst->virq, vinst);
+ }
return rc;
}
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 9f08daa..879f5b4 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -315,6 +315,7 @@ struct vas_instance {
u64 irq_port;
int virq;
+ int fault_crbs;
int fault_fifo_size;
void *fault_fifo;
struct vas_window *fault_win; /* Fault window */
@@ -413,6 +414,9 @@ struct vas_winctx {
extern void vas_window_init_dbgdir(struct vas_window *win);
extern void vas_window_free_dbgdir(struct vas_window *win);
extern int vas_setup_fault_window(struct vas_instance *vinst);
+extern irqreturn_t vas_fault_handler(int irq, void *data);
+extern struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,
+ uint32_t pswid);
static inline void vas_log_write(struct vas_window *win, char *name,
void *regptr, u64 val)
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH V2 05/13] powerpc/vas: Setup thread IRQ handler per VAS instance
2019-12-09 3:31 ` [PATCH V2 05/13] powerpc/vas: Setup thread IRQ handler " Haren Myneni
@ 2019-12-12 12:59 ` Christoph Hellwig
0 siblings, 0 replies; 23+ messages in thread
From: Christoph Hellwig @ 2019-12-12 12:59 UTC (permalink / raw)
To: Haren Myneni
Cc: mpe, devicetree, mikey, herbert, npiggin, hch, sukadev, linuxppc-dev
On Sun, Dec 08, 2019 at 07:31:24PM -0800, Haren Myneni wrote:
>
> Setup thread IRQ handler per each VAS instance. When NX sees a fault
> on CRB, kernel gets an interrupt and vas_fault_handler will be
> executed to process fault CRBs. Read all valid CRBs from fault FIFO,
> determine the corresponding send window from CRB and process fault
> requests.
>
> Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
> Signed-off-by: Haren Myneni <haren@us.ibm.com>
> ---
> arch/powerpc/platforms/powernv/vas-fault.c | 83 +++++++++++++++++++++++++++++
> arch/powerpc/platforms/powernv/vas-window.c | 60 +++++++++++++++++++++
> arch/powerpc/platforms/powernv/vas.c | 15 +++++-
> arch/powerpc/platforms/powernv/vas.h | 4 ++
> 4 files changed, 161 insertions(+), 1 deletion(-)
>
> diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
> index b0258ed..e1e34c6 100644
> --- 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/mmu_context.h>
> #include <asm/icswx.h>
>
> #include "vas.h"
> @@ -25,6 +26,88 @@
> #define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
>
> /*
> + * Process CRBs that we receive on the fault window.
> + */
> +irqreturn_t vas_fault_handler(int irq, void *data)
> +{
> + struct vas_instance *vinst = (struct vas_instance *)data;
No need for the cast.
> + crb = (struct coprocessor_request_block *)fifo;
Or this one.
> + if (vinst->fault_crbs == vinst->fault_fifo_size/CRB_SIZE)
Missing whitespace before and after the /
> + rc = request_threaded_irq(vinst->virq, NULL, vas_fault_handler,
> + IRQF_ONESHOT, devname, vinst);
> + if (rc) {
> + pr_err("VAS[%d]: Request IRQ(%d) failed with %d\n",
> + vinst->vas_id, vinst->virq, rc);
> + } else {
> + rc = vas_setup_fault_window(vinst);
> + if (rc)
> + free_irq(vinst->virq, vinst);
> + }
>
> return rc;
This would be a tad cleaner with proper goto unwinding:
rc = request_threaded_irq(vinst->virq, NULL, vas_fault_handler,
IRQF_ONESHOT, devname, vinst);
if (rc) {
pr_err("VAS[%d]: Request IRQ(%d) failed with %d\n",
vinst->vas_id, vinst->virq, rc);
goto out;
}
rc = vas_setup_fault_window(vinst);
if (rc)
goto out_free_irq;
return 0;
out_free_irq:
free_irq(vinst->virq, vinst);
out:
return rc;
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH V2 06/13] powerpc/vas: Register NX with fault window ID and IRQ port value
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (4 preceding siblings ...)
2019-12-09 3:31 ` [PATCH V2 05/13] powerpc/vas: Setup thread IRQ handler " Haren Myneni
@ 2019-12-09 3:32 ` Haren Myneni
2019-12-09 3:32 ` [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows Haren Myneni
` (8 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:32 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
For each user space send window, register NX with fault window ID
and port value so that NX paste CRBs in this fault FIFO when it
sees fault on the request buffer.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-window.c | 15 +++++++++++++--
arch/powerpc/platforms/powernv/vas.h | 15 +++++++++++++++
2 files changed, 28 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index cec1b41..e36c5d2 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -373,7 +373,7 @@ int init_winctx_regs(struct vas_window *window, struct vas_winctx *winctx)
init_xlate_regs(window, winctx->user_win);
val = 0ULL;
- val = SET_FIELD(VAS_FAULT_TX_WIN, val, 0);
+ val = SET_FIELD(VAS_FAULT_TX_WIN, val, winctx->fault_win_id);
write_hvwc_reg(window, VREG(FAULT_TX_WIN), val);
/* In PowerNV, interrupts go to HV. */
@@ -748,6 +748,8 @@ static void init_winctx_for_rxwin(struct vas_window *rxwin,
winctx->min_scope = VAS_SCOPE_LOCAL;
winctx->max_scope = VAS_SCOPE_VECTORED_GROUP;
+ if (rxwin->vinst->virq)
+ winctx->irq_port = rxwin->vinst->irq_port;
}
static bool rx_win_args_valid(enum vas_cop_type cop,
@@ -945,13 +947,22 @@ static void init_winctx_for_txwin(struct vas_window *txwin,
winctx->lpid = txattr->lpid;
winctx->pidr = txattr->pidr;
winctx->rx_win_id = txwin->rxwin->winid;
+ /*
+ * IRQ and fault window setup is successful. Set fault window
+ * for the send window so that ready to handle faults.
+ */
+ if (txwin->vinst->virq)
+ winctx->fault_win_id = txwin->vinst->fault_win->winid;
winctx->dma_type = VAS_DMA_TYPE_INJECT;
winctx->tc_mode = txattr->tc_mode;
winctx->min_scope = VAS_SCOPE_LOCAL;
winctx->max_scope = VAS_SCOPE_VECTORED_GROUP;
+ if (txwin->vinst->virq)
+ winctx->irq_port = txwin->vinst->irq_port;
- winctx->pswid = 0;
+ winctx->pswid = txattr->pswid ? txattr->pswid :
+ encode_pswid(txwin->vinst->vas_id, txwin->winid);
}
static bool tx_win_args_valid(enum vas_cop_type cop,
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 879f5b4..2621df1 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -455,6 +455,21 @@ static inline u64 read_hvwc_reg(struct vas_window *win,
return in_be64(win->hvwc_map+reg);
}
+/*
+ * Encode/decode the Partition Send Window ID (PSWID) for a window in
+ * a way that we can uniquely identify any window in the system. i.e.
+ * we should be able to locate the 'struct vas_window' given the PSWID.
+ *
+ * Bits Usage
+ * 0:7 VAS id (8 bits)
+ * 8:15 Unused, 0 (3 bits)
+ * 16:31 Window id (16 bits)
+ */
+static inline u32 encode_pswid(int vasid, int winid)
+{
+ return ((u32)winid | (vasid << (31 - 7)));
+}
+
static inline void decode_pswid(u32 pswid, int *vasid, int *winid)
{
if (vasid)
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (5 preceding siblings ...)
2019-12-09 3:32 ` [PATCH V2 06/13] powerpc/vas: Register NX with fault window ID and IRQ port value Haren Myneni
@ 2019-12-09 3:32 ` Haren Myneni
2019-12-12 13:02 ` Christoph Hellwig
2019-12-09 3:33 ` [PATCH V2 08/13] powerpc/vas: Update CSB and notify process for fault CRBs Haren Myneni
` (7 subsequent siblings)
14 siblings, 1 reply; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:32 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
Process close windows after its requests are completed. In multi-thread
applications, child can open a window but release FD will not be called
upon its exit. Parent thread will be closing it later upon its exit.
The parent can also send NX requests with this window and NX can
generate page faults. After kernel handles the page fault, send
signal to process by using PID if CSB address is invalid. Parent
thread will not receive signal since its PID is different from the one
saved in vas_window. So use tgid in case if the task for the pid saved
in window is not running and send signal to its parent.
To prevent reusing the pid until the window closed, take reference to
pid and task mm.
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-debug.c | 2 +-
arch/powerpc/platforms/powernv/vas-window.c | 44 ++++++++++++++++++++++++++---
arch/powerpc/platforms/powernv/vas.h | 9 +++++-
3 files changed, 49 insertions(+), 6 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-debug.c b/arch/powerpc/platforms/powernv/vas-debug.c
index 09e63df..ef9a717 100644
--- a/arch/powerpc/platforms/powernv/vas-debug.c
+++ b/arch/powerpc/platforms/powernv/vas-debug.c
@@ -38,7 +38,7 @@ static int info_show(struct seq_file *s, void *private)
seq_printf(s, "Type: %s, %s\n", cop_to_str(window->cop),
window->tx_win ? "Send" : "Receive");
- seq_printf(s, "Pid : %d\n", window->pid);
+ seq_printf(s, "Pid : %d\n", vas_window_pid(window));
unlock:
mutex_unlock(&vas_mutex);
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index e36c5d2..344db11 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -12,6 +12,8 @@
#include <linux/log2.h>
#include <linux/rcupdate.h>
#include <linux/cred.h>
+#include <linux/sched/mm.h>
+#include <linux/mmu_context.h>
#include <asm/switch_to.h>
#include <asm/ppc-opcode.h>
#include "vas.h"
@@ -877,8 +879,6 @@ struct vas_window *vas_rx_win_open(int vasid, enum vas_cop_type cop,
rxwin->user_win = rxattr->user_win;
rxwin->cop = cop;
rxwin->wcreds_max = rxattr->wcreds_max ?: VAS_WCREDS_DEFAULT;
- if (rxattr->user_win)
- rxwin->pid = task_pid_vnr(current);
init_winctx_for_rxwin(rxwin, rxattr, &winctx);
init_winctx_regs(rxwin, &winctx);
@@ -1028,7 +1028,6 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
txwin->tx_win = 1;
txwin->rxwin = rxwin;
txwin->nx_win = txwin->rxwin->nx_win;
- txwin->pid = attr->pid;
txwin->user_win = attr->user_win;
txwin->wcreds_max = attr->wcreds_max ?: VAS_WCREDS_DEFAULT;
@@ -1069,6 +1068,34 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
goto free_window;
}
+ if (txwin->user_win) {
+ /*
+ * Window opened by child thread may not be closed when
+ * it exits. So take reference to its pid and release it
+ * when the window is free by parent thread.
+ * Acquire a reference to the task's pid to make sure
+ * pid will not be re-used.
+ */
+ txwin->pid = get_task_pid(current, PIDTYPE_PID);
+ /*
+ * Acquire a reference to the task's mm.
+ */
+ txwin->mm = get_task_mm(current);
+
+ if (txwin->mm) {
+ mmput(txwin->mm);
+ mmgrab(txwin->mm);
+ mm_context_add_copro(txwin->mm);
+ } else {
+ put_pid(txwin->pid);
+ pr_err("VAS: pid(%d): mm_struct is not found\n",
+ current->pid);
+ rc = -EPERM;
+ goto free_window;
+ }
+ txwin->tgid = task_tgid_vnr(current);
+ }
+
set_vinst_win(vinst, txwin);
return txwin;
@@ -1267,8 +1294,17 @@ int vas_win_close(struct vas_window *window)
poll_window_castout(window);
/* if send window, drop reference to matching receive window */
- if (window->tx_win)
+ if (window->tx_win) {
+ if (window->user_win) {
+ /* Drop references to pid and mm */
+ put_pid(window->pid);
+ if (window->mm) {
+ mmdrop(window->mm);
+ mm_context_remove_copro(window->mm);
+ }
+ }
put_rx_win(window->rxwin);
+ }
vas_window_free(window);
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 2621df1..cd609ce 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -340,7 +340,9 @@ struct vas_window {
bool user_win; /* True if user space window */
void *hvwc_map; /* HV window context */
void *uwc_map; /* OS/User window context */
- pid_t pid; /* Linux process id of owner */
+ struct pid *pid; /* Linux process id of owner */
+ pid_t tgid; /* Thread group ID of owner */
+ struct mm_struct *mm; /* Linux process mm_struct */
int wcreds_max; /* Window credits */
char *dbgname;
@@ -418,6 +420,11 @@ struct vas_winctx {
extern struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,
uint32_t pswid);
+static inline int vas_window_pid(struct vas_window *window)
+{
+ return pid_vnr(window->pid);
+}
+
static inline void vas_log_write(struct vas_window *win, char *name,
void *regptr, u64 val)
{
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows
2019-12-09 3:32 ` [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows Haren Myneni
@ 2019-12-12 13:02 ` Christoph Hellwig
2019-12-17 5:35 ` Haren Myneni
0 siblings, 1 reply; 23+ messages in thread
From: Christoph Hellwig @ 2019-12-12 13:02 UTC (permalink / raw)
To: Haren Myneni
Cc: mpe, devicetree, mikey, herbert, npiggin, hch, sukadev, linuxppc-dev
> + if (txwin->user_win) {
> + /*
> + * Window opened by child thread may not be closed when
> + * it exits. So take reference to its pid and release it
> + * when the window is free by parent thread.
> + * Acquire a reference to the task's pid to make sure
> + * pid will not be re-used.
> + */
> + txwin->pid = get_task_pid(current, PIDTYPE_PID);
> + /*
> + * Acquire a reference to the task's mm.
> + */
> + txwin->mm = get_task_mm(current);
> +
> + if (txwin->mm) {
> + mmput(txwin->mm);
> + mmgrab(txwin->mm);
Doesn't the mmgrab need to come before the mmput?
> + mm_context_add_copro(txwin->mm);
> + } else {
> + put_pid(txwin->pid);
> + pr_err("VAS: pid(%d): mm_struct is not found\n",
> + current->pid);
> + rc = -EPERM;
> + goto free_window;
> + }
Also the code is much easier to follow if you handle the error
first and avoid the else:
txwin->mm = get_task_mm(current);
if (!txwin->mm) {
put_pid(txwin->pid);
pr_err("VAS: pid(%d): mm_struct is not found\n",
current->pid);
rc = -EPERM;
goto free_window;
}
mmgrab(txwin->mm);
mmput(txwin->mm);
Also don't you need to take a reference to the struct pid for the
tgid as well?
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows
2019-12-12 13:02 ` Christoph Hellwig
@ 2019-12-17 5:35 ` Haren Myneni
0 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-17 5:35 UTC (permalink / raw)
To: Christoph Hellwig
Cc: mpe, devicetree, mikey, herbert, npiggin, sukadev, linuxppc-dev
On Thu, 2019-12-12 at 05:02 -0800, Christoph Hellwig wrote:
> > + if (txwin->user_win) {
> > + /*
> > + * Window opened by child thread may not be closed when
> > + * it exits. So take reference to its pid and release it
> > + * when the window is free by parent thread.
> > + * Acquire a reference to the task's pid to make sure
> > + * pid will not be re-used.
> > + */
> > + txwin->pid = get_task_pid(current, PIDTYPE_PID);
> > + /*
> > + * Acquire a reference to the task's mm.
> > + */
> > + txwin->mm = get_task_mm(current);
> > +
> > + if (txwin->mm) {
> > + mmput(txwin->mm);
> > + mmgrab(txwin->mm);
>
> Doesn't the mmgrab need to come before the mmput?
>
> > + mm_context_add_copro(txwin->mm);
> > + } else {
> > + put_pid(txwin->pid);
> > + pr_err("VAS: pid(%d): mm_struct is not found\n",
> > + current->pid);
> > + rc = -EPERM;
> > + goto free_window;
> > + }
>
> Also the code is much easier to follow if you handle the error
> first and avoid the else:
>
> txwin->mm = get_task_mm(current);
> if (!txwin->mm) {
> put_pid(txwin->pid);
> pr_err("VAS: pid(%d): mm_struct is not found\n",
> current->pid);
> rc = -EPERM;
> goto free_window;
> }
> mmgrab(txwin->mm);
> mmput(txwin->mm);
>
> Also don't you need to take a reference to the struct pid for the
> tgid as well?
Process opens window and closed it upon its exit. We do not have to take
pid reference in this case. But in multithread applications, child
thread can open window, can exit without closing it. Parent thread can
use this window and expects to close it later. So in this case pid
reference for child thread is needed. Where as parent thread is the one
who is closing the window later, do not to have to take its pid
reference.
Basically we are taking pid reference to the process who opens the
window to cover multithread applications.
Thanks for your review comments. I will post V3 patches.
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH V2 08/13] powerpc/vas: Update CSB and notify process for fault CRBs
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (6 preceding siblings ...)
2019-12-09 3:32 ` [PATCH V2 07/13] powerpc/vas: Take reference to PID and mm for user space windows Haren Myneni
@ 2019-12-09 3:33 ` Haren Myneni
2019-12-12 13:07 ` Christoph Hellwig
2019-12-09 3:34 ` [PATCH V2 09/13] powerpc/vas: Print CRB and FIFO values Haren Myneni
` (6 subsequent siblings)
14 siblings, 1 reply; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:33 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
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.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-fault.c | 130 +++++++++++++++++++++++++++++
1 file changed, 130 insertions(+)
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index e1e34c6..88a211b 100644
--- 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,134 @@
*/
#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
+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;
+ /*
+ * process will be polling on csb.flags after request is sent to
+ * NX. So generally CSB update should not fail except when an
+ * application does not follow the process properly. 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, 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 = be64_to_cpu(crb->stamp.nx.fault_storage_addr);
+ 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.
+ * pid and mm references are taken when window is opened by
+ * process (pid). So tgid is used only when child thread is not
+ * available in multithread tasks.
+ *
+ */
+ if (tsk) {
+ if (tsk->flags & PF_EXITING)
+ task_exit = 1;
+ put_task_struct(tsk);
+ pid = vas_window_pid(window);
+ } else {
+ pid = window->tgid;
+
+ 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.
*/
@@ -102,6 +231,7 @@ irqreturn_t vas_fault_handler(int irq, void *data)
return IRQ_HANDLED;
}
+ update_csb(window, crb);
} while (true);
return IRQ_HANDLED;
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH V2 08/13] powerpc/vas: Update CSB and notify process for fault CRBs
2019-12-09 3:33 ` [PATCH V2 08/13] powerpc/vas: Update CSB and notify process for fault CRBs Haren Myneni
@ 2019-12-12 13:07 ` Christoph Hellwig
0 siblings, 0 replies; 23+ messages in thread
From: Christoph Hellwig @ 2019-12-12 13:07 UTC (permalink / raw)
To: Haren Myneni
Cc: mpe, devicetree, mikey, herbert, npiggin, hch, sukadev, linuxppc-dev
On Sun, Dec 08, 2019 at 07:33:37PM -0800, Haren Myneni wrote:
> +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;
> + /*
> + * process will be polling on csb.flags after request is sent to
> + * NX. So generally CSB update should not fail except when an
> + * application does not follow the process properly. 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, find_vpid(pid));
> + rcu_read_unlock();
> +
> + pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__, pid, rc);
> +}
I think you want to pass in the struct pid * here instead of looking
up again, given that..
> + if (tsk) {
> + if (tsk->flags & PF_EXITING)
> + task_exit = 1;
> + put_task_struct(tsk);
> + pid = vas_window_pid(window);
We already have the struct pid in the window structure here.
> + } else {
> + pid = window->tgid;
> +
> + rcu_read_lock();
> + tsk = find_task_by_vpid(pid);
> + if (!tsk) {
.. and could have easily stored on here. Or at least only do the
look up once, given that already looks it up.
> + /* 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);
> + }
I suspect inlining notify_process and just existing early for the
task_exit case also makes the code a bit easier to follow.
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH V2 09/13] powerpc/vas: Print CRB and FIFO values
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (7 preceding siblings ...)
2019-12-09 3:33 ` [PATCH V2 08/13] powerpc/vas: Update CSB and notify process for fault CRBs Haren Myneni
@ 2019-12-09 3:34 ` Haren Myneni
2019-12-09 3:34 ` [PATCH V2 10/13] powerpc/vas: Do not use default credits for receive window Haren Myneni
` (5 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:34 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
Dump FIFO entry values if could not find send window and print CRB
for debugging.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-fault.c | 41 ++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index 88a211b..cf41b65 100644
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -26,6 +26,28 @@
*/
#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
+static void dump_crb(struct coprocessor_request_block *crb)
+{
+ struct data_descriptor_entry *dde;
+ struct nx_fault_stamp *nx;
+
+ dde = &crb->source;
+ pr_devel("SrcDDE: addr 0x%llx, len %d, count %d, idx %d, flags %d\n",
+ be64_to_cpu(dde->address), be32_to_cpu(dde->length),
+ dde->count, dde->index, dde->flags);
+
+ dde = &crb->target;
+ pr_devel("TgtDDE: addr 0x%llx, len %d, count %d, idx %d, flags %d\n",
+ be64_to_cpu(dde->address), be32_to_cpu(dde->length),
+ dde->count, dde->index, dde->flags);
+
+ nx = &crb->stamp.nx;
+ pr_devel("NX Stamp: PSWID 0x%x, FSA 0x%llx, flags 0x%x, FS 0x%x\n",
+ be32_to_cpu(nx->pswid),
+ be64_to_cpu(crb->stamp.nx.fault_storage_addr),
+ nx->flags, be32_to_cpu(nx->fault_status));
+}
+
static void notify_process(pid_t pid, u64 fault_addr)
{
int rc;
@@ -154,6 +176,23 @@ static void update_csb(struct vas_window *window,
}
}
+static void dump_fifo(struct vas_instance *vinst, void *entry)
+{
+ int i;
+ unsigned long *fifo = entry;
+
+ pr_err("Fault fifo size %d, max crbs %d, crb size %lu\n",
+ vinst->fault_fifo_size,
+ vinst->fault_fifo_size / CRB_SIZE,
+ sizeof(struct coprocessor_request_block));
+
+ pr_err("Fault FIFO Entry Dump:\n");
+ for (i = 0; i < CRB_SIZE; i += 4, fifo += 4) {
+ pr_err("[%.3d, %p]: 0x%.16lx 0x%.16lx 0x%.16lx 0x%.16lx\n",
+ i, fifo, *fifo, *(fifo+1), *(fifo+2), *(fifo+3));
+ }
+}
+
/*
* Process CRBs that we receive on the fault window.
*/
@@ -212,6 +251,7 @@ irqreturn_t vas_fault_handler(int irq, void *data)
vinst->vas_id, vinst->fault_fifo, fifo,
vinst->fault_crbs);
+ dump_crb(crb);
window = vas_pswid_to_window(vinst,
be32_to_cpu(crb->stamp.nx.pswid));
@@ -222,6 +262,7 @@ irqreturn_t vas_fault_handler(int irq, void *data)
* even clean it up (return credit).
* But we should not get here.
*/
+ dump_fifo(vinst, (void *)crb);
pr_err("VAS[%d] fault_fifo %p, fifo %p, pswid 0x%x, fault_crbs %d bad CRB?\n",
vinst->vas_id, vinst->fault_fifo, fifo,
be32_to_cpu(crb->stamp.nx.pswid),
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 10/13] powerpc/vas: Do not use default credits for receive window
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (8 preceding siblings ...)
2019-12-09 3:34 ` [PATCH V2 09/13] powerpc/vas: Print CRB and FIFO values Haren Myneni
@ 2019-12-09 3:34 ` Haren Myneni
2019-12-09 3:35 ` [PATCH V2 11/13] powerpc/vas: Return credits after handling fault Haren Myneni
` (4 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:34 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
System checkstops if RxFIFO overruns with more requests than the
maximum possible number of CRBs allowed in FIFO at any time. So
max credits value (rxattr.wcreds_max) is set and is passed to
vas_rx_win_open() by the the driver.
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-window.c | 4 ++--
arch/powerpc/platforms/powernv/vas.h | 2 --
2 files changed, 2 insertions(+), 4 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 344db11..941582b 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -772,7 +772,7 @@ static bool rx_win_args_valid(enum vas_cop_type cop,
if (attr->rx_fifo_size > VAS_RX_FIFO_SIZE_MAX)
return false;
- if (attr->wcreds_max > VAS_RX_WCREDS_MAX)
+ if (!attr->wcreds_max)
return false;
if (attr->nx_win) {
@@ -878,7 +878,7 @@ struct vas_window *vas_rx_win_open(int vasid, enum vas_cop_type cop,
rxwin->nx_win = rxattr->nx_win;
rxwin->user_win = rxattr->user_win;
rxwin->cop = cop;
- rxwin->wcreds_max = rxattr->wcreds_max ?: VAS_WCREDS_DEFAULT;
+ rxwin->wcreds_max = rxattr->wcreds_max;
init_winctx_for_rxwin(rxwin, rxattr, &winctx);
init_winctx_regs(rxwin, &winctx);
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index cd609ce..d7398b7 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -101,11 +101,9 @@
/*
* Initial per-process credits.
* Max send window credits: 4K-1 (12-bits in VAS_TX_WCRED)
- * Max receive window credits: 64K-1 (16 bits in VAS_LRX_WCRED)
*
* TODO: Needs tuning for per-process credits
*/
-#define VAS_RX_WCREDS_MAX ((64 << 10) - 1)
#define VAS_TX_WCREDS_MAX ((4 << 10) - 1)
#define VAS_WCREDS_DEFAULT (1 << 10)
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 11/13] powerpc/vas: Return credits after handling fault
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (9 preceding siblings ...)
2019-12-09 3:34 ` [PATCH V2 10/13] powerpc/vas: Do not use default credits for receive window Haren Myneni
@ 2019-12-09 3:35 ` Haren Myneni
2019-12-09 3:36 ` [PATCH V2 12/13] powerpc/vas: Display process stuck message Haren Myneni
` (3 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:35 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
NX expects OS to return credit for send window after processing each
fault. Also credit has to be returned even for fault window.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-fault.c | 10 ++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 17 +++++++++++++++++
arch/powerpc/platforms/powernv/vas.h | 1 +
3 files changed, 28 insertions(+)
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index cf41b65..926fdf3 100644
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -247,6 +247,11 @@ irqreturn_t vas_fault_handler(int irq, void *data)
memset(fifo, 0, CRB_SIZE);
mutex_unlock(&vinst->mutex);
+ /*
+ * Return credit for the fault window.
+ */
+ vas_return_credit(vinst->fault_win, 0);
+
pr_devel("VAS[%d] fault_fifo %p, fifo %p, fault_crbs %d\n",
vinst->vas_id, vinst->fault_fifo, fifo,
vinst->fault_crbs);
@@ -273,6 +278,11 @@ irqreturn_t vas_fault_handler(int irq, void *data)
}
update_csb(window, crb);
+ /*
+ * Return credit for send window after processing
+ * fault CRB.
+ */
+ vas_return_credit(window, 1);
} while (true);
return IRQ_HANDLED;
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 941582b..27848d3 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -1312,6 +1312,23 @@ int vas_win_close(struct vas_window *window)
}
EXPORT_SYMBOL_GPL(vas_win_close);
+/*
+ * Return credit for the given window.
+ */
+void vas_return_credit(struct vas_window *window, bool tx)
+{
+ uint64_t val;
+
+ val = 0ULL;
+ if (tx) { /* send window */
+ val = SET_FIELD(VAS_TX_WCRED, val, 1);
+ write_hvwc_reg(window, VREG(TX_WCRED_ADDER), val);
+ } else {
+ val = SET_FIELD(VAS_LRX_WCRED, val, 1);
+ write_hvwc_reg(window, VREG(LRX_WCRED_ADDER), val);
+ }
+}
+
struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,
uint32_t pswid)
{
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index d7398b7..6332683 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -415,6 +415,7 @@ struct vas_winctx {
extern void vas_window_free_dbgdir(struct vas_window *win);
extern int vas_setup_fault_window(struct vas_instance *vinst);
extern irqreturn_t vas_fault_handler(int irq, void *data);
+extern void vas_return_credit(struct vas_window *window, bool tx);
extern struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,
uint32_t pswid);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 12/13] powerpc/vas: Display process stuck message
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (10 preceding siblings ...)
2019-12-09 3:35 ` [PATCH V2 11/13] powerpc/vas: Return credits after handling fault Haren Myneni
@ 2019-12-09 3:36 ` Haren Myneni
2019-12-09 3:37 ` [PATCH V2 13/13] powerpc/vas: Free send window in VAS instance after credits returned Haren Myneni
` (2 subsequent siblings)
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:36 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
Process can not close send window until all requests are processed.
Means wait until window state is not busy and send credits are
returned. Display debug message in case taking longer to close the
window.
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-window.c | 26 ++++++++++++++++++++++++++
1 file changed, 26 insertions(+)
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 27848d3..578f144 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -1176,6 +1176,7 @@ static void poll_window_credits(struct vas_window *window)
{
u64 val;
int creds, mode;
+ int count = 0;
val = read_hvwc_reg(window, VREG(WINCTL));
if (window->tx_win)
@@ -1194,10 +1195,25 @@ static void poll_window_credits(struct vas_window *window)
creds = GET_FIELD(VAS_LRX_WCRED, val);
}
+ /*
+ * Takes around few microseconds to complete all pending requests
+ * and return credits.
+ * TODO: Issue CRB Kill to stop all pending requests. Need only
+ * if there is a bug in NX or fault handling in kernel.
+ */
if (creds < window->wcreds_max) {
val = 0;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(msecs_to_jiffies(10));
+ count++;
+ /*
+ * Process can not close send window until all credits are
+ * returned.
+ */
+ if (!(count % 10000))
+ pr_debug("%s() pid %d stuck? retries %d\n", __func__,
+ vas_window_pid(window), count);
+
goto retry;
}
}
@@ -1211,6 +1227,7 @@ static void poll_window_busy_state(struct vas_window *window)
{
int busy;
u64 val;
+ int count = 0;
retry:
val = read_hvwc_reg(window, VREG(WIN_STATUS));
@@ -1219,6 +1236,15 @@ static void poll_window_busy_state(struct vas_window *window)
val = 0;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(msecs_to_jiffies(5));
+ count++;
+ /*
+ * Takes around 5 microseconds to process all pending
+ * requests.
+ */
+ if (!(count % 10000))
+ pr_debug("%s() pid %d stuck? retries %d\n", __func__,
+ vas_window_pid(window), count);
+
goto retry;
}
}
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH V2 13/13] powerpc/vas: Free send window in VAS instance after credits returned
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (11 preceding siblings ...)
2019-12-09 3:36 ` [PATCH V2 12/13] powerpc/vas: Display process stuck message Haren Myneni
@ 2019-12-09 3:37 ` Haren Myneni
2019-12-09 5:37 ` [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Christophe Leroy
2019-12-12 5:38 ` Haren Myneni
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-09 3:37 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
NX may be processing requests while trying to close window. Wait until
all credits are returned and then free send window from VAS instance.
Signed-off-by: Haren Myneni <haren@us.ibm.com>
---
arch/powerpc/platforms/powernv/vas-window.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 578f144..5322d1c 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -1309,14 +1309,14 @@ int vas_win_close(struct vas_window *window)
unmap_paste_region(window);
- clear_vinst_win(window);
-
poll_window_busy_state(window);
unpin_close_window(window);
poll_window_credits(window);
+ clear_vinst_win(window);
+
poll_window_castout(window);
/* if send window, drop reference to matching receive window */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (12 preceding siblings ...)
2019-12-09 3:37 ` [PATCH V2 13/13] powerpc/vas: Free send window in VAS instance after credits returned Haren Myneni
@ 2019-12-09 5:37 ` Christophe Leroy
2019-12-09 8:38 ` Segher Boessenkool
2019-12-12 5:38 ` Haren Myneni
14 siblings, 1 reply; 23+ messages in thread
From: Christophe Leroy @ 2019-12-09 5:37 UTC (permalink / raw)
To: Haren Myneni, mpe, hch, mikey, npiggin, herbert, linuxppc-dev,
devicetree
Cc: sukadev
Hi,
What do you mean by NX ?
Up to now, NX has been standing for No-eXecute. That's a bit in segment
registers on book3s/32 to forbid executing code.
Therefore, some of your text is really misleading. If NX means something
else for you, your text must be unambiguous.
Christophe
Le 09/12/2019 à 04:18, Haren Myneni a écrit :
>
> Applications will send compression / decompression requests to NX with
> COPY/PASTE instructions. When NX is processing these requests, can hit
> fault on the request buffer (not in memory). It issues an interrupt and
> pastes fault CRB in fault FIFO. Expects kernel to handle this fault and
> return credits for both send and fault windows after processing.
>
> This patch series adds IRQ and fault window setup, and NX fault handling:
> - Read IRQ# from "interrupts" property and configure IRQ per VAS instance.
> - Set port# for each window to generate an interrupt when noticed fault.
> - Set fault window and FIFO on which NX paste fault CRB.
> - Setup IRQ thread fault handler per VAS instance.
> - When receiving an interrupt, Read CRBs from fault FIFO and update
> coprocessor_status_block (CSB) in the corresponding CRB with translation
> failure (CSB_CC_TRANSLATION). After issuing NX requests, process polls
> on CSB address. When it sees translation error, can touch the request
> buffer to bring the page in to memory and reissue NX request.
> - If copy_to_user fails on user space CSB address, OS sends SEGV signal.
>
> Tested these patches with NX-GZIP support and will be posting this series
> soon.
>
> Patch 2: Define nx_fault_stamp on which NX writes fault status for the fault
> CRB
> Patch 3: Read interrupts and port properties per VAS instance
> Patch 4: Setup fault window per each VAS instance. This window is used for
> NX to paste fault CRB in FIFO.
> Patches 5 & 6: Setup threaded IRQ per VAS and register NX with fault window
> ID and port number for each send window so that NX paste fault CRB
> in this window.
> Patch 7: Reference to pid and mm so that pid is not used until window closed.
> Needed for multi thread application where child can open a window
> and can be used by parent later.
> Patches 8 and 9: Process CRBs from fault FIFO and notify tasks by
> updating CSB or through signals.
> Patches 10 and 11: Return credits for send and fault windows after handling
> faults.
> Patch 13:Fix closing send window after all credits are returned. This issue
> happens only for user space requests. No page faults on kernel
> request buffer.
>
> Changelog:
> V2:
> - Use threaded IRQ instead of own kernel thread handler
> - Use pswid insted of user space CSB address to find valid CRB
> - Removed unused macros and other changes as suggested by Christoph Hellwig
>
> Haren Myneni (13):
> powerpc/vas: Describe vas-port and interrupts properties
> powerpc/vas: Define nx_fault_stamp in coprocessor_request_block
> powerpc/vas: Read interrupts and vas-port device tree properties
> powerpc/vas: Setup fault window per VAS instance
> powerpc/vas: Setup thread IRQ handler per VAS instance
> powerpc/vas: Register NX with fault window ID and IRQ port value
> powerpc/vas: Take reference to PID and mm for user space windows
> powerpc/vas: Update CSB and notify process for fault CRBs
> powerpc/vas: Print CRB and FIFO values
> powerpc/vas: Do not use default credits for receive window
> powerpc/VAS: Return credits after handling fault
> powerpc/vas: Display process stuck message
> powerpc/vas: Free send window in VAS instance after credits returned
>
> .../devicetree/bindings/powerpc/ibm,vas.txt | 5 +
> arch/powerpc/include/asm/icswx.h | 18 +-
> arch/powerpc/platforms/powernv/Makefile | 2 +-
> arch/powerpc/platforms/powernv/vas-debug.c | 2 +-
> arch/powerpc/platforms/powernv/vas-fault.c | 337 +++++++++++++++++++++
> arch/powerpc/platforms/powernv/vas-window.c | 173 ++++++++++-
> arch/powerpc/platforms/powernv/vas.c | 77 ++++-
> arch/powerpc/platforms/powernv/vas.h | 38 ++-
> 8 files changed, 627 insertions(+), 25 deletions(-)
> create mode 100644 arch/powerpc/platforms/powernv/vas-fault.c
>
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests
2019-12-09 5:37 ` [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Christophe Leroy
@ 2019-12-09 8:38 ` Segher Boessenkool
2019-12-12 5:05 ` Haren Myneni
0 siblings, 1 reply; 23+ messages in thread
From: Segher Boessenkool @ 2019-12-09 8:38 UTC (permalink / raw)
To: Christophe Leroy
Cc: Haren Myneni, mpe, hch, mikey, npiggin, herbert, linuxppc-dev,
devicetree, sukadev
Hi!
On Mon, Dec 09, 2019 at 06:37:09AM +0100, Christophe Leroy wrote:
> What do you mean by NX ?
It is the Power9 "Nest Accelerator". The patch series should ideally
mention that right at the start, yeah.
> Up to now, NX has been standing for No-eXecute. That's a bit in segment
> registers on book3s/32 to forbid executing code.
That bit is called just N fwiw (and not really specific to 32-bit -- on
64-bit implementations it was part of segment table entries, and of SLB
entries on newer machines).
Segher
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests
2019-12-09 8:38 ` Segher Boessenkool
@ 2019-12-12 5:05 ` Haren Myneni
0 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-12 5:05 UTC (permalink / raw)
To: Segher Boessenkool
Cc: Christophe Leroy, mpe, hch, mikey, npiggin, herbert,
linuxppc-dev, devicetree, sukadev
On Mon, 2019-12-09 at 02:38 -0600, Segher Boessenkool wrote:
> Hi!
>
> On Mon, Dec 09, 2019 at 06:37:09AM +0100, Christophe Leroy wrote:
> > What do you mean by NX ?
>
> It is the Power9 "Nest Accelerator". The patch series should ideally
> mention that right at the start, yeah.
Thanks, NX (Nest Accelerator) is introduced since power7+
(drivers/crypto/nx/)
Whereas on power9, VAS (Virtual Accelerator Switchboard) is introduced
which allows to open multiple channels to communicate with NX. kernel or
user space can interact with NX directly using copy/paste instructions.
Kernel support with NX-842 compression is already included in kernel.
In the case of user space, NX can see page fault on the request buffer
and interrupts OS to handle this fault. This patch series adds page
fault handling in VAS for user space requests.
I will repost this patch with more explanation on NX.
>
> > Up to now, NX has been standing for No-eXecute. That's a bit in segment
> > registers on book3s/32 to forbid executing code.
>
> That bit is called just N fwiw (and not really specific to 32-bit -- on
> 64-bit implementations it was part of segment table entries, and of SLB
> entries on newer machines).
>
>
> Segher
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests
2019-12-09 3:18 [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Haren Myneni
` (13 preceding siblings ...)
2019-12-09 5:37 ` [PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests Christophe Leroy
@ 2019-12-12 5:38 ` Haren Myneni
14 siblings, 0 replies; 23+ messages in thread
From: Haren Myneni @ 2019-12-12 5:38 UTC (permalink / raw)
To: mpe; +Cc: hch, mikey, npiggin, herbert, linuxppc-dev, devicetree, sukadev
[PATCH V2 00/13] powerpc/vas: Page fault handling for user space NX requests
On power9, Virtual Accelerator Switchboard (VAS) allows user space or
kernel to communicate with Nest Accelerator (NX) directly using COPY/PASTE
instructions. NX provides verious functionalities such as compression,
encryption and etc. But only compression (842 and GZIP formats) is
supported in Linux kernel on power9.
842 compression driver (drivers/crypto/nx/nx-842-powernv.c)
is already included in Linux. Only GZIP support will be available from
user space.
Applications can issue GZIP compression / decompression requests to NX with
COPY/PASTE instructions. When NX is processing these requests, can hit
fault on the request buffer (not in memory). It issues an interrupt and
pastes fault CRB in fault FIFO. Expects kernel to handle this fault and
return credits for both send and fault windows after processing.
This patch series adds IRQ and fault window setup, and NX fault handling:
- Read IRQ# from "interrupts" property and configure IRQ per VAS instance.
- Set port# for each window to generate an interrupt when noticed fault.
- Set fault window and FIFO on which NX paste fault CRB.
- Setup IRQ thread fault handler per VAS instance.
- When receiving an interrupt, Read CRBs from fault FIFO and update
coprocessor_status_block (CSB) in the corresponding CRB with translation
failure (CSB_CC_TRANSLATION). After issuing NX requests, process polls
on CSB address. When it sees translation error, can touch the request
buffer to bring the page in to memory and reissue NX request.
- If copy_to_user fails on user space CSB address, OS sends SEGV signal.
Tested these patches with NX-GZIP support and will be posting this series
soon.
Patch 2: Define nx_fault_stamp on which NX writes fault status for the fault
CRB
Patch 3: Read interrupts and port properties per VAS instance
Patch 4: Setup fault window per each VAS instance. This window is used for
NX to paste fault CRB in FIFO.
Patches 5 & 6: Setup threaded IRQ per VAS and register NX with fault window
ID and port number for each send window so that NX paste fault CRB
in this window.
Patch 7: Reference to pid and mm so that pid is not used until window closed.
Needed for multi thread application where child can open a window
and can be used by parent later.
Patches 8 and 9: Process CRBs from fault FIFO and notify tasks by
updating CSB or through signals.
Patches 10 and 11: Return credits for send and fault windows after handling
faults.
Patch 13:Fix closing send window after all credits are returned. This issue
happens only for user space requests. No page faults on kernel
request buffer.
Changelog:
V2:
- Use threaded IRQ instead of own kernel thread handler
- Use pswid insted of user space CSB address to find valid CRB
- Removed unused macros and other changes as suggested by Christoph Hellwig
Haren Myneni (13):
powerpc/vas: Describe vas-port and interrupts properties
powerpc/vas: Define nx_fault_stamp in coprocessor_request_block
powerpc/vas: Read interrupts and vas-port device tree properties
powerpc/vas: Setup fault window per VAS instance
powerpc/vas: Setup thread IRQ handler per VAS instance
powerpc/vas: Register NX with fault window ID and IRQ port value
powerpc/vas: Take reference to PID and mm for user space windows
powerpc/vas: Update CSB and notify process for fault CRBs
powerpc/vas: Print CRB and FIFO values
powerpc/vas: Do not use default credits for receive window
powerpc/VAS: Return credits after handling fault
powerpc/vas: Display process stuck message
powerpc/vas: Free send window in VAS instance after credits returned
.../devicetree/bindings/powerpc/ibm,vas.txt | 5 +
arch/powerpc/include/asm/icswx.h | 18 +-
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas-debug.c | 2 +-
arch/powerpc/platforms/powernv/vas-fault.c | 337 +++++++++++++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 173 ++++++++++-
arch/powerpc/platforms/powernv/vas.c | 77 ++++-
arch/powerpc/platforms/powernv/vas.h | 38 ++-
8 files changed, 627 insertions(+), 25 deletions(-)
create mode 100644 arch/powerpc/platforms/powernv/vas-fault.c
--
1.8.3.1
^ permalink raw reply [flat|nested] 23+ messages in thread