Enable VAS and NX-GZIP support on PowerVM
Subsystems (4)
v6 cover Enable VAS and NX-GZIP support on PowerVM
Virtual Accelerator Switchboard (VAS) allows kernel subsystems and user space processes to directly access the Nest Accelerator (NX) engines which provides HW compression. The true user mode VAS/NX support on PowerNV is already included in Linux. Whereas PowerVM support is available from P10 onwards.
This patch series enables VAS / NX-GZIP on PowerVM which allows the user space to do copy/paste with the same existing interface that is available on PowerNV.
VAS Enablement:
- Get all VAS capabilities using H_QUERY_VAS_CAPABILITIES that are available in the hypervisor. These capabilities tells OS which type of features (credit types such as Default and Quality of Service (QoS)). Also gives specific capabilities for each credit
type: Maximum window credits, Maximum LPAR credits, Target credits in that parition (varies from max LPAR credits based DLPAR operation), whether supports user mode COPY/PASTE and etc.
- Register LPAR VAS operations such as open window. get paste address and close window with the current VAS user space API.
- Open window operation - Use H_ALLOCATE_VAS_WINDOW HCALL to open window and H_MODIFY_VAS_WINDOW HCALL to setup the window with LPAR PID and etc.
- mmap to paste address returned in H_ALLOCATE_VAS_WINDOW HCALL
- To close window, H_DEALLOCATE_VAS_WINDOW HCALL is used to close in the hypervisor.
NX Enablement:
- Get NX capabilities from the the hypervisor which provides Maximum buffer length in a single GZIP request, recommended minimum compression / decompression lengths.
- Register to VAS to enable user space VAS API
Main feature differences with PowerNV implementation:
- Each VAS window will be configured with a number of credits which means that many requests can be issues simultaniously on that window. On PowerNV, 1K credits are configured per window. Whereas on PowerVM, the hypervisor allows 1 credit per window at present.
- The hypervisor introduced 2 different types of credits: Default - Uses normal priority FIFO and Quality of Service (QoS) - Uses high priority FIFO. On PowerVM, VAS/NX HW resources are shared across LPARs. The total number of credits available on a system depends on cores configured. We may see more credits are assigned across the system than the NX HW resources can handle. So to avoid NX HW contention, the hypervisor introduced QoS credits which can be configured by system administration with HMC API. Then the total number of available default credits on LPAR varies based on QoS credits configured.
- On PowerNV, windows are allocated on a specific VAS instance and the user space can select VAS instance with the open window ioctl. Since VAS instances can be shared across partitions on PowerVM, the hypervisor manages window allocations on different VAS instances. So H_ALLOCATE_VAS_WINDOW allows to select by domain indentifiers (H_HOME_NODE_ASSOCIATIVITY values by cpu). By default the hypervisor selects VAS instance closer to CPU resources that the parition uses. So vas_id in ioctl interface is ignored on PowerVM except vas_id=-1 which is used to allocate window based on CPU that the process is executing. This option is needed for process affinity to NUMA node.
The existing applications that linked with libnxz should work as long as the job request length is restricted to req_max_processed_len.
Tested the following patches on P10 successfully with test cases
given: https://github.com/libnxz/power-gzip
Note: The hypervisor supports user mode NX from p10 onwards. Linux
supports user mode VAS/NX on P10 only with radix page tables.
Patch 1: Fix to release reference to tgid during window close Patches 2- 6: Move the code that is needed for both PowerNV and
PowerVM to powerpc book3s platform directory
Patch 7: Modify vas-window struct to support both platforms
and the related changes.
Patch 8: Define HCALL and the related VAS/NXGZIP specific
structs.
Patch 9: Define QoS credit flag in window open ioctl Patch 10: Implement Allocate, Modify and Deallocate HCALLs Patch 11: Retrieve VAS capabilities from the hypervisor Patch 12; Implement window operations and integrate with API Patch 13: Setup IRQ and NX fault handling Patch 14 - 15: Make the code common to add NX-GZIP enablement Patch 16: Get NX capabilities from the hypervisor patch 17; Add sysfs interface to expose NX capabilities
Changes in v2:
- Rebase on 5.12-rc6
- Moved VAS Kconfig changes to arch/powerpc/platform as suggested by Christophe Leroy
- build fix with allyesconfig (reported by kernel test build)
Changes in v3:
- Rebase on 5.12-rc7
- Moved vas-api.c and VAS Kconfig changes to arch/powerpc/platform/book3s as Michael Ellerman suggested
Changes in v4:
- Rebase on 5.13-rc2
- Changes based on review comments from Nicholas Piggin
- Add seperate patch to define user window operations
- Drop "sysfs interface to export VAS capabilities" patch This interface is mainly needed for DLPAR operations and this patch will be included when DLPAR/LPM support is added.
- Other cleanup changes
Changes in v5:
- Rebase on 5.13-rc5
- Changes based on review comments from Nicholas Piggin and Michael Ellerman:
- Add new patch to fix tgid reference release. This fix should be also included in stable 5.8+
- Define platform specific VAS window structs
- Define helper functions to take and release pid, tgid and mm references
- Other cleanup suggestions
Changes in v6:
- Rebase on 5.13-rc6
- Changes based on suggestions from Nicholas Piggin
- Create ref_get_pid_and_task() helper function which takes task refrence based on pid or tgid
- Pass vas_id and flags to platform specific open window API
- Miscellaneous changes
Haren Myneni (17):
powerpc/powernv/vas: Release reference to tgid during window close powerpc/vas: Move VAS API to book3s common platform powerpc/powernv/vas: Rename register/unregister functions powerpc/vas: Add platform specific user window operations powerpc/vas: Create take/drop pid and mm reference functions powerpc/vas: Move update_csb/dump_crb to common book3s platform powerpc/vas: Define and use common vas_window struct powerpc/pseries/vas: Define VAS/NXGZIP hcalls and structs powerpc/vas: Define QoS credit flag to allocate window powerpc/pseries/vas: Add hcall wrappers for VAS handling powerpc/pseries/vas: Implement getting capabilities from hypervisor powerpc/pseries/vas: Integrate API with open/close windows powerpc/pseries/vas: Setup IRQ and fault handling crypto/nx: Rename nx-842-pseries file name to nx-common-pseries crypto/nx: Get NX capabilities for GZIP coprocessor type crypto/nx: Add sysfs interface to export NX capabilities crypto/nx: Register and unregister VAS interface on PowerVM
arch/powerpc/include/asm/hvcall.h | 7 +
arch/powerpc/include/asm/vas.h | 109 +++-
arch/powerpc/include/uapi/asm/vas-api.h | 6 +-
arch/powerpc/platforms/Kconfig | 1 +
arch/powerpc/platforms/Makefile | 1 +
arch/powerpc/platforms/book3s/Kconfig | 15 +
arch/powerpc/platforms/book3s/Makefile | 2 +
arch/powerpc/platforms/book3s/vas-api.c | 493 +++++++++++++++
arch/powerpc/platforms/powernv/Kconfig | 14 -
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas-api.c | 278 --------
arch/powerpc/platforms/powernv/vas-debug.c | 27 +-
arch/powerpc/platforms/powernv/vas-fault.c | 173 +----
arch/powerpc/platforms/powernv/vas-trace.h | 4 +-
arch/powerpc/platforms/powernv/vas-window.c | 264 ++++----
arch/powerpc/platforms/powernv/vas.h | 50 +-
arch/powerpc/platforms/pseries/Makefile | 1 +
arch/powerpc/platforms/pseries/vas.c | 594 ++++++++++++++++++
arch/powerpc/platforms/pseries/vas.h | 125 ++++
drivers/crypto/nx/Kconfig | 1 +
drivers/crypto/nx/Makefile | 2 +-
drivers/crypto/nx/nx-common-powernv.c | 6 +-
.../{nx-842-pseries.c => nx-common-pseries.c} | 138 ++++
23 files changed, 1696 insertions(+), 617 deletions(-)
create mode 100644 arch/powerpc/platforms/book3s/Kconfig
create mode 100644 arch/powerpc/platforms/book3s/Makefile
create mode 100644 arch/powerpc/platforms/book3s/vas-api.c
delete mode 100644 arch/powerpc/platforms/powernv/vas-api.c
create mode 100644 arch/powerpc/platforms/pseries/vas.c
create mode 100644 arch/powerpc/platforms/pseries/vas.h
rename drivers/crypto/nx/{nx-842-pseries.c => nx-common-pseries.c} (90%)Signature · 1 line
2.18.2
PATCH v6 1/17 powerpc/powernv/vas: Release reference to tgid during window close
The kernel handles the NX fault by updating CSB or sending signal to process. In multithread applications, children can open VAS windows and can exit without closing them. But the parent can continue to send NX requests with these windows. To prevent pid reuse, reference will be taken on pid and tgid when the window is opened and release them during window close.
The current code is not releasing the tgid reference which can cause pid leak and this patch fixes the issue.
--- arch/powerpc/platforms/powernv/vas-window.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
arch/powerpc/platforms/powernv/vas-window.c +5 -4
@@ -1093,9 +1093,9 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,/* * Process closes window during exit. In the case of * multithread application, the child thread can open -* window and can exit without closing it. Expects parent -* thread to use and close the window. So do not need -* to take pid reference for parent thread. +* window and can exit without closing it. so takes tgid +* reference until window closed to make sure tgid is not +* reused. */ txwin->tgid =find_get_pid (task_tgid_vnr (current));/*
@@ -1339,8 +1339,9 @@ int vas_win_close(struct vas_window *window)/* if send window, drop reference to matching receive window */ if (window->tx_win) {if (window->user_win) { -/* Drop references to pid and mm */ +/* Drop references to pid. tgid and mm */ put_pid (window->pid); +put_pid (window->tgid);if (window->mm) {mm_context_remove_vas_window (window->mm);mmdrop (window->mm);
Signature · 1 line
2.18.2
PATCH v6 2/17 powerpc/vas: Move VAS API to book3s common platform
In reply to Haren MyneniThe pseries platform will share vas and nx code and interfaces with the PowerNV platform, so create the arch/powerpc/platforms/book3s/ directory and move VAS API code there. Functionality is not changed.
---
arch/powerpc/include/asm/vas.h | 3 +++
arch/powerpc/platforms/Kconfig | 1 +
arch/powerpc/platforms/Makefile | 1 +
arch/powerpc/platforms/book3s/Kconfig | 15 +++++++++++++++
arch/powerpc/platforms/book3s/Makefile | 2 ++
.../platforms/{powernv => book3s}/vas-api.c | 2 +-
arch/powerpc/platforms/powernv/Kconfig | 14 --------------
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas.h | 2 --
9 files changed, 24 insertions(+), 18 deletions(-)
create mode 100644 arch/powerpc/platforms/book3s/Kconfig
create mode 100644 arch/powerpc/platforms/book3s/Makefile
rename arch/powerpc/platforms/{powernv => book3s}/vas-api.c (99%)arch/powerpc/include/asm/vas.h +3 -0
@@ -162,6 +162,9 @@ int vas_copy_crb(void *crb, int offset);*/ int vas_paste_crb (struct vas_window *win,int offset,bool re); +void vas_win_paste_addr (struct vas_window *window,u64 *addr, +int *len); +/* * Register / unregister coprocessor type to VAS API which will be exported * to user space. Applications can use this API to open / close window
arch/powerpc/platforms/Kconfig +1 -0
@@ -20,6 +20,7 @@ source "arch/powerpc/platforms/embedded6xx/Kconfig" source "arch/powerpc/platforms/44x/Kconfig" source "arch/powerpc/platforms/40x/Kconfig" source "arch/powerpc/platforms/amigaone/Kconfig" +source "arch/powerpc/platforms/book3s/Kconfig" config KVM_GUEST bool "KVM Guest support"
arch/powerpc/platforms/Makefile +1 -0
@@ -22,3 +22,4 @@ obj-$(CONFIG_PPC_CELL) += cell/ obj-$(CONFIG_PPC_PS3) += ps3/ obj-$(CONFIG_EMBEDDED6xx) += embedded6xx/ obj-$(CONFIG_AMIGAONE) += amigaone/ +obj-$(CONFIG_PPC_BOOK3S) += book3s/
arch/powerpc/platforms/book3s/Kconfig new file +15 -0
@@ -0,0 +1,15 @@ +# SPDX-License-Identifier: GPL-2.0 +config PPC_VAS + bool "IBM Virtual Accelerator Switchboard (VAS)" + depends on (PPC_POWERNV || PPC_PSERIES) && PPC_64K_PAGES + default y + help + This enables support for IBM Virtual Accelerator Switchboard (VAS). + + VAS devices are found in POWER9-based and later systems, they + provide access to accelerator coprocessors such as NX-GZIP and + NX-842. This config allows the kernel to use NX-842 accelerators, + and user-mode APIs for the NX-GZIP accelerator on POWER9 PowerNV + and POWER10 PowerVM platforms. + + If unsure, say "N".
arch/powerpc/platforms/book3s/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_PPC_VAS) += vas-api.o
arch/powerpc/platforms/book3s/vas-api.c renamed from arch/powerpc/platforms/powernv/vas-api.c +1 -1
@@ -10,9 +10,9 @@#include <linux/fs.h> #include <linux/slab.h> #include <linux/uaccess.h> +#include <linux/io.h> #include <asm/vas.h> #include <uapi/asm/vas-api.h> -#include "vas.h" /* * The driver creates the device node that can be used as follows:
arch/powerpc/platforms/powernv/Kconfig +0 -14
@@ -33,20 +33,6 @@ config PPC_MEMTRACE Enabling this option allows for runtime allocation of memory (RAM) for hardware tracing. -config PPC_VAS - bool "IBM Virtual Accelerator Switchboard (VAS)" - depends on PPC_POWERNV && PPC_64K_PAGES - default y - help - This enables support for IBM Virtual Accelerator Switchboard (VAS). - - VAS allows accelerators in co-processors like NX-GZIP and NX-842 - to be accessible to kernel subsystems and user processes. - - VAS adapters are found in POWER9 based systems. - - If unsure, say N. - config SCOM_DEBUGFS bool "Expose SCOM controllers via debugfs" depends on DEBUG_FS
arch/powerpc/platforms/powernv/Makefile +1 -1
@@ -18,7 +18,7 @@ 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 vas-fault.o vas-api.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 obj-$(CONFIG_PPC_SECURE_BOOT) += opal-secvar.o
arch/powerpc/platforms/powernv/vas.h +0 -2
@@ -438,8 +438,6 @@ extern irqreturn_t vas_fault_handler(int irq, void *dev_id);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); -extern void vas_win_paste_addr (struct vas_window *window,u64 *addr, -int *len);static inline int vas_window_pid (struct vas_window *window) {
Signature · 1 line
2.18.2
PATCH v6 3/17 powerpc/powernv/vas: Rename register/unregister functions
In reply to Haren MynenipowerNV and pseries drivers register / unregister to the corresponding platform specific VAS separately. Then these VAS functions call the common API with the specific window operations. So rename powerNV VAS API register/unregister functions.
--- arch/powerpc/include/asm/vas.h | 3 +++ arch/powerpc/platforms/book3s/vas-api.c | 2 -- arch/powerpc/platforms/powernv/vas-window.c | 18 ++++++++++++++++++ drivers/crypto/nx/nx-common-powernv.c | 6 +++--- 4 files changed, 24 insertions(+), 5 deletions(-)
arch/powerpc/include/asm/vas.h +3 -0
@@ -164,6 +164,9 @@ int vas_paste_crb(struct vas_window *win, int offset, bool re);void vas_win_paste_addr (struct vas_window *window,u64 *addr,int *len); +int vas_register_api_powernv (struct module *mod,enum vas_cop_type cop_type, +const char *name); +void vas_unregister_api_powernv (void );/* * Register / unregister coprocessor type to VAS API which will be exported
arch/powerpc/platforms/book3s/vas-api.c +0 -2
@@ -262,7 +262,6 @@ int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type,unregister_chrdev_region (coproc_device.devt,1 );return rc; } -EXPORT_SYMBOL_GPL (vas_register_coproc_api);void vas_unregister_coproc_api (void ) {
@@ -275,4 +274,3 @@ void vas_unregister_coproc_api(void)class_destroy (coproc_device.class);unregister_chrdev_region (coproc_device.devt,1 ); } -EXPORT_SYMBOL_GPL (vas_unregister_coproc_api);
arch/powerpc/platforms/powernv/vas-window.c +18 -0
@@ -1442,3 +1442,21 @@ struct vas_window *vas_pswid_to_window(struct vas_instance *vinst,return window; } + +/* +* Supporting only nx-gzip coprocessor type now, but this API code +* extended to other coprocessor types later. +*/ +int vas_register_api_powernv (struct module *mod,enum vas_cop_type cop_type, +const char *name) +{ + +return vas_register_coproc_api (mod, cop_type, name); +} +EXPORT_SYMBOL_GPL (vas_register_api_powernv); + +void vas_unregister_api_powernv (void ) +{ +vas_unregister_coproc_api (); +} +EXPORT_SYMBOL_GPL (vas_unregister_api_powernv);
drivers/crypto/nx/nx-common-powernv.c +3 -3
@@ -1092,8 +1092,8 @@ static __init int nx_compress_powernv_init(void)* normal FIFO priority is assigned for userspace. * 842 compression is supported only in kernel. */ - ret =vas_register_coproc_api (THIS_MODULE ,VAS_COP_TYPE_GZIP , -"nx-gzip" ); + ret =vas_register_api_powernv (THIS_MODULE ,VAS_COP_TYPE_GZIP , +"nx-gzip" );/* * GZIP is not supported in kernel right now.
@@ -1129,7 +1129,7 @@ static void __exit nx_compress_powernv_exit(void)* use. So delete this API use for GZIP engine. */ if (!nx842_ct) -vas_unregister_coproc_api (); +vas_unregister_api_powernv ();crypto_unregister_alg (&nx842_powernv_alg);
Signature · 1 line
2.18.2
PATCH v6 4/17 powerpc/vas: Add platform specific user window operations
In reply to Haren MyneniPowerNV uses registers to open/close VAS windows, and getting the paste address. Whereas the hypervisor calls are used on PowerVM.
This patch adds the platform specific user space window operations and register with the common VAS user space interface.
--- arch/powerpc/include/asm/vas.h | 16 +++++-- arch/powerpc/platforms/book3s/vas-api.c | 53 +++++++++++++-------- arch/powerpc/platforms/powernv/vas-window.c | 45 ++++++++++++++++- arch/powerpc/platforms/powernv/vas.h | 2 + 4 files changed, 91 insertions(+), 25 deletions(-)
arch/powerpc/include/asm/vas.h +13 -3
@@ -5,6 +5,7 @@#ifndef _ASM_POWERPC_VAS_H#define _ASM_POWERPC_VAS_H +#include <uapi/asm/vas-api.h> struct vas_window ;
@@ -48,6 +49,16 @@ enum vas_cop_type { VAS_COP_TYPE_MAX, }; +/* +* User space window operations used for powernv and powerVM +*/ +struct vas_user_win_ops { +struct vas_window * (*open_win)(int vas_id,u64 flags, +enum vas_cop_type ); +u64 (*paste_addr)(struct vas_window *); +int (*close_win)(struct vas_window *); +}; +/* * Receive window attributes specified by the (in-kernel) owner of window. */
@@ -162,8 +173,6 @@ int vas_copy_crb(void *crb, int offset);*/ int vas_paste_crb (struct vas_window *win,int offset,bool re); -void vas_win_paste_addr (struct vas_window *window,u64 *addr, -int *len);int vas_register_api_powernv (struct module *mod,enum vas_cop_type cop_type,const char *name);void vas_unregister_api_powernv (void );
@@ -177,7 +186,8 @@ void vas_unregister_api_powernv(void);* used for others in future. */ int vas_register_coproc_api (struct module *mod,enum vas_cop_type cop_type, -const char *name); +const char *name, +const struct vas_user_win_ops *vops);void vas_unregister_coproc_api (void );#endif /* __ASM_POWERPC_VAS_H */
arch/powerpc/platforms/book3s/vas-api.c +32 -21
105 lines not on this page · raw message
arch/powerpc/platforms/powernv/vas-window.c +44 -1
63 lines not on this page · raw message
arch/powerpc/platforms/powernv/vas.h +2 -0
@@ -438,6 +438,8 @@ extern irqreturn_t vas_fault_handler(int irq, void *dev_id);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); +extern void vas_win_paste_addr (struct vas_window *window,u64 *addr, +int *len);static inline int vas_window_pid (struct vas_window *window) {
Signature · 1 line
2.18.2
Nicholas Piggin
reviewerRe: [PATCH v6 04/17] powerpc/vas: Add platform specific user window operations
Excerpts from Haren Myneni's message of June 18, 2021 6:31 am:
Quoted 29 lines
PowerNV uses registers to open/close VAS windows, and getting the paste address. Whereas the hypervisor calls are used on PowerVM.
This patch adds the platform specific user space window operations and register with the common VAS user space interface.
Signed-off-by Haren Myneni <[email protected]>Reviewed-by Nicholas Piggin <[email protected]>--- arch/powerpc/include/asm/vas.h | 16 +++++-- arch/powerpc/platforms/book3s/vas-api.c | 53 +++++++++++++-------- arch/powerpc/platforms/powernv/vas-window.c | 45 ++++++++++++++++- arch/powerpc/platforms/powernv/vas.h | 2 + 4 files changed, 91 insertions(+), 25 deletions(-)arch/powerpc/include/asm/vas.h +1
-0@@ -5,6 +5,7 @@#ifndef _ASM_POWERPC_VAS_H#define _ASM_POWERPC_VAS_H +#include <uapi/asm/vas-api.h> struct vas_window ;
arch/powerpc/include/asm/vas.h enum vas_cop_type { · line 57
Quoted 9 lines
arch/powerpc/include/asm/vas.h +6
-0@@ -48,6 +49,16 @@ enum vas_cop_type { VAS_COP_TYPE_MAX, }; +/* +* User space window operations used for powernv and powerVM +*/ +struct vas_user_win_ops { +struct vas_window * (*open_win)(int vas_id,u64 flags, +enum vas_cop_type );
Thanks for changing that to not pass down the struct passed in by the user. Looks good.
Thanks,
Nick
PATCH v6 5/17 powerpc/vas: Create take/drop pid and mm reference functions
In reply to Haren MyneniTake pid and mm references when each window opens and drops during close. This functionality is needed for powerNV and pseries. So this patch defines the existing code as functions in common book3s platform vas-api.c
--- arch/powerpc/include/asm/vas.h | 40 +++++++++++++++ arch/powerpc/platforms/book3s/vas-api.c | 39 +++++++++++++++ arch/powerpc/platforms/powernv/vas-fault.c | 10 ++-- arch/powerpc/platforms/powernv/vas-window.c | 55 ++------------------- arch/powerpc/platforms/powernv/vas.h | 6 +-- 5 files changed, 91 insertions(+), 59 deletions(-)
arch/powerpc/include/asm/vas.h +40 -0
@@ -5,6 +5,9 @@#ifndef _ASM_POWERPC_VAS_H#define _ASM_POWERPC_VAS_H +#include <linux/sched/mm.h> +#include <linux/mmu_context.h> +#include <asm/icswx.h> #include <uapi/asm/vas-api.h> struct vas_window ;
@@ -49,6 +52,17 @@ enum vas_cop_type { VAS_COP_TYPE_MAX, }; +/* +* User space VAS windows are opened by tasks and take references +* to pid and mm until windows are closed. +* Stores pid, mm, and tgid for each window. +*/ +struct vas_user_win_ref { +struct pid *pid;/* PID of owner */ +struct pid *tgid;/* Thread group ID of owner */ +struct mm_struct *mm;/* Linux process mm_struct */ +}; +/* * User space window operations used for powernv and powerVM */
@@ -59,6 +73,31 @@ struct vas_user_win_ops {int (*close_win)(struct vas_window *); }; +static inline void put_vas_user_win_ref (struct vas_user_win_ref *ref) +{ +/* Drop references to pid, tgid, and mm */ +put_pid (ref->pid); +put_pid (ref->tgid); +if (ref->mm) +mmdrop (ref->mm); +} + +static inline void vas_user_win_add_mm_context (struct vas_user_win_ref *ref) +{ +mm_context_add_vas_window (ref->mm); +/* +* Even a process that has no foreign real address mapping can +* use an unpaired COPY instruction (to no real effect). Issue +* CP_ABORT to clear any pending COPY and prevent a covert +* channel. +* +* __switch_to() will issue CP_ABORT on future context switches +* if process / thread has any open VAS window (Use +* current->mm->context.vas_windows). +*/ + asm volatile(PPC_CP_ABORT); +} +/* * Receive window attributes specified by the (in-kernel) owner of window. */
@@ -190,4 +229,5 @@ int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type, const struct vas_user_win_ops *vops);void vas_unregister_coproc_api (void ); +int get_vas_user_win_ref (struct vas_user_win_ref *task_ref);#endif /* __ASM_POWERPC_VAS_H */
arch/powerpc/platforms/book3s/vas-api.c +39 -0
@@ -55,6 +55,45 @@ static char *coproc_devnode(struct device *dev, umode_t *mode)return kasprintf (GFP_KERNEL ,"crypto/%s" ,dev_name (dev)); } +/* +* Take reference to pid and mm +*/ +int get_vas_user_win_ref (struct vas_user_win_ref *task_ref) +{ +/* +* Window opened by a 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 - needed only for multithread +* applications. +*/ + task_ref->pid =get_task_pid (current,PIDTYPE_PID ); +/* +* Acquire a reference to the task's mm. +*/ + task_ref->mm =get_task_mm (current); +if (!task_ref->mm) { +put_pid (task_ref->pid); +pr_err ("VAS: pid(%d): mm_struct is not found\n" , + current->pid); +return -EPERM ; + } + +mmgrab (task_ref->mm); +mmput (task_ref->mm); +/* +* Process closes window during exit. In the case of +* multithread application, the child thread can open +* window and can exit without closing it. So takes tgid +* reference until window closed to make sure tgid is not +* reused. +*/ + task_ref->tgid =find_get_pid (task_tgid_vnr (current)); + +return 0 ; +} +static int coproc_open (struct inode *inode,struct file *fp) {struct coproc_instance *cp_inst;
arch/powerpc/platforms/powernv/vas-fault.c +5 -5
@@ -73,7 +73,7 @@ static void update_csb(struct vas_window *window,* 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)) +if (WARN_ON_ONCE (!window->task_ref.mm || !window->user_win))return ; csb_addr = (void __user *)be64_to_cpu (crb->csb_addr);
@@ -92,7 +92,7 @@ static void update_csb(struct vas_window *window, csb.address = crb->stamp.nx.fault_storage_addr; csb.flags =0 ; - pid = window->pid; + pid = window->task_ref.pid; tsk =get_pid_task (pid,PIDTYPE_PID );/* * Process closes send window after all pending NX requests are
@@ -111,7 +111,7 @@ static void update_csb(struct vas_window *window,* a window and exits without closing it. */ if (!tsk) { - pid = window->tgid; + pid = window->task_ref.tgid; tsk =get_pid_task (pid,PIDTYPE_PID );/* * Parent thread (tgid) will be closing window when it
@@ -127,7 +127,7 @@ static void update_csb(struct vas_window *window,return ; } -kthread_use_mm (window->mm); +kthread_use_mm (window->task_ref.mm); rc =copy_to_user (csb_addr, &csb,sizeof (csb));/* * User space polls on csb.flags (first byte). So add barrier
@@ -139,7 +139,7 @@ static void update_csb(struct vas_window *window,smp_mb (); rc =copy_to_user (csb_addr, &csb,sizeof (u8)); } -kthread_unuse_mm (window->mm); +kthread_unuse_mm (window->task_ref.mm);put_task_struct (tsk);/* Success */
arch/powerpc/platforms/powernv/vas-window.c +5 -50
69 lines not on this page · raw message
arch/powerpc/platforms/powernv/vas.h +2 -4
@@ -357,11 +357,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 */ -struct pid *pid;/* Linux process id of owner */ -struct pid *tgid;/* Thread group ID of owner */ -struct mm_struct *mm;/* Linux process mm_struct */ int wcreds_max;/* Window credits */ +struct vas_user_win_ref task_ref;char *dbgname;struct dentry *dbgdir;
@@ -443,7 +441,7 @@ extern void vas_win_paste_addr(struct vas_window *window, u64 *addr,static inline int vas_window_pid (struct vas_window *window) { -return pid_vnr (window->pid); +return pid_vnr (window->task_ref.pid); } static inline void vas_log_write(struct vas_window *win, char *name,
Signature · 1 line
2.18.2
PATCH v6 6/17 powerpc/vas: Move update_csb/dump_crb to common book3s platform
In reply to Haren MyneniIf a coprocessor encounters an error translating an address, the VAS will cause an interrupt in the host. The kernel processes the fault by updating CSB. This functionality is same for both powerNV and pseries. So this patch moves these functions to common vas-api.c and the actual functionality is not changed.
--- arch/powerpc/include/asm/vas.h | 3 + arch/powerpc/platforms/book3s/vas-api.c | 167 +++++++++++++++++++++ arch/powerpc/platforms/powernv/vas-fault.c | 155 ++----------------- 3 files changed, 179 insertions(+), 146 deletions(-)
arch/powerpc/include/asm/vas.h +3 -0
@@ -230,4 +230,7 @@ int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type,void vas_unregister_coproc_api (void );int get_vas_user_win_ref (struct vas_user_win_ref *task_ref); +void vas_update_csb (struct coprocessor_request_block *crb, +struct vas_user_win_ref *task_ref); +void vas_dump_crb (struct coprocessor_request_block *crb);#endif /* __ASM_POWERPC_VAS_H */
arch/powerpc/platforms/book3s/vas-api.c +167 -0
179 lines not on this page · raw message
arch/powerpc/platforms/powernv/vas-fault.c +9 -146
173 lines not on this page · raw message
Signature · 1 line
2.18.2
Re: [PATCH v6 06/17] powerpc/vas: Move update_csb/dump_crb to common book3s platform
Excerpts from Haren Myneni's message of June 18, 2021 6:32 am:
Quoted 69 lines
If a coprocessor encounters an error translating an address, the VAS will cause an interrupt in the host. The kernel processes the fault by updating CSB. This functionality is same for both powerNV and pseries. So this patch moves these functions to common
vas-api.cand the actual functionality is not changed.Signed-off-by Haren Myneni <[email protected]>Reviewed-by Nicholas Piggin <[email protected]>--- arch/powerpc/include/asm/vas.h | 3 + arch/powerpc/platforms/book3s/vas-api.c | 167 +++++++++++++++++++++ arch/powerpc/platforms/powernv/vas-fault.c | 155 ++----------------- 3 files changed, 179 insertions(+), 146 deletions(-)arch/powerpc/include/asm/vas.h +3
-0@@ -230,4 +230,7 @@ int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type,void vas_unregister_coproc_api (void );int get_vas_user_win_ref (struct vas_user_win_ref *task_ref); +void vas_update_csb (struct coprocessor_request_block *crb, +struct vas_user_win_ref *task_ref); +void vas_dump_crb (struct coprocessor_request_block *crb);#endif /* __ASM_POWERPC_VAS_H */ arch/powerpc/platforms/book3s/vas-api.c +27
-0@@ -10,6 +10,9 @@#include <linux/fs.h> #include <linux/slab.h> #include <linux/uaccess.h> +#include <linux/kthread.h> +#include <linux/sched/signal.h> +#include <linux/mmu_context.h> #include <linux/io.h> #include <asm/vas.h> #include <uapi/asm/vas-api.h> @@ -94,6 +97,170 @@ int get_vas_user_win_ref(struct vas_user_win_ref *task_ref)return 0 ; } +/* +* Successful return must release the task reference with +* put_task_struct +*/ +static bool ref_get_pid_and_task (struct vas_user_win_ref *task_ref, +struct task_struct **tskp,struct pid **pidp) +{ +struct task_struct *tsk; +struct pid *pid; + + pid = task_ref->pid; + tsk =get_pid_task (pid,PIDTYPE_PID ); +if (!tsk) { + pid = task_ref->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 false; + } + +/* Return if the task is exiting. */
arch/powerpc/platforms/book3s/vas-api.c int get_vas_user_win_ref(struct vas_user_win_ref *task_ref) · line 133
Quoted 10 lines
arch/powerpc/platforms/book3s/vas-api.c +10
-0+if (tsk->flags &PF_EXITING ) { +put_task_struct (tsk); +return false; + } + + *tskp = tsk; + *pidp = pid; + +return true; +}
Thanks for making this change.
I think that's good to factor all these out and put them together.
Quoted 318 lines
arch/powerpc/platforms/book3s/vas-api.c +130
-0+ +/* +* 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. +*/ +void vas_update_csb (struct coprocessor_request_block *crb, +struct vas_user_win_ref *task_ref) +{ +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 (!task_ref->mm)) +return ; + + csb_addr = (void __user *)be64_to_cpu (crb->csb_addr); + +memset (&csb,0 ,sizeof (csb)); + csb.cc =CSB_CC_FAULT_ADDRESS ; + 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 ; + +/* +* 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 (!ref_get_pid_and_task (task_ref, &tsk, &pid)) +return ; + +kthread_use_mm (task_ref->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)); + } +kthread_unuse_mm (task_ref->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); +} + +void vas_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, nx->fault_status); +} +static int coproc_open (struct inode *inode,struct file *fp) {struct coproc_instance *cp_inst;arch/powerpc/platforms/powernv/vas-fault.c +9
-146@@ -26,150 +26,6 @@*/ #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, nx->fault_status); -} - -/* -* 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->task_ref.mm || !window->user_win)) -return ; - - csb_addr = (void __user *)be64_to_cpu (crb->csb_addr); - -memset (&csb,0 ,sizeof (csb)); - csb.cc =CSB_CC_FAULT_ADDRESS ; - 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->task_ref.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->task_ref.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 ; - } - -kthread_use_mm (window->task_ref.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)); - } -kthread_unuse_mm (window->task_ref.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); -} -static void dump_fifo (struct vas_instance *vinst,void *entry) {unsigned long *end = vinst->fault_fifo + vinst->fault_fifo_size;@@ -272,7 +128,7 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data) vinst->vas_id, vinst->fault_fifo, fifo, vinst->fault_crbs); -dump_crb (crb); +vas_dump_crb (crb); window =vas_pswid_to_window (vinst,be32_to_cpu (crb->stamp.nx.pswid));@@ -293,7 +149,14 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data)WARN_ON_ONCE (1 ); }else { -update_csb (window, crb); +/* +* NX sees faults only with user space windows. +*/ +if (window->user_win) +vas_update_csb (crb, &window->task_ref); +else +WARN_ON_ONCE (!window->user_win); +/* * Return credit for send window after processing * fault CRB. Signature · 1 line
2.18.2
PATCH v6 7/17 powerpc/vas: Define and use common vas_window struct
In reply to Haren MyneniMany elements in vas_struct are used on PowerNV and PowerVM platforms. vas_window is used for both TX and RX windows on PowerNV and for TX windows on PowerVM. So some elements are specific to these platforms.
So this patch defines common vas_window and platform specific window structs (pnv_vas_window on PowerNV). Also adds the corresponding changes in PowerNV vas code.
--- arch/powerpc/include/asm/vas.h | 14 +- arch/powerpc/platforms/powernv/vas-debug.c | 27 ++-- arch/powerpc/platforms/powernv/vas-fault.c | 20 +-- arch/powerpc/platforms/powernv/vas-trace.h | 4 +- arch/powerpc/platforms/powernv/vas-window.c | 161 +++++++++++--------- arch/powerpc/platforms/powernv/vas.h | 44 +++--- 6 files changed, 144 insertions(+), 126 deletions(-)
arch/powerpc/include/asm/vas.h +12 -2
@@ -10,8 +10,6 @@#include <asm/icswx.h> #include <uapi/asm/vas-api.h> -struct vas_window ; -/* * Min and max FIFO sizes are based on Version 1.05 Section 3.1.4.25 * (Local FIFO Size Register) of the VAS workbook.
@@ -63,6 +61,18 @@ struct vas_user_win_ref {struct mm_struct *mm;/* Linux process mm_struct */ }; +/* +* Common VAS window struct on PowerNV and PowerVM +*/ +struct vas_window { +u32 winid; +u32 wcreds_max;/* Window credits */ +enum vas_cop_type cop; +struct vas_user_win_ref task_ref; +char *dbgname; +struct dentry *dbgdir; +}; +/* * User space window operations used for powernv and powerVM */
arch/powerpc/platforms/powernv/vas-debug.c +15 -12
@@ -9,6 +9,7 @@#include <linux/slab.h> #include <linux/debugfs.h> #include <linux/seq_file.h> +#include <asm/vas.h> #include "vas.h" static struct dentry *vas_debugfs;
@@ -28,7 +29,7 @@ static char *cop_to_str(int cop)static int info_show (struct seq_file *s,void *private) { -struct vas_window *window = s->private; +struct pnv_vas_window *window = s->private;mutex_lock (&vas_mutex);
@@ -36,9 +37,9 @@ static int info_show(struct seq_file *s, void *private)if (!window->hvwc_map) goto unlock; -seq_printf (s,"Type: %s, %s\n" ,cop_to_str (window->cop), +seq_printf (s,"Type: %s, %s\n" ,cop_to_str (window->vas_win.cop), window->tx_win ?"Send" :"Receive" ); -seq_printf (s,"Pid : %d\n" ,vas_window_pid (window)); +seq_printf (s,"Pid : %d\n" ,vas_window_pid (&window->vas_win)); unlock:mutex_unlock (&vas_mutex);
@@ -47,7 +48,7 @@ static int info_show(struct seq_file *s, void *private)DEFINE_SHOW_ATTRIBUTE (info); -static inline void print_reg (struct seq_file *s,struct vas_window *win, +static inline void print_reg (struct seq_file *s,struct pnv_vas_window *win,char *name,u32 reg) {seq_printf (s,"0x%016llx %s\n" ,read_hvwc_reg (win, name, reg), name);
@@ -55,7 +56,7 @@ static inline void print_reg(struct seq_file *s, struct vas_window *win,static int hvwc_show (struct seq_file *s,void *private) { -struct vas_window *window = s->private; +struct pnv_vas_window *window = s->private;mutex_lock (&vas_mutex);
@@ -103,8 +104,10 @@ static int hvwc_show(struct seq_file *s, void *private)DEFINE_SHOW_ATTRIBUTE (hvwc); -void vas_window_free_dbgdir (struct vas_window *window) +void vas_window_free_dbgdir (struct pnv_vas_window *pnv_win) { +struct vas_window *window = &pnv_win->vas_win; +if (window->dbgdir) {debugfs_remove_recursive (window->dbgdir);kfree (window->dbgname);
@@ -113,21 +116,21 @@ void vas_window_free_dbgdir(struct vas_window *window) } } -void vas_window_init_dbgdir (struct vas_window *window) +void vas_window_init_dbgdir (struct pnv_vas_window *window) {struct dentry *d;if (!window->vinst->dbgdir)return ; - window->dbgname =kzalloc (16 ,GFP_KERNEL ); -if (!window->dbgname) + window->vas_win.dbgname =kzalloc (16 ,GFP_KERNEL ); +if (!window->vas_win.dbgname)return ; -snprintf (window->dbgname,16 ,"w%d" , window->winid); +snprintf (window->vas_win.dbgname,16 ,"w%d" , window->vas_win.winid); - d =debugfs_create_dir (window->dbgname, window->vinst->dbgdir); - window->dbgdir = d; + d =debugfs_create_dir (window->vas_win.dbgname, window->vinst->dbgdir); + window->vas_win.dbgdir = d;debugfs_create_file ("info" ,0444 , d, window, &info_fops);debugfs_create_file ("hvwc" ,0444 , d, window, &hvwc_fops);
arch/powerpc/platforms/powernv/vas-fault.c +10 -10
@@ -68,7 +68,7 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data)struct vas_instance *vinst = data;struct coprocessor_request_block *crb, *entry;struct coprocessor_request_block buf; -struct vas_window *window; +struct pnv_vas_window *window;unsigned long flags;void *fifo;
@@ -153,7 +153,7 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data)* NX sees faults only with user space windows. */ if (window->user_win) -vas_update_csb (crb, &window->task_ref); +vas_update_csb (crb, &window->vas_win.task_ref);else WARN_ON_ONCE (!window->user_win);
@@ -199,6 +199,7 @@ irqreturn_t vas_fault_handler(int irq, void *dev_id)int vas_setup_fault_window (struct vas_instance *vinst) {struct vas_rx_win_attr attr; +struct vas_window *win; vinst->fault_fifo_size =VAS_FAULT_WIN_FIFO_SIZE ; vinst->fault_fifo =kzalloc (vinst->fault_fifo_size,GFP_KERNEL );
@@ -227,18 +228,17 @@ int vas_setup_fault_window(struct vas_instance *vinst) 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)); + win =vas_rx_win_open (vinst->vas_id,VAS_COP_TYPE_FAULT , &attr); +if (IS_ERR (win)) { +pr_err ("VAS: Error %ld opening FaultWin\n" ,PTR_ERR (win));kfree (vinst->fault_fifo); -return PTR_ERR (vinst->fault_win); +return PTR_ERR (win); } + vinst->fault_win = container_of(win, struct pnv_vas_window, vas_win); +pr_devel ("VAS: Created FaultWin %d, LPID/PID/TID [%d/%d/%d]\n" , - vinst->fault_win->winid, attr.lnotify_lpid, + vinst->fault_win->vas_win.winid, attr.lnotify_lpid, attr.lnotify_pid, attr.lnotify_tid);return 0 ;
arch/powerpc/platforms/powernv/vas-trace.h +2 -2
@@ -80,7 +80,7 @@ TRACE_EVENT( vas_tx_win_open, TRACE_EVENT( vas_paste_crb, TP_PROTO(struct task_struct *tsk, - struct vas_window *win), + struct pnv_vas_window *win), TP_ARGS(tsk, win),
@@ -96,7 +96,7 @@ TRACE_EVENT( vas_paste_crb,TP_fast_assign ( __entry->pid = tsk->pid; __entry->vasid = win->vinst->vas_id; - __entry->winid = win->winid; + __entry->winid = win->vas_win.winid; __entry->paste_kaddr = (unsigned long )win->paste_kaddr ),
arch/powerpc/platforms/powernv/vas-window.c +86 -75
531 lines not on this page · raw message
arch/powerpc/platforms/powernv/vas.h +19 -25
105 lines not on this page · raw message
Signature · 1 line
2.18.2
PATCH v6 8/17 powerpc/pseries/vas: Define VAS/NXGZIP hcalls and structs
In reply to Haren MyneniThis patch adds hcalls and other definitions. Also define structs that are used in VAS implementation on PowerVM.
--- arch/powerpc/include/asm/hvcall.h | 7 ++ arch/powerpc/include/asm/vas.h | 30 +++++++ arch/powerpc/platforms/pseries/vas.h | 125 +++++++++++++++++++++++++++ 3 files changed, 162 insertions(+) create mode 100644 arch/powerpc/platforms/pseries/vas.h
arch/powerpc/include/asm/hvcall.h +7 -0
@@ -294,6 +294,13 @@#define H_RESIZE_HPT_COMMIT 0x370#define H_REGISTER_PROC_TBL 0x37C#define H_SIGNAL_SYS_RESET 0x380 +#define H_ALLOCATE_VAS_WINDOW 0x388 +#define H_MODIFY_VAS_WINDOW 0x38C +#define H_DEALLOCATE_VAS_WINDOW 0x390 +#define H_QUERY_VAS_WINDOW 0x394 +#define H_QUERY_VAS_CAPABILITIES 0x398 +#define H_QUERY_NX_CAPABILITIES 0x39C +#define H_GET_NX_FAULT 0x3A0#define H_INT_GET_SOURCE_INFO 0x3A8#define H_INT_SET_SOURCE_CONFIG 0x3AC#define H_INT_GET_SOURCE_CONFIG 0x3B0
arch/powerpc/include/asm/vas.h +30 -0
@@ -160,6 +160,7 @@ struct vas_tx_win_attr {bool rx_win_ord_mode; }; +#ifdef CONFIG_PPC_POWERNV /* * Helper to map a chip id to VAS id. * For POWER9, this is a 1:1 mapping. In the future this maybe a 1:N
@@ -225,6 +226,35 @@ int vas_paste_crb(struct vas_window *win, int offset, bool re);int vas_register_api_powernv (struct module *mod,enum vas_cop_type cop_type,const char *name);void vas_unregister_api_powernv (void ); +#endif + +#ifdef CONFIG_PPC_PSERIES + +/* VAS Capabilities */ +#define VAS_GZIP_QOS_FEAT 0x1 +#define VAS_GZIP_DEF_FEAT 0x2 +#define VAS_GZIP_QOS_FEAT_BIT PPC_BIT(VAS_GZIP_QOS_FEAT)/* Bit 1 */ +#define VAS_GZIP_DEF_FEAT_BIT PPC_BIT(VAS_GZIP_DEF_FEAT)/* Bit 2 */ + +/* NX Capabilities */ +#define VAS_NX_GZIP_FEAT 0x1 +#define VAS_NX_GZIP_FEAT_BIT PPC_BIT(VAS_NX_GZIP_FEAT)/* Bit 1 */ + +/* +* These structs are used to retrieve overall VAS capabilities that +* the hypervisor provides. +*/ +struct hv_vas_all_caps { +__be64 descriptor; +__be64 feat_type; +} __packed__aligned(0x1000) ; + +struct vas_all_caps { +u64 descriptor; +u64 feat_type; +}; + +#endif /* * Register / unregister coprocessor type to VAS API which will be exported
arch/powerpc/platforms/pseries/vas.h new file +125 -0
125 lines not on this page · raw message
Signature · 1 line
2.18.2
PATCH v6 9/17 powerpc/vas: Define QoS credit flag to allocate window
In reply to Haren MyneniPowerVM introduces two different type of credits: Default and Quality of service (QoS).
The total number of default credits available on each LPAR depends on CPU resources configured. But these credits can be shared or over-committed across LPARs in shared mode which can result in paste command failure (RMA_busy). To avoid NX HW contention, the hypervisor ntroduces QoS credit type which makes sure guaranteed access to NX esources. The system admins can assign QoS credits or each LPAR via HMC.
Default credit type is used to allocate a VAS window by default as on PowerVM implementation. But the process can pass VAS_TX_WIN_FLAG_QOS_CREDIT flag with VAS_TX_WIN_OPEN ioctl to open QoS type window.
--- arch/powerpc/include/uapi/asm/vas-api.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
arch/powerpc/include/uapi/asm/vas-api.h +5 -1
@@ -13,11 +13,15 @@#define VAS_MAGIC 'v'#define VAS_TX_WIN_OPEN _IOW(VAS_MAGIC, 0x20, struct vas_tx_win_open_attr) +/* Flags to VAS TX open window ioctl */ +/* To allocate a window with QoS credit, otherwise use default credit */ +#define VAS_TX_WIN_FLAG_QOS_CREDIT 0x0000000000000001 +struct vas_tx_win_open_attr {__u32 version;__s16 vas_id;/* specific instance of vas or -1 for default */ __u16 reserved1; -__u64 flags;/* Future use */ +__u64 flags;__u64 reserved2[6 ]; };
Signature · 1 line
2.18.2
PATCH v6 10/17 powerpc/pseries/vas: Add hcall wrappers for VAS handling
In reply to Haren MyneniThis patch adds the following hcall wrapper functions to allocate, modify and deallocate VAS windows, and retrieve VAS capabilities.
H_ALLOCATE_VAS_WINDOW: Allocate VAS windowH_DEALLOCATE_VAS_WINDOW: Close VAS windowH_MODIFY_VAS_WINDOW: Setup window before usingH_QUERY_VAS_CAPABILITIES: Get VAS capabilities
--- arch/powerpc/platforms/pseries/vas.c | 147 +++++++++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 arch/powerpc/platforms/pseries/vas.c
arch/powerpc/platforms/pseries/vas.c new file +147 -0
@@ -0,0 +1,147 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright 2020-21 IBM Corp. +*/ + +#define pr_fmt (fmt) "vas: " fmt + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/export.h> +#include <linux/types.h> +#include <linux/delay.h> +#include <asm/hvcall.h> +#include <asm/plpar_wrappers.h> +#include <asm/vas.h> +#include "vas.h" + +#define VAS_INVALID_WIN_ADDRESS 0xFFFFFFFFFFFFFFFFul +#define VAS_DEFAULT_DOMAIN_ID 0xFFFFFFFFFFFFFFFFul +/* The hypervisor allows one credit per window right now */ +#define DEF_WIN_CREDS 1 + +static long hcall_return_busy_check (long rc) +{ +/* Check if we are stalled for some time */ +if (H_IS_LONG_BUSY (rc)) { +msleep (get_longbusy_msecs (rc)); + rc =H_BUSY ; + }else if (rc ==H_BUSY ) { +cond_resched (); + } + +return rc; +} + +/* +* Allocate VAS window hcall +*/ +static int h_allocate_vas_window (struct pseries_vas_window *win,u64 *domain, +u8 wintype,u16 credits) +{ +long retbuf[PLPAR_HCALL9_BUFSIZE ] = {0 }; +long rc; + +do { + rc =plpar_hcall9 (H_ALLOCATE_VAS_WINDOW , retbuf, wintype, + credits, domain[0 ], domain[1 ], domain[2 ], + domain[3 ], domain[4 ], domain[5 ]); + + rc =hcall_return_busy_check (rc); + }while (rc ==H_BUSY ); + +if (rc ==H_SUCCESS ) { +if (win->win_addr ==VAS_INVALID_WIN_ADDRESS ) { +pr_err ("H_ALLOCATE_VAS_WINDOW: COPY/PASTE is not supported\n" ); +return -ENOTSUPP ; + } + win->vas_win.winid = retbuf[0 ]; + win->win_addr = retbuf[1 ]; + win->complete_irq = retbuf[2 ]; + win->fault_irq = retbuf[3 ]; +return 0 ; + } + +pr_err ("H_ALLOCATE_VAS_WINDOW error: %ld, wintype: %u, credits: %u\n" , + rc, wintype, credits); + +return -EIO ; +} + +/* +* Deallocate VAS window hcall. +*/ +static int h_deallocate_vas_window (u64 winid) +{ +long rc; + +do { + rc =plpar_hcall_norets (H_DEALLOCATE_VAS_WINDOW , winid); + + rc =hcall_return_busy_check (rc); + }while (rc ==H_BUSY ); + +if (rc ==H_SUCCESS ) +return 0 ; + +pr_err ("H_DEALLOCATE_VAS_WINDOW error: %ld, winid: %llu\n" , + rc, winid); +return -EIO ; +} + +/* +* Modify VAS window. +* After the window is opened with allocate window hcall, configure it +* with flags and LPAR PID before using. +*/ +static int h_modify_vas_window (struct pseries_vas_window *win) +{ +long rc; +u32 lpid =mfspr (SPRN_PID ); + +/* +* AMR value is not supported in Linux VAS implementation. +* The hypervisor ignores it if 0 is passed. +*/ +do { + rc =plpar_hcall_norets (H_MODIFY_VAS_WINDOW , + win->vas_win.winid, lpid,0 , +VAS_MOD_WIN_FLAGS ,0 ); + + rc =hcall_return_busy_check (rc); + }while (rc ==H_BUSY ); + +if (rc ==H_SUCCESS ) +return 0 ; + +pr_err ("H_MODIFY_VAS_WINDOW error: %ld, winid %u lpid %u\n" , + rc, win->vas_win.winid, lpid); +return -EIO ; +} + +/* +* This hcall is used to determine the capabilities from the hypervisor. +* @hcall: H_QUERY_VAS_CAPABILITIES or H_QUERY_NX_CAPABILITIES +* @query_type: If 0 is passed, the hypervisor returns the overall +* capabilities which provides all feature(s) that are +* available. Then query the hypervisor to get the +* corresponding capabilities for the specific feature. +* Example: H_QUERY_VAS_CAPABILITIES provides VAS GZIP QoS +* and VAS GZIP Default capabilities. +* H_QUERY_NX_CAPABILITIES provides NX GZIP +* capabilities. +* @result: Return buffer to save capabilities. +*/ +int h_query_vas_capabilities (const u64 hcall,u8 query_type,u64 result) +{ +long rc; + + rc =plpar_hcall_norets (hcall, query_type, result); + +if (rc ==H_SUCCESS ) +return 0 ; + +pr_err ("HCALL(%llx) error %ld, query_type %u, result buffer 0x%llx\n" , + hcall, rc, query_type, result); +return -EIO ; +}
Signature · 1 line
2.18.2
PATCH v6 11/17 powerpc/pseries/vas: Implement getting capabilities from hypervisor
In reply to Haren MyneniThe hypervisor provides VAS capabilities for GZIP default and QoS features. These capabilities gives information for the specific features such as total number of credits available in LPAR, maximum credits allowed per window, maximum credits allowed in LPAR, whether usermode copy/paste is supported, and etc.
This patch adds the following:
- Retrieve all features that are provided by hypervisor using H_QUERY_VAS_CAPABILITIES hcall with 0 as feature type.
- Retrieve capabilities for the specific feature using the same hcall and the feature type (1 for QoS and 2 for default type).
--- arch/powerpc/platforms/pseries/vas.c | 122 +++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)
arch/powerpc/platforms/pseries/vas.c +122 -0
@@ -10,6 +10,7 @@#include <linux/export.h> #include <linux/types.h> #include <linux/delay.h> +#include <asm/machdep.h> #include <asm/hvcall.h> #include <asm/plpar_wrappers.h> #include <asm/vas.h>
@@ -20,6 +21,11 @@/* The hypervisor allows one credit per window right now */ #define DEF_WIN_CREDS 1 +static struct vas_all_caps caps_all; +static bool copypaste_feat; + +static struct vas_caps vascaps[VAS_MAX_FEAT_TYPE ]; +static long hcall_return_busy_check (long rc) {/* Check if we are stalled for some time */
@@ -145,3 +151,119 @@ int h_query_vas_capabilities(const u64 hcall, u8 query_type, u64 result) hcall, rc, query_type, result);return -EIO ; } + +/* +* Get the specific capabilities based on the feature type. +* Right now supports GZIP default and GZIP QoS capabilities. +*/ +static int get_vas_capabilities (u8 feat,enum vas_cop_feat_type type, +struct hv_vas_cop_feat_caps *hv_caps) +{ +struct vas_cop_feat_caps *caps; +struct vas_caps *vcaps; +int rc =0 ; + + vcaps = &vascaps[type]; +memset (vcaps,0 ,sizeof (*vcaps)); +INIT_LIST_HEAD (&vcaps->list); + + caps = &vcaps->caps; + + rc =h_query_vas_capabilities (H_QUERY_VAS_CAPABILITIES , feat, + (u64 )virt_to_phys (hv_caps)); +if (rc) +return rc; + + caps->user_mode = hv_caps->user_mode; +if (!(caps->user_mode &VAS_COPY_PASTE_USER_MODE )) { +pr_err ("User space COPY/PASTE is not supported\n" ); +return -ENOTSUPP ; + } + + caps->descriptor =be64_to_cpu (hv_caps->descriptor); + caps->win_type = hv_caps->win_type; +if (caps->win_type >=VAS_MAX_FEAT_TYPE ) { +pr_err ("Unsupported window type %u\n" , caps->win_type); +return -EINVAL ; + } + caps->max_lpar_creds =be16_to_cpu (hv_caps->max_lpar_creds); + caps->max_win_creds =be16_to_cpu (hv_caps->max_win_creds); +atomic_set (&caps->target_lpar_creds, +be16_to_cpu (hv_caps->target_lpar_creds)); +if (feat ==VAS_GZIP_DEF_FEAT ) { + caps->def_lpar_creds =be16_to_cpu (hv_caps->def_lpar_creds); + +if (caps->max_win_creds <DEF_WIN_CREDS ) { +pr_err ("Window creds(%u) > max allowed window creds(%u)\n" , +DEF_WIN_CREDS , caps->max_win_creds); +return -EINVAL ; + } + } + + copypaste_feat = true; + +return 0 ; +} + +static int __init pseries_vas_init (void ) +{ +struct hv_vas_cop_feat_caps *hv_cop_caps; +struct hv_vas_all_caps *hv_caps; +int rc; + +/* +* Linux supports user space COPY/PASTE only with Radix +*/ +if (!radix_enabled ()) { +pr_err ("API is supported only with radix page tables\n" ); +return -ENOTSUPP ; + } + + hv_caps =kmalloc (sizeof (*hv_caps),GFP_KERNEL ); +if (!hv_caps) +return -ENOMEM ; +/* +* Get VAS overall capabilities by passing 0 to feature type. +*/ + rc =h_query_vas_capabilities (H_QUERY_VAS_CAPABILITIES ,0 , + (u64 )virt_to_phys (hv_caps)); +if (rc) + goto out; + + caps_all.descriptor =be64_to_cpu (hv_caps->descriptor); + caps_all.feat_type =be64_to_cpu (hv_caps->feat_type); + + hv_cop_caps =kmalloc (sizeof (*hv_cop_caps),GFP_KERNEL ); +if (!hv_cop_caps) { + rc = -ENOMEM ; + goto out; + } +/* +* QOS capabilities available +*/ +if (caps_all.feat_type &VAS_GZIP_QOS_FEAT_BIT ) { + rc =get_vas_capabilities (VAS_GZIP_QOS_FEAT , +VAS_GZIP_QOS_FEAT_TYPE , hv_cop_caps); + +if (rc) + goto out_cop; + } +/* +* Default capabilities available +*/ +if (caps_all.feat_type &VAS_GZIP_DEF_FEAT_BIT ) { + rc =get_vas_capabilities (VAS_GZIP_DEF_FEAT , +VAS_GZIP_DEF_FEAT_TYPE , hv_cop_caps); +if (rc) + goto out_cop; + } + +pr_info ("GZIP feature is available\n" ); + +out_cop: +kfree (hv_cop_caps); +out: +kfree (hv_caps); +return rc; +} +machine_device_initcall (pseries, pseries_vas_init);
Signature · 1 line
2.18.2
Re: [PATCH v6 11/17] powerpc/pseries/vas: Implement getting capabilities from hypervisor
Excerpts from Haren Myneni's message of June 18, 2021 6:35 am:
Quoted 7 lines
The hypervisor provides VAS capabilities for GZIP default and QoS features. These capabilities gives information for the specific features such as total number of credits available in LPAR, maximum credits allowed per window, maximum credits allowed in LPAR, whether usermode copy/paste is supported, and etc.
Quoted 7 lines
This patch adds the following:
- Retrieve all features that are provided by hypervisor usingH_QUERY_VAS_CAPABILITIEShcall with 0 as feature type.
- Retrieve capabilities for the specific feature using the same hcall and the feature type (1 for QoS and 2 for default type).Signed-off-by Haren Myneni <[email protected]>
Quoted 153 lines
--- arch/powerpc/platforms/pseries/vas.c | 122 +++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)arch/powerpc/platforms/pseries/vas.c +122
-0@@ -10,6 +10,7 @@#include <linux/export.h> #include <linux/types.h> #include <linux/delay.h> +#include <asm/machdep.h> #include <asm/hvcall.h> #include <asm/plpar_wrappers.h> #include <asm/vas.h> @@ -20,6 +21,11 @@/* The hypervisor allows one credit per window right now */ #define DEF_WIN_CREDS 1 +static struct vas_all_caps caps_all; +static bool copypaste_feat; + +static struct vas_caps vascaps[VAS_MAX_FEAT_TYPE ]; +static long hcall_return_busy_check (long rc) {/* Check if we are stalled for some time */ @@ -145,3 +151,119 @@ int h_query_vas_capabilities(const u64 hcall, u8 query_type, u64 result) hcall, rc, query_type, result);return -EIO ; } + +/* +* Get the specific capabilities based on the feature type. +* Right now supports GZIP default and GZIP QoS capabilities. +*/ +static int get_vas_capabilities (u8 feat,enum vas_cop_feat_type type, +struct hv_vas_cop_feat_caps *hv_caps) +{ +struct vas_cop_feat_caps *caps; +struct vas_caps *vcaps; +int rc =0 ; + + vcaps = &vascaps[type]; +memset (vcaps,0 ,sizeof (*vcaps)); +INIT_LIST_HEAD (&vcaps->list); + + caps = &vcaps->caps; + + rc =h_query_vas_capabilities (H_QUERY_VAS_CAPABILITIES , feat, + (u64 )virt_to_phys (hv_caps)); +if (rc) +return rc; + + caps->user_mode = hv_caps->user_mode; +if (!(caps->user_mode &VAS_COPY_PASTE_USER_MODE )) { +pr_err ("User space COPY/PASTE is not supported\n" ); +return -ENOTSUPP ; + } + + caps->descriptor =be64_to_cpu (hv_caps->descriptor); + caps->win_type = hv_caps->win_type; +if (caps->win_type >=VAS_MAX_FEAT_TYPE ) { +pr_err ("Unsupported window type %u\n" , caps->win_type); +return -EINVAL ; + } + caps->max_lpar_creds =be16_to_cpu (hv_caps->max_lpar_creds); + caps->max_win_creds =be16_to_cpu (hv_caps->max_win_creds); +atomic_set (&caps->target_lpar_creds, +be16_to_cpu (hv_caps->target_lpar_creds)); +if (feat ==VAS_GZIP_DEF_FEAT ) { + caps->def_lpar_creds =be16_to_cpu (hv_caps->def_lpar_creds); + +if (caps->max_win_creds <DEF_WIN_CREDS ) { +pr_err ("Window creds(%u) > max allowed window creds(%u)\n" , +DEF_WIN_CREDS , caps->max_win_creds); +return -EINVAL ; + } + } + + copypaste_feat = true; + +return 0 ; +} + +static int __init pseries_vas_init (void ) +{ +struct hv_vas_cop_feat_caps *hv_cop_caps; +struct hv_vas_all_caps *hv_caps; +int rc; + +/* +* Linux supports user space COPY/PASTE only with Radix +*/ +if (!radix_enabled ()) { +pr_err ("API is supported only with radix page tables\n" ); +return -ENOTSUPP ; + } + + hv_caps =kmalloc (sizeof (*hv_caps),GFP_KERNEL ); +if (!hv_caps) +return -ENOMEM ; +/* +* Get VAS overall capabilities by passing 0 to feature type. +*/ + rc =h_query_vas_capabilities (H_QUERY_VAS_CAPABILITIES ,0 , + (u64 )virt_to_phys (hv_caps)); +if (rc) + goto out; + + caps_all.descriptor =be64_to_cpu (hv_caps->descriptor); + caps_all.feat_type =be64_to_cpu (hv_caps->feat_type); + + hv_cop_caps =kmalloc (sizeof (*hv_cop_caps),GFP_KERNEL ); +if (!hv_cop_caps) { + rc = -ENOMEM ; + goto out; + } +/* +* QOS capabilities available +*/ +if (caps_all.feat_type &VAS_GZIP_QOS_FEAT_BIT ) { + rc =get_vas_capabilities (VAS_GZIP_QOS_FEAT , +VAS_GZIP_QOS_FEAT_TYPE , hv_cop_caps); + +if (rc) + goto out_cop; + } +/* +* Default capabilities available +*/ +if (caps_all.feat_type &VAS_GZIP_DEF_FEAT_BIT ) { + rc =get_vas_capabilities (VAS_GZIP_DEF_FEAT , +VAS_GZIP_DEF_FEAT_TYPE , hv_cop_caps); +if (rc) + goto out_cop; + } + +pr_info ("GZIP feature is available\n" ); + +out_cop: +kfree (hv_cop_caps); +out: +kfree (hv_caps); +return rc; +} +machine_device_initcall (pseries, pseries_vas_init);Signature · 1 line
2.18.2
PATCH v6 12/17 powerpc/pseries/vas: Integrate API with open/close windows
In reply to Haren MyneniThis patch adds VAS window allocatioa/close with the corresponding hcalls. Also changes to integrate with the existing user space VAS API and provide register/unregister functions to NX pseries driver.
The driver register function is used to create the user space interface (/dev/crypto/nx-gzip) and unregister to remove this entry.
The user space process opens this device node and makes an ioctl to allocate VAS window. The close interface is used to deallocate window.
--- arch/powerpc/include/asm/vas.h | 4 + arch/powerpc/platforms/pseries/Makefile | 1 + arch/powerpc/platforms/pseries/vas.c | 223 ++++++++++++++++++++++++ 3 files changed, 228 insertions(+)
arch/powerpc/include/asm/vas.h +4 -0
@@ -254,6 +254,10 @@ struct vas_all_caps { u64 feat_type; }; +int h_query_vas_capabilities (const u64 hcall,u8 query_type,u64 result); +int vas_register_api_pseries (struct module *mod, +enum vas_cop_type cop_type,const char *name); +void vas_unregister_api_pseries (void );#endif /*
arch/powerpc/platforms/pseries/Makefile +1 -0
@@ -30,3 +30,4 @@ obj-$(CONFIG_PPC_SVM) += svm.o obj-$(CONFIG_FA_DUMP) += rtas-fadump.o obj-$(CONFIG_SUSPEND) += suspend.o +obj-$(CONFIG_PPC_VAS) += vas.o
arch/powerpc/platforms/pseries/vas.c +223 -0
241 lines not on this page · raw message
Signature · 1 line
2.18.2
Re: [PATCH v6 12/17] powerpc/pseries/vas: Integrate API with open/close windows
Excerpts from Haren Myneni's message of June 18, 2021 6:36 am:
Quoted 5 lines
This patch adds VAS window allocatioa/close with the corresponding hcalls. Also changes to integrate with the existing user space VAS API and provide register/unregister functions to NX pseries driver.
Quoted 8 lines
The driver register function is used to create the user space interface (
/dev/crypto/nx-gzip) and unregister to remove this entry.The user space process opens this device node and makes an ioctl to allocate VAS window. The close interface is used to deallocate window.
Signed-off-by Haren Myneni <[email protected]>
Unless there is some significant performance reason it might be simplest to take the mutex for the duration of the allocate and frees rather than taking it several times, covering the atomic with the lock instead.
You have a big lock, might as well use it and not have to wonder what if things race here or there.
But don't rework that now, maybe just something to consider for later.
Thanks,
Nick
Re: [PATCH v6 12/17] powerpc/pseries/vas: Integrate API with open/close windows
Quoted 23 lines · Nicholas Piggin
Excerpts from Haren Myneni's message of June 18, 2021 6:36 am:
Quoted 8 lines
This patch adds VAS window allocatioa/close with the corresponding hcalls. Also changes to integrate with the existing user space VAS API and provide register/unregister functions to NX pseries driver.
The driver register function is used to create the user space interface (
/dev/crypto/nx-gzip) and unregister to remove this entry.Quoted 5 lines
The user space process opens this device node and makes an ioctl to allocate VAS window. The close interface is used to deallocate window.
Signed-off-by Haren Myneni <[email protected]>Reviewed-by Nicholas Piggin <[email protected]>Unless there is some significant performance reason it might be simplest
to take the mutex for the duration of the allocate and frees rather than
taking it several times, covering the atomic with the lock instead.
Quoted 3 lines
You have a big lock, might as well use it and not have to wonder what if
things race here or there.
Using mutex to protect allocate/deallocate window and setup/free IRQ, also to protect updating the list. We do not need lock for modify window hcall and other things. Hence taking mutex several times. Also used atomic for counters (used_lpar_creds) which can be exported in sysfs (this patch will be added later in next enhancement seris).
Genarlly applications open window initially, do continuous copy/paste operations and close window later. But possible that the library / application to open/close window for each request. Also may be opening or closing multiple windows (say 1000 depends on cores on the system) at the same time. These cases may affect the application performance.
Thanks
Haren
Quoted 7 lines
But don't rework that now, maybe just something to consider for later.
Thanks,
Nick
Nicholas Piggin
reviewerRe: [PATCH v6 12/17] powerpc/pseries/vas: Integrate API with open/close windows
Excerpts from Haren Myneni's message of June 18, 2021 5:49 pm:
Quoted 24 lines · Nicholas Piggin
Quoted 23 lines
Excerpts from Haren Myneni's message of June 18, 2021 6:36 am:
Quoted 8 lines
This patch adds VAS window allocatioa/close with the corresponding hcalls. Also changes to integrate with the existing user space VAS API and provide register/unregister functions to NX pseries driver.
The driver register function is used to create the user space interface (
/dev/crypto/nx-gzip) and unregister to remove this entry.Quoted 5 lines
The user space process opens this device node and makes an ioctl to allocate VAS window. The close interface is used to deallocate window.
Signed-off-by Haren Myneni <[email protected]>Reviewed-by Nicholas Piggin <[email protected]>Unless there is some significant performance reason it might be simplest
to take the mutex for the duration of the allocate and frees rather than
taking it several times, covering the atomic with the lock instead.
Quoted 7 lines
Quoted 3 lines
You have a big lock, might as well use it and not have to wonder what if
things race here or there.Using mutex to protect allocate/deallocate window and setup/free IRQ, also to protect updating the list. We do not need lock for modify window hcall and other things. Hence taking mutex several times.
Right, at which point you have to consider what happens with interleaving allocates and deallocates. I'm not saying it's wrong, just that if you do credential allocation, hcall allocation, irq allocation, and list insertion all under the one lock, and remoe it all under the one lock, concurrency requires less attention.
Quoted 3 lines
Also
used atomic for counters (used_lpar_creds) which can be exported in sysfs (this patch will be added later in next enhancement seris).
That's okay you can use mutexes for that too if that's how you're protecting them.
Quoted 6 lines
Genarlly applications open window initially, do continuous copy/paste operations and close window later. But possible that the library / application to open/close window for each request. Also may be opening or closing multiple windows (say 1000 depends on cores on the system) at the same time. These cases may affect the application performance.
It definitely could if you have a lot of concurrent open/close, but the code as is won't handle it all that well either, so there's the question of what is reasonable to do and what is reasonable to add concurrency complexity for.
As I said, you've got it working and seem to have covered all cases now so let's get the series in first. But something to consider changing IMO.
Thanks,
Nick
PATCH v6 13/17 powerpc/pseries/vas: Setup IRQ and fault handling
In reply to Haren MyneniNX 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.
--- arch/powerpc/platforms/pseries/vas.c | 102 +++++++++++++++++++++++++++ 1 file changed, 102 insertions(+)
arch/powerpc/platforms/pseries/vas.c +102 -0
@@ -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; }
Signature · 1 line
2.18.2
Re: [PATCH v6 13/17] powerpc/pseries/vas: Setup IRQ and fault handling
Excerpts from Haren Myneni's message of June 18, 2021 6:37 am:
Quoted 8 lines
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_FAULThcall 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.
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.
Thanks,
Nick
Quoted 157 lines
Signed-off-by Haren Myneni <[email protected]>--- arch/powerpc/platforms/pseries/vas.c | 102 +++++++++++++++++++++++++++ 1 file changed, 102 insertions(+)arch/powerpc/platforms/pseries/vas.c +102
-0@@ -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; }Signature · 1 line
2.18.2
Re: [PATCH v6 13/17] powerpc/pseries/vas: Setup IRQ and fault handling
Quoted 13 lines · Nicholas Piggin
Excerpts from Haren Myneni's message of June 18, 2021 6:37 am:
Quoted 7 lines
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_FAULThcall 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.
Quoted 6 lines
Reviewed-by Nicholas Piggin <[email protected]>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
Quoted 174 lines
Thanks,
NickQuoted 170 lines
Signed-off-by Haren Myneni <[email protected]>--- arch/powerpc/platforms/pseries/vas.c | 102 +++++++++++++++++++++++++++ 1 file changed, 102 insertions(+)arch/powerpc/platforms/pseries/vas.c +24
-0@@ -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 eachH_GET_NX_FAULThcall.
+ */arch/powerpc/platforms/pseries/vas.c +8
-0+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));
arch/powerpc/platforms/pseries/vas.c +46
-0+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(structpseries_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)
arch/powerpc/platforms/pseries/vas.c +4
-0+{ +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, u64flags,
arch/powerpc/platforms/pseries/vas.c +5
-0@@ -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:arch/powerpc/platforms/pseries/vas.c +11
-0atomic_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;}
Signature · 1 line
2.18.2
Nicholas Piggin
reviewerRe: [PATCH v6 13/17] powerpc/pseries/vas: Setup IRQ and fault handling
Excerpts from Haren Myneni's message of June 18, 2021 12:09 pm:
Quoted 23 lines · Nicholas Piggin
Quoted 13 lines
Excerpts from Haren Myneni's message of June 18, 2021 6:37 am:
Quoted 7 lines
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_FAULThcall 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.Quoted 6 lines
Reviewed-by Nicholas Piggin <[email protected]>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.
Quoted 7 lines
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.
Yeah, I thought as much. Just wondering.
Thanks,
Nick
PATCH v6 14/17 crypto/nx: Rename nx-842-pseries file name to nx-common-pseries
In reply to Haren MyneniRename nx-842-pseries.c to nx-common-pseries.c to add code for new GZIP compression type. The actual functionality is not changed in this patch.
---
drivers/crypto/nx/Makefile | 2 +-
drivers/crypto/nx/{nx-842-pseries.c => nx-common-pseries.c} | 0
2 files changed, 1 insertion(+), 1 deletion(-)
rename drivers/crypto/nx/{nx-842-pseries.c => nx-common-pseries.c} (100%)drivers/crypto/nx/Makefile +1 -1
@@ -14,5 +14,5 @@ nx-crypto-objs := nx.o \ obj-$(CONFIG_CRYPTO_DEV_NX_COMPRESS_PSERIES) += nx-compress-pseries.o nx-compress.o obj-$(CONFIG_CRYPTO_DEV_NX_COMPRESS_POWERNV) += nx-compress-powernv.o nx-compress.o nx-compress-objs := nx-842.o -nx-compress-pseries-objs := nx-842-pseries.o +nx-compress-pseries-objs := nx-common-pseries.o nx-compress-powernv-objs := nx-common-powernv.o
drivers/crypto/nx/nx-common-pseries.c renamed from drivers/crypto/nx/nx-842-pseries.c +0 -0
Signature · 1 line
2.18.2
PATCH v6 15/17 crypto/nx: Get NX capabilities for GZIP coprocessor type
In reply to Haren MyneniThe hypervisor provides different NX capabilities that it supports. These capabilities such as recommended minimum compression / decompression lengths and the maximum request buffer size in bytes are used to define the user space NX request.
NX will reject the request if the buffer size is more than the maximum buffer size. Whereas compression / decompression lengths are recommended values for better performance.
Changes to get NX overall capabilities which points to the specific features that the hypervisor supports. Then retrieve the capabilities for the specific feature (available only for NXGZIP).
--- drivers/crypto/nx/nx-common-pseries.c | 87 +++++++++++++++++++++++++++ 1 file changed, 87 insertions(+)
drivers/crypto/nx/nx-common-pseries.c +87 -0
@@ -9,6 +9,8 @@*/ #include <asm/vio.h> +#include <asm/hvcall.h> +#include <asm/vas.h> #include "nx-842.h" #include "nx_csbcpb.h" /* struct nx_csbcpb */
@@ -19,6 +21,29 @@ MODULE_DESCRIPTION("842 H/W Compression driver for IBM Power processors");MODULE_ALIAS_CRYPTO ("842" );MODULE_ALIAS_CRYPTO ("842-nx" ); +/* +* Coprocessor type specific capabilities from the hypervisor. +*/ +struct hv_nx_cop_caps { +__be64 descriptor; +__be64 req_max_processed_len;/* Max bytes in one GZIP request */ +__be64 min_compress_len;/* Min compression size in bytes */ +__be64 min_decompress_len;/* Min decompression size in bytes */ +} __packed__aligned(0x1000) ; + +/* +* Coprocessor type specific capabilities. +*/ +struct nx_cop_caps { +u64 descriptor; +u64 req_max_processed_len;/* Max bytes in one GZIP request */ +u64 min_compress_len;/* Min compression in bytes */ +u64 min_decompress_len;/* Min decompression in bytes */ +}; + +static u64 caps_feat; +static struct nx_cop_caps nx_cop_caps; +static struct nx842_constraints nx842_pseries_constraints = { .alignment =DDE_BUFFER_ALIGN , .multiple =DDE_BUFFER_LAST_MULT ,
@@ -1065,6 +1090,64 @@ static void nx842_remove(struct vio_dev *viodev)kfree (old_devdata); } +/* +* Get NX capabilities from the hypervisor. +* Only NXGZIP capabilities are provided by the hypersvisor right +* now and these values are available to user space with sysfs. +*/ +static void __init nxcop_get_capabilities (void ) +{ +struct hv_vas_all_caps *hv_caps; +struct hv_nx_cop_caps *hv_nxc; +int rc; + + hv_caps =kmalloc (sizeof (*hv_caps),GFP_KERNEL ); +if (!hv_caps) +return ; +/* +* Get NX overall capabilities with feature type=0 +*/ + rc =h_query_vas_capabilities (H_QUERY_NX_CAPABILITIES ,0 , + (u64 )virt_to_phys (hv_caps)); +if (rc) + goto out; + + caps_feat =be64_to_cpu (hv_caps->feat_type); +/* +* NX-GZIP feature available +*/ +if (caps_feat &VAS_NX_GZIP_FEAT_BIT ) { + hv_nxc =kmalloc (sizeof (*hv_nxc),GFP_KERNEL ); +if (!hv_nxc) + goto out; +/* +* Get capabilities for NX-GZIP feature +*/ + rc =h_query_vas_capabilities (H_QUERY_NX_CAPABILITIES , +VAS_NX_GZIP_FEAT , + (u64 )virt_to_phys (hv_nxc)); + }else { +pr_err ("NX-GZIP feature is not available\n" ); + rc = -EINVAL ; + } + +if (!rc) { + nx_cop_caps.descriptor =be64_to_cpu (hv_nxc->descriptor); + nx_cop_caps.req_max_processed_len = +be64_to_cpu (hv_nxc->req_max_processed_len); + nx_cop_caps.min_compress_len = +be64_to_cpu (hv_nxc->min_compress_len); + nx_cop_caps.min_decompress_len = +be64_to_cpu (hv_nxc->min_decompress_len); + }else { + caps_feat =0 ; + } + +kfree (hv_nxc); +out: +kfree (hv_caps); +} +static const struct vio_device_id nx842_vio_driver_ids[] = { {"ibm,compression-v1" ,"ibm,compression" }, {"" ,"" },
@@ -1092,6 +1175,10 @@ static int __init nx842_pseries_init(void)return -ENOMEM ;RCU_INIT_POINTER (devdata, new_devdata); +/* +* Get NX capabilities from the hypervisor. +*/ +nxcop_get_capabilities (); ret =vio_register_driver (&nx842_vio_driver);if (ret) {
Signature · 1 line
2.18.2
Re: [PATCH v6 15/17] crypto/nx: Get NX capabilities for GZIP coprocessor type
Excerpts from Haren Myneni's message of June 18, 2021 6:38 am:
Quoted 11 lines
The hypervisor provides different NX capabilities that it supports. These capabilities such as recommended minimum compression / decompression lengths and the maximum request buffer size in bytes are used to define the user space NX request.
NX will reject the request if the buffer size is more than the maximum buffer size. Whereas compression / decompression lengths are recommended values for better performance.
Quoted 7 lines
Changes to get NX overall capabilities which points to the specific features that the hypervisor supports. Then retrieve the capabilities for the specific feature (available only for NXGZIP).
Signed-off-by Haren Myneni <[email protected]>Acked-by Herbert Xu <[email protected]>
Quoted 128 lines
--- drivers/crypto/nx/nx-common-pseries.c | 87 +++++++++++++++++++++++++++ 1 file changed, 87 insertions(+)drivers/crypto/nx/nx-common-pseries.c +87
-0@@ -9,6 +9,8 @@*/ #include <asm/vio.h> +#include <asm/hvcall.h> +#include <asm/vas.h> #include "nx-842.h" #include "nx_csbcpb.h" /* struct nx_csbcpb */ @@ -19,6 +21,29 @@ MODULE_DESCRIPTION("842 H/W Compression driver for IBM Power processors");MODULE_ALIAS_CRYPTO ("842" );MODULE_ALIAS_CRYPTO ("842-nx" ); +/* +* Coprocessor type specific capabilities from the hypervisor. +*/ +struct hv_nx_cop_caps { +__be64 descriptor; +__be64 req_max_processed_len;/* Max bytes in one GZIP request */ +__be64 min_compress_len;/* Min compression size in bytes */ +__be64 min_decompress_len;/* Min decompression size in bytes */ +} __packed__aligned(0x1000) ; + +/* +* Coprocessor type specific capabilities. +*/ +struct nx_cop_caps { +u64 descriptor; +u64 req_max_processed_len;/* Max bytes in one GZIP request */ +u64 min_compress_len;/* Min compression in bytes */ +u64 min_decompress_len;/* Min decompression in bytes */ +}; + +static u64 caps_feat; +static struct nx_cop_caps nx_cop_caps; +static struct nx842_constraints nx842_pseries_constraints = { .alignment =DDE_BUFFER_ALIGN , .multiple =DDE_BUFFER_LAST_MULT ,@@ -1065,6 +1090,64 @@ static void nx842_remove(struct vio_dev *viodev)kfree (old_devdata); } +/* +* Get NX capabilities from the hypervisor. +* Only NXGZIP capabilities are provided by the hypersvisor right +* now and these values are available to user space with sysfs. +*/ +static void __init nxcop_get_capabilities (void ) +{ +struct hv_vas_all_caps *hv_caps; +struct hv_nx_cop_caps *hv_nxc; +int rc; + + hv_caps =kmalloc (sizeof (*hv_caps),GFP_KERNEL ); +if (!hv_caps) +return ; +/* +* Get NX overall capabilities with feature type=0 +*/ + rc =h_query_vas_capabilities (H_QUERY_NX_CAPABILITIES ,0 , + (u64 )virt_to_phys (hv_caps)); +if (rc) + goto out; + + caps_feat =be64_to_cpu (hv_caps->feat_type); +/* +* NX-GZIP feature available +*/ +if (caps_feat &VAS_NX_GZIP_FEAT_BIT ) { + hv_nxc =kmalloc (sizeof (*hv_nxc),GFP_KERNEL ); +if (!hv_nxc) + goto out; +/* +* Get capabilities for NX-GZIP feature +*/ + rc =h_query_vas_capabilities (H_QUERY_NX_CAPABILITIES , +VAS_NX_GZIP_FEAT , + (u64 )virt_to_phys (hv_nxc)); + }else { +pr_err ("NX-GZIP feature is not available\n" ); + rc = -EINVAL ; + } + +if (!rc) { + nx_cop_caps.descriptor =be64_to_cpu (hv_nxc->descriptor); + nx_cop_caps.req_max_processed_len = +be64_to_cpu (hv_nxc->req_max_processed_len); + nx_cop_caps.min_compress_len = +be64_to_cpu (hv_nxc->min_compress_len); + nx_cop_caps.min_decompress_len = +be64_to_cpu (hv_nxc->min_decompress_len); + }else { + caps_feat =0 ; + } + +kfree (hv_nxc); +out: +kfree (hv_caps); +} +static const struct vio_device_id nx842_vio_driver_ids[] = { {"ibm,compression-v1" ,"ibm,compression" }, {"" ,"" },@@ -1092,6 +1175,10 @@ static int __init nx842_pseries_init(void)return -ENOMEM ;RCU_INIT_POINTER (devdata, new_devdata); +/* +* Get NX capabilities from the hypervisor. +*/ +nxcop_get_capabilities (); ret =vio_register_driver (&nx842_vio_driver);if (ret) {Signature · 1 line
2.18.2
PATCH v6 16/17 crypto/nx: Add sysfs interface to export NX capabilities
In reply to Haren MyneniExport NX-GZIP capabilities to usrespace in sysfs /sys/devices/vio/ibm,compression-v1/nx_gzip_caps directory. These are queried by userspace accelerator libraries to set minimum length heuristics and maximum limits on request sizes.
NX-GZIP capabilities:min_compress_len /*Recommended minimum compress length in bytes*/ min_decompress_len /*Recommended minimum decompress length in bytes*/ req_max_processed_len /* Maximum number of bytes processed in one
request */
NX will return RMA_Reject if the request buffer size is greater than req_max_processed_len.
--- drivers/crypto/nx/nx-common-pseries.c | 43 +++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
drivers/crypto/nx/nx-common-pseries.c +43 -0
@@ -967,6 +967,36 @@ static struct attribute_group nx842_attribute_group = { .attrs = nx842_sysfs_entries, }; +#define nxcop_caps_read (_name) \ +static ssize_t nxcop_##_name##_show(struct device *dev, \ + struct device_attribute *attr, char *buf) \ +{ \ + return sprintf(buf, "%lld\n", nx_cop_caps._name); \ +} + +#define NXCT_ATTR_RO (_name) \ + nxcop_caps_read(_name); \ + static struct device_attribute dev_attr_##_name = __ATTR(_name, \ + 0444, \ + nxcop_##_name##_show, \ + NULL); + +NXCT_ATTR_RO (req_max_processed_len); +NXCT_ATTR_RO (min_compress_len); +NXCT_ATTR_RO (min_decompress_len); + +static struct attribute *nxcop_caps_sysfs_entries[] = { + &dev_attr_req_max_processed_len.attr, + &dev_attr_min_compress_len.attr, + &dev_attr_min_decompress_len.attr, +NULL , +}; + +static struct attribute_group nxcop_caps_attr_group = { + .name ="nx_gzip_caps" , + .attrs = nxcop_caps_sysfs_entries, +}; +static struct nx842_driver nx842_pseries_driver = { .name =KBUILD_MODNAME , .owner =THIS_MODULE ,
@@ -1056,6 +1086,16 @@ static int nx842_probe(struct vio_dev *viodev, goto error; } +if (caps_feat) { +if (sysfs_create_group (&viodev->dev.kobj, + &nxcop_caps_attr_group)) { +dev_err (&viodev->dev, +"Could not create sysfs NX capability entries\n" ); + ret =-1 ; + goto error; + } + } +return 0 ; error_unlock:
@@ -1075,6 +1115,9 @@ static void nx842_remove(struct vio_dev *viodev)pr_info ("Removing IBM Power 842 compression device\n" );sysfs_remove_group (&viodev->dev.kobj, &nx842_attribute_group); +if (caps_feat) +sysfs_remove_group (&viodev->dev.kobj, &nxcop_caps_attr_group); +crypto_unregister_alg (&nx842_pseries_alg);spin_lock_irqsave (&devdata_mutex, flags);
Signature · 1 line
2.18.2
Re: [PATCH v6 16/17] crypto/nx: Add sysfs interface to export NX capabilities
Excerpts from Haren Myneni's message of June 18, 2021 6:39 am:
Quoted 12 lines
Export NX-GZIP capabilities to usrespace in sysfs
/sys/devices/vio/ibm,compression-v1/nx_gzip_capsdirectory. These are queried by userspace accelerator libraries to set minimum length heuristics and maximum limits on request sizes.NX-GZIP capabilities:
min_compress_len/*Recommended minimum compress length in bytes*/min_decompress_len/*Recommended minimum decompress length in bytes*/req_max_processed_len/* Maximum number of bytes processed in one
request */
Quoted 5 lines
NX will return
RMA_Rejectif the request buffer size is greater thanreq_max_processed_len.Signed-off-by Haren Myneni <[email protected]>Acked-by Herbert Xu <[email protected]>
Again, if you could just move those ^^ C style comments into the code. Possibly have a small comment with the sysfs stuff saying that it's ABI which userspace code queries when using the accelerator (or if you have an ABI documentation somewhere, point the comments to that).
sysfs is ABI, but some bits are more ABI than others, it would just be good to be clear that it is actually used, and can't be changed.
Aside from that,
Thanks,
Nick
Quoted 77 lines
--- drivers/crypto/nx/nx-common-pseries.c | 43 +++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)drivers/crypto/nx/nx-common-pseries.c +43
-0@@ -967,6 +967,36 @@ static struct attribute_group nx842_attribute_group = { .attrs = nx842_sysfs_entries, }; +#define nxcop_caps_read (_name) \ +static ssize_t nxcop_##_name##_show(struct device *dev, \ + struct device_attribute *attr, char *buf) \ +{ \ + return sprintf(buf, "%lld\n", nx_cop_caps._name); \ +} + +#define NXCT_ATTR_RO (_name) \ + nxcop_caps_read(_name); \ + static struct device_attribute dev_attr_##_name = __ATTR(_name, \ + 0444, \ + nxcop_##_name##_show, \ + NULL); + +NXCT_ATTR_RO (req_max_processed_len); +NXCT_ATTR_RO (min_compress_len); +NXCT_ATTR_RO (min_decompress_len); + +static struct attribute *nxcop_caps_sysfs_entries[] = { + &dev_attr_req_max_processed_len.attr, + &dev_attr_min_compress_len.attr, + &dev_attr_min_decompress_len.attr, +NULL , +}; + +static struct attribute_group nxcop_caps_attr_group = { + .name ="nx_gzip_caps" , + .attrs = nxcop_caps_sysfs_entries, +}; +static struct nx842_driver nx842_pseries_driver = { .name =KBUILD_MODNAME , .owner =THIS_MODULE ,@@ -1056,6 +1086,16 @@ static int nx842_probe(struct vio_dev *viodev, goto error; } +if (caps_feat) { +if (sysfs_create_group (&viodev->dev.kobj, + &nxcop_caps_attr_group)) { +dev_err (&viodev->dev, +"Could not create sysfs NX capability entries\n" ); + ret =-1 ; + goto error; + } + } +return 0 ; error_unlock:@@ -1075,6 +1115,9 @@ static void nx842_remove(struct vio_dev *viodev)pr_info ("Removing IBM Power 842 compression device\n" );sysfs_remove_group (&viodev->dev.kobj, &nx842_attribute_group); +if (caps_feat) +sysfs_remove_group (&viodev->dev.kobj, &nxcop_caps_attr_group); +crypto_unregister_alg (&nx842_pseries_alg);spin_lock_irqsave (&devdata_mutex, flags);Signature · 1 line
2.18.2
PATCH v6 17/17 crypto/nx: Register and unregister VAS interface on PowerVM
In reply to Haren MyneniThe user space uses /dev/crypto/nx-gzip interface to setup VAS windows, create paste mapping and close windows. This patch adds changes to create/remove this interface with VAS register/unregister functions on PowerVM platform.
--- drivers/crypto/nx/Kconfig | 1 + drivers/crypto/nx/nx-common-pseries.c | 8 ++++++++ 2 files changed, 9 insertions(+)
drivers/crypto/nx/Kconfig +1 -0
@@ -29,6 +29,7 @@ if CRYPTO_DEV_NX_COMPRESS config CRYPTO_DEV_NX_COMPRESS_PSERIES tristate "Compression acceleration support on pSeries platform" depends on PPC_PSERIES && IBMVIO + depends on PPC_VAS default y help Support for PowerPC Nest (NX) compression acceleration. This
drivers/crypto/nx/nx-common-pseries.c +8 -0
@@ -1231,6 +1231,12 @@ static int __init nx842_pseries_init(void)return ret; } + ret =vas_register_api_pseries (THIS_MODULE ,VAS_COP_TYPE_GZIP , +"nx-gzip" ); + +if (ret) +pr_err ("NX-GZIP is not supported. Returned=%d\n" , ret); +return 0 ; }
@@ -1241,6 +1247,8 @@ static void __exit nx842_pseries_exit(void)struct nx842_devdata *old_devdata;unsigned long flags; +vas_unregister_api_pseries (); +crypto_unregister_alg (&nx842_pseries_alg);spin_lock_irqsave (&devdata_mutex, flags);
Signature · 1 line
2.18.2
Michael Ellerman
AppliedQuoted 11 lines · Haren Myneni
Virtual Accelerator Switchboard (VAS) allows kernel subsystems and user space processes to directly access the Nest Accelerator (NX) engines which provides HW compression. The true user mode VAS/NX support on PowerNV is already included in Linux. Whereas PowerVM support is available from P10 onwards.
This patch series enables VAS / NX-GZIP on PowerVM which allows the user space to do copy/paste with the same existing interface that is available on PowerNV.
[...]
Applied to powerpc/next.
[01/17] powerpc/powernv/vas: Release reference to tgid during window close
https://git.kernel.org/powerpc/c/91cdbb955aa94ee0841af4685be40937345d29b8 [02/17] powerpc/vas: Move VAS API to book3s common platform https://git.kernel.org/powerpc/c/413d6ed3eac387a2876893c337174f0c5b99d01d [03/17] powerpc/powernv/vas: Rename register/unregister functions https://git.kernel.org/powerpc/c/06c6fad9bfe0b6439e18ea1f1cf0d178405ccf25 [04/17] powerpc/vas: Add platform specific user window operations https://git.kernel.org/powerpc/c/1a0d0d5ed5e3cd9e3fc1ad4459f1db2f3618fce0 [05/17] powerpc/vas: Create take/drop pid and mm reference functions https://git.kernel.org/powerpc/c/3856aa542d90ed79cd5ed4cfd828b1fb04017131 [06/17] powerpc/vas: Move update_csb/dump_crb to common book3s platform https://git.kernel.org/powerpc/c/3b26797350352479f37216d674c8e5d126faab66 [07/17] powerpc/vas: Define and use common vas_window struct https://git.kernel.org/powerpc/c/7bc6f71bdff5f8921e324da0a8fad6f4e2e63a85 [08/17] powerpc/pseries/vas: Define VAS/NXGZIP hcalls and structs https://git.kernel.org/powerpc/c/8f3a6c92802b7c48043954ba3b507e9b33d8c898 [09/17] powerpc/vas: Define QoS credit flag to allocate window https://git.kernel.org/powerpc/c/540761b7f51067d76b301c64abc50328ded89b1c [10/17] powerpc/pseries/vas: Add hcall wrappers for VAS handling https://git.kernel.org/powerpc/c/f33ecfde30ce6909fff41339285e0274bb403fb8 [11/17] powerpc/pseries/vas: Implement getting capabilities from hypervisor https://git.kernel.org/powerpc/c/ca77d48854177bb9749aef7329201f03b2382fbb [12/17] powerpc/pseries/vas: Integrate API with open/close windows https://git.kernel.org/powerpc/c/b22f2d88e435cdada32581ca1f11b9806adf459a [13/17] powerpc/pseries/vas: Setup IRQ and fault handling https://git.kernel.org/powerpc/c/6d0aaf5e0de00491de136f387ebed55604cedebe [14/17] crypto/nx: Rename nx-842-pseries file name to nx-common-pseries https://git.kernel.org/powerpc/c/7da00b0e71334aa1e3d8db1cc1f40eb47cb1e188 [15/17] crypto/nx: Get NX capabilities for GZIP coprocessor type https://git.kernel.org/powerpc/c/b4ba22114c78de48fda3818f569f75e97d58c719 [16/17] crypto/nx: Add sysfs interface to export NX capabilities https://git.kernel.org/powerpc/c/8c099490fd2bd3b012b3b6d0babbba3b90e69b55 [17/17] crypto/nx: Register and unregister VAS interface on PowerVM https://git.kernel.org/powerpc/c/99cd49bb39516d1beb1c38ae629b15ccb923198c
cheers