On Fri, 2021-06-18 at 09:34 +1000, Nicholas Piggin wrote:
> Excerpts from Haren Myneni's message of June 18, 2021 6:37 am:
> > NX generates an interrupt when sees a fault on the user space
> > buffer and the hypervisor forwards that interrupt to OS. Then
> > the kernel handles the interrupt by issuing H_GET_NX_FAULT hcall
> > to retrieve the fault CRB information.
> >
> > This patch also adds changes to setup and free IRQ per each
> > window and also handles the fault by updating the CSB.
>
> In as much as this pretty well corresponds to the PowerNV code
> AFAIKS,
> it looks okay to me.
>
> Reviewed-by: Nicholas Piggin <npiggin@xxxxxxxxx>
>
> Could you have an irq handler in your ops vector and have
> the core code set up the irq and call your handler, so the Linux irq
> handling is in one place? Not something for this series, I was just
> wondering.
Not possible to have common core code for IRQ setup.
PowerNV: Every VAS instance will be having IRQ and this setup will be
done during initialization (system boot). A fault FIFO will be assigned
for each instance and registered to VAS so that VAS/NX writes fault CRB
into this FIFO.
PowerVM: Each window will have an IRQ and the setup will be done during
window open.
Thanks
Haren
>
> Thanks,
> Nick
>
> > Signed-off-by: Haren Myneni <haren@xxxxxxxxxxxxx>
> > ---
> > arch/powerpc/platforms/pseries/vas.c | 102
> > +++++++++++++++++++++++++++
> > 1 file changed, 102 insertions(+)
> >
> > diff --git a/arch/powerpc/platforms/pseries/vas.c
> > b/arch/powerpc/platforms/pseries/vas.c
> > index f5a44f2f0e99..3385b5400cc6 100644
> > --- a/arch/powerpc/platforms/pseries/vas.c
> > +++ b/arch/powerpc/platforms/pseries/vas.c
> > @@ -11,6 +11,7 @@
> > #include <linux/types.h>
> > #include <linux/delay.h>
> > #include <linux/slab.h>
> > +#include <linux/interrupt.h>
> > #include <asm/machdep.h>
> > #include <asm/hvcall.h>
> > #include <asm/plpar_wrappers.h>
> > @@ -155,6 +156,50 @@ int h_query_vas_capabilities(const u64 hcall,
> > u8 query_type, u64 result)
> > }
> > EXPORT_SYMBOL_GPL(h_query_vas_capabilities);
> >
> > +/*
> > + * hcall to get fault CRB from the hypervisor.
> > + */
> > +static int h_get_nx_fault(u32 winid, u64 buffer)
> > +{
> > + long rc;
> > +
> > + rc = plpar_hcall_norets(H_GET_NX_FAULT, winid, buffer);
> > +
> > + if (rc == H_SUCCESS)
> > + return 0;
> > +
> > + pr_err("H_GET_NX_FAULT error: %ld, winid %u, buffer 0x%llx\n",
> > + rc, winid, buffer);
> > + return -EIO;
> > +
> > +}
> > +
> > +/*
> > + * Handle the fault interrupt.
> > + * When the fault interrupt is received for each window, query the
> > + * hypervisor to get the fault CRB on the specific fault. Then
> > + * process the CRB by updating CSB or send signal if the user
> > space
> > + * CSB is invalid.
> > + * Note: The hypervisor forwards an interrupt for each fault
> > request.
> > + * So one fault CRB to process for each H_GET_NX_FAULT hcall.
> > + */
> > +irqreturn_t pseries_vas_fault_thread_fn(int irq, void *data)
> > +{
> > + struct pseries_vas_window *txwin = data;
> > + struct coprocessor_request_block crb;
> > + struct vas_user_win_ref *tsk_ref;
> > + int rc;
> > +
> > + rc = h_get_nx_fault(txwin->vas_win.winid,
> > (u64)virt_to_phys(&crb));
> > + if (!rc) {
> > + tsk_ref = &txwin->vas_win.task_ref;
> > + vas_dump_crb(&crb);
> > + vas_update_csb(&crb, tsk_ref);
> > + }
> > +
> > + return IRQ_HANDLED;
> > +}
> > +
> > /*
> > * Allocate window and setup IRQ mapping.
> > */
> > @@ -166,10 +211,51 @@ static int allocate_setup_window(struct
> > pseries_vas_window *txwin,
> > rc = h_allocate_vas_window(txwin, domain, wintype,
> > DEF_WIN_CREDS);
> > if (rc)
> > return rc;
> > + /*
> > + * On PowerVM, the hypervisor setup and forwards the fault
> > + * interrupt per window. So the IRQ setup and fault handling
> > + * will be done for each open window separately.
> > + */
> > + txwin->fault_virq = irq_create_mapping(NULL, txwin->fault_irq);
> > + if (!txwin->fault_virq) {
> > + pr_err("Failed irq mapping %d\n", txwin->fault_irq);
> > + rc = -EINVAL;
> > + goto out_win;
> > + }
> > +
> > + txwin->name = kasprintf(GFP_KERNEL, "vas-win-%d",
> > + txwin->vas_win.winid);
> > + if (!txwin->name) {
> > + rc = -ENOMEM;
> > + goto out_irq;
> > + }
> > +
> > + rc = request_threaded_irq(txwin->fault_virq, NULL,
> > + pseries_vas_fault_thread_fn,
> > IRQF_ONESHOT,
> > + txwin->name, txwin);
> > + if (rc) {
> > + pr_err("VAS-Window[%d]: Request IRQ(%u) failed with
> > %d\n",
> > + txwin->vas_win.winid, txwin->fault_virq, rc);
> > + goto out_free;
> > + }
> >
> > txwin->vas_win.wcreds_max = DEF_WIN_CREDS;
> >
> > return 0;
> > +out_free:
> > + kfree(txwin->name);
> > +out_irq:
> > + irq_dispose_mapping(txwin->fault_virq);
> > +out_win:
> > + h_deallocate_vas_window(txwin->vas_win.winid);
> > + return rc;
> > +}
> > +
> > +static inline void free_irq_setup(struct pseries_vas_window
> > *txwin)
> > +{
> > + free_irq(txwin->fault_virq, txwin);
> > + kfree(txwin->name);
> > + irq_dispose_mapping(txwin->fault_virq);
> > }
> >
> > static struct vas_window *vas_allocate_window(int vas_id, u64
> > flags,
> > @@ -284,6 +370,11 @@ static struct vas_window
> > *vas_allocate_window(int vas_id, u64 flags,
> > return &txwin->vas_win;
> >
> > out_free:
> > + /*
> > + * Window is not operational. Free IRQ before closing
> > + * window so that do not have to hold mutex.
> > + */
> > + free_irq_setup(txwin);
> > h_deallocate_vas_window(txwin->vas_win.winid);
> > out:
> > atomic_dec(&cop_feat_caps->used_lpar_creds);
> > @@ -303,7 +394,18 @@ static int deallocate_free_window(struct
> > pseries_vas_window *win)
> > {
> > int rc = 0;
> >
> > + /*
> > + * The hypervisor waits for all requests including faults
> > + * are processed before closing the window - Means all
> > + * credits have to be returned. In the case of fault
> > + * request, a credit is returned after OS issues
> > + * H_GET_NX_FAULT hcall.
> > + * So free IRQ after executing H_DEALLOCATE_VAS_WINDOW
> > + * hcall.
> > + */
> > rc = h_deallocate_vas_window(win->vas_win.winid);
> > + if (!rc)
> > + free_irq_setup(win);
> >
> > return rc;
> > }
> > --
> > 2.18.2
> >
> >
> >
