* [V3 PATCH 03/16] powerpc/vas: Create take/drop task reference functions
From: Haren Myneni @ 2021-04-17 21:03 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
Take task reference 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
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/include/asm/vas.h | 20 ++++++++
arch/powerpc/platforms/book3s/vas-api.c | 51 ++++++++++++++++++
arch/powerpc/platforms/powernv/vas-fault.c | 10 ++--
arch/powerpc/platforms/powernv/vas-window.c | 57 ++-------------------
arch/powerpc/platforms/powernv/vas.h | 6 +--
5 files changed, 83 insertions(+), 61 deletions(-)
diff --git a/arch/powerpc/include/asm/vas.h b/arch/powerpc/include/asm/vas.h
index 6bbade60d8f4..2daaa1a2a9a9 100644
--- a/arch/powerpc/include/asm/vas.h
+++ b/arch/powerpc/include/asm/vas.h
@@ -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>
@@ -60,6 +63,22 @@ struct vas_user_win_ops {
int (*close_win)(void *);
};
+struct vas_win_task {
+ struct pid *pid; /* Thread group ID of owner */
+ struct pid *tgid; /* Linux process mm_struct */
+ struct mm_struct *mm; /* Linux process mm_struct */
+};
+
+static inline void vas_drop_reference_task(struct vas_win_task *task)
+{
+ /* Drop references to pid and mm */
+ put_pid(task->pid);
+ if (task->mm) {
+ mm_context_remove_vas_window(task->mm);
+ mmdrop(task->mm);
+ }
+}
+
/*
* Receive window attributes specified by the (in-kernel) owner of window.
*/
@@ -190,4 +209,5 @@ int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type,
struct vas_user_win_ops *vops);
void vas_unregister_coproc_api(void);
+int vas_reference_task(struct vas_win_task *vtask);
#endif /* __ASM_POWERPC_VAS_H */
diff --git a/arch/powerpc/platforms/book3s/vas-api.c b/arch/powerpc/platforms/book3s/vas-api.c
index 05d7b99acf41..d98caa734154 100644
--- a/arch/powerpc/platforms/book3s/vas-api.c
+++ b/arch/powerpc/platforms/book3s/vas-api.c
@@ -60,6 +60,57 @@ 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 vas_reference_task(struct vas_win_task *vtask)
+{
+ /*
+ * 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.
+ */
+ vtask->pid = get_task_pid(current, PIDTYPE_PID);
+ /*
+ * Acquire a reference to the task's mm.
+ */
+ vtask->mm = get_task_mm(current);
+ if (!vtask->mm) {
+ put_pid(vtask->pid);
+ pr_err("VAS: pid(%d): mm_struct is not found\n",
+ current->pid);
+ return -EPERM;
+ }
+
+ mmgrab(vtask->mm);
+ mmput(vtask->mm);
+ mm_context_add_vas_window(vtask->mm);
+ /*
+ * 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.
+ */
+ vtask->tgid = find_get_pid(task_tgid_vnr(current));
+ /*
+ * 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);
+
+ return 0;
+}
+
static int coproc_open(struct inode *inode, struct file *fp)
{
struct coproc_instance *cp_inst;
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index 3d21fce254b7..a4835cb82c09 100644
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -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.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.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.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.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.mm);
put_task_struct(tsk);
/* Success */
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index b973dd574b47..58e3d16c316f 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -1066,51 +1066,9 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
rc = -ENODEV;
goto free_window;
}
-
- /*
- * 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.
- */
- txwin->pid = get_task_pid(current, PIDTYPE_PID);
- /*
- * Acquire a reference to the task's mm.
- */
- txwin->mm = get_task_mm(current);
-
- if (!txwin->mm) {
- put_pid(txwin->pid);
- pr_err("VAS: pid(%d): mm_struct is not found\n",
- current->pid);
- rc = -EPERM;
+ rc = vas_reference_task(&txwin->task);
+ if (rc)
goto free_window;
- }
-
- mmgrab(txwin->mm);
- mmput(txwin->mm);
- mm_context_add_vas_window(txwin->mm);
- /*
- * 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.
- */
- txwin->tgid = find_get_pid(task_tgid_vnr(current));
- /*
- * 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);
}
set_vinst_win(vinst, txwin);
@@ -1340,14 +1298,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 */
- put_pid(window->pid);
- if (window->mm) {
- mm_context_remove_vas_window(window->mm);
- mmdrop(window->mm);
- }
- }
+ if (window->user_win)
+ vas_drop_reference_task(&window->task);
+
put_rx_win(window->rxwin);
}
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index c7db3190baca..f7aa2d04cd16 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -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_win_task task;
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.pid);
}
static inline void vas_log_write(struct vas_window *win, char *name,
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 05/16] powerpc/vas: Define and use common vas_window struct
From: Haren Myneni @ 2021-04-17 21:04 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
^ permalink raw reply
* [V3 PATCH 06/16] powerpc/pseries/vas: Define VAS/NXGZIP HCALLs and structs
From: Haren Myneni @ 2021-04-17 21:05 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
This patch adds HCALLs and other definitions. Also define structs
that are used in VAS implementation on powerVM.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/include/asm/hvcall.h | 7 ++
arch/powerpc/include/asm/vas.h | 28 ++++++++
arch/powerpc/platforms/pseries/vas.h | 96 ++++++++++++++++++++++++++++
3 files changed, 131 insertions(+)
create mode 100644 arch/powerpc/platforms/pseries/vas.h
diff --git a/arch/powerpc/include/asm/hvcall.h b/arch/powerpc/include/asm/hvcall.h
index ed6086d57b22..accbb7f6f272 100644
--- a/arch/powerpc/include/asm/hvcall.h
+++ b/arch/powerpc/include/asm/hvcall.h
@@ -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
diff --git a/arch/powerpc/include/asm/vas.h b/arch/powerpc/include/asm/vas.h
index f928bf4c7e98..d15784506a54 100644
--- a/arch/powerpc/include/asm/vas.h
+++ b/arch/powerpc/include/asm/vas.h
@@ -179,6 +179,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
@@ -243,6 +244,33 @@ 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 (1UL << (63 - VAS_GZIP_QOS_FEAT)) /* Bit 1 */
+#define VAS_GZIP_DEF_FEAT_BIT (1UL << (63 - VAS_GZIP_DEF_FEAT)) /* Bit 2 */
+
+/* NX Capabilities */
+#define VAS_NX_GZIP_FEAT 0x1
+#define VAS_NX_GZIP_FEAT_BIT (1UL << (63 - VAS_NX_GZIP_FEAT)) /* Bit 1 */
+#define VAS_DESCR_LEN 8
+
+struct vas_all_capabs_be {
+ __be64 descriptor;
+ __be64 feat_type;
+} __packed __aligned(0x1000);
+
+struct vas_all_capabs {
+ char name[VAS_DESCR_LEN + 1];
+ u64 descriptor;
+ u64 feat_type;
+};
+
+#endif
/*
* Register / unregister coprocessor type to VAS API which will be exported
diff --git a/arch/powerpc/platforms/pseries/vas.h b/arch/powerpc/platforms/pseries/vas.h
new file mode 100644
index 000000000000..208682fffa57
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/vas.h
@@ -0,0 +1,96 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright 2020-21 IBM Corp.
+ */
+
+#ifndef _VAS_H
+#define _VAS_H
+#include <asm/vas.h>
+#include <linux/mutex.h>
+#include <linux/stringify.h>
+
+/*
+ * VAS window modify flags
+ */
+#define VAS_MOD_WIN_CLOSE (1UL << 63)
+#define VAS_MOD_WIN_JOBS_KILL (1UL << (63 - 1))
+#define VAS_MOD_WIN_DR (1UL << (63 - 3))
+#define VAS_MOD_WIN_PR (1UL << (63 - 4))
+#define VAS_MOD_WIN_SF (1UL << (63 - 5))
+#define VAS_MOD_WIN_TA (1UL << (63 - 6))
+#define VAS_MOD_WIN_FLAGS (VAS_MOD_WIN_JOBS_KILL | VAS_MOD_WIN_DR | \
+ VAS_MOD_WIN_PR | VAS_MOD_WIN_SF)
+
+#define VAS_WIN_ACTIVE 0x0
+#define VAS_WIN_CLOSED 0x1
+#define VAS_WIN_INACTIVE 0x2 /* Inactive due to HW failure */
+/* Process of being modified, deallocated, or quiesced */
+#define VAS_WIN_MOD_IN_PROCESS 0x3
+
+#define VAS_COPY_PASTE_USER_MODE 0x00000001
+#define VAS_COP_OP_USER_MODE 0x00000010
+
+/*
+ * Co-processor feature - GZIP QoS windows or GZIP default windows
+ */
+enum vas_cop_feat_type {
+ VAS_GZIP_QOS_FEAT_TYPE,
+ VAS_GZIP_DEF_FEAT_TYPE,
+ VAS_MAX_FEAT_TYPE,
+};
+
+struct vas_ct_capabs_be {
+ __be64 descriptor;
+ u8 win_type; /* Default or QoS type */
+ u8 user_mode;
+ __be16 max_lpar_creds;
+ __be16 max_win_creds;
+ union {
+ __be16 reserved;
+ __be16 def_lpar_creds; /* Used for default capabilities */
+ };
+ __be16 target_lpar_creds;
+} __packed __aligned(0x1000);
+
+struct vas_ct_capabs {
+ char name[VAS_DESCR_LEN + 1];
+ u64 descriptor;
+ u8 win_type; /* Default or QoS type */
+ u8 user_mode; /* User mode copy/paste or COP HCALL */
+ u16 max_lpar_creds; /* Max credits available in LPAR */
+ /* Max credits can be assigned per window */
+ u16 max_win_creds;
+ union {
+ u16 reserved; /* Used for QoS credit type */
+ u16 def_lpar_creds; /* Used for default credit type */
+ };
+ /* Total LPAR available credits. Can be different from max LPAR */
+ /* credits due to DLPAR operation */
+ atomic_t target_lpar_creds;
+ atomic_t used_lpar_creds; /* Used credits so far */
+ u16 avail_lpar_creds; /* Remaining available credits */
+};
+
+struct vas_capabs {
+ struct vas_ct_capabs capab;
+ struct list_head list;
+};
+
+struct vas_win_lpar_be {
+ __be16 version;
+ u8 win_type;
+ u8 status;
+ __be16 credits; /* No of credits assigned to this window */
+ __be16 reserved;
+ __be32 pid; /* LPAR Process ID */
+ __be32 tid; /* LPAR Thread ID */
+ __be64 win_addr;
+ __be32 interrupt; /* Interrupt when NX request completes */
+ __be32 fault; /* Interrupt when NX sees fault */
+ /* Associativity Domain Identifiers as returned in */
+ /* H_HOME_NODE_ASSOCIATIVITY */
+ __be64 domain[6];
+ __be64 win_util; /* Number of bytes processed */
+} __packed __aligned(0x1000);
+
+#endif /* _VAS_H */
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 07/16] powerpc/vas: Define QoS credit flag to allocate window
From: Haren Myneni @ 2021-04-17 21:06 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
pHyp 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, phyp
introduces QoS credit type which makes sure guaranteed access to NX
resources. The system admins can assign QoS credits for 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_WIN_QOS_CREDITS
flag with VAS_TX_WIN_OPEN ioctl to open QoS type window.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/include/uapi/asm/vas-api.h | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/include/uapi/asm/vas-api.h b/arch/powerpc/include/uapi/asm/vas-api.h
index ebd4b2424785..eb7c8694174f 100644
--- a/arch/powerpc/include/uapi/asm/vas-api.h
+++ b/arch/powerpc/include/uapi/asm/vas-api.h
@@ -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 default credit is used */
+#define VAS_WIN_QOS_CREDITS 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];
};
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 08/16] powerpc/pseries/VAS: Implement allocate/modify/deallocate HCALLS
From: Haren Myneni @ 2021-04-17 21:07 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
This patch adds the following HCALLs which are used to allocate,
modify and deallocate VAS windows.
H_ALLOCATE_VAS_WINDOW: Allocate VAS window
H_DEALLOCATE_VAS_WINDOW: Close VAS window
H_MODIFY_VAS_WINDOW: Setup window before using
Also adds phyp call (H_QUERY_VAS_CAPABILITIES) to get all VAS
capabilities that phyp provides.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/pseries/vas.c | 217 +++++++++++++++++++++++++++
1 file changed, 217 insertions(+)
create mode 100644 arch/powerpc/platforms/pseries/vas.c
diff --git a/arch/powerpc/platforms/pseries/vas.c b/arch/powerpc/platforms/pseries/vas.c
new file mode 100644
index 000000000000..06960151477c
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/vas.c
@@ -0,0 +1,217 @@
+// 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 <linux/slab.h>
+#include <linux/irqdomain.h>
+#include <linux/interrupt.h>
+#include <linux/sched/mm.h>
+#include <linux/mmu_context.h>
+#include <asm/hvcall.h>
+#include <asm/hvconsole.h>
+#include <asm/machdep.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
+/* Authority Mask Register (AMR) value is not supported in */
+/* linux implementation. So pass '0' to modify window HCALL */
+#define VAS_AMR_VALUE 0
+/* phyp allows one credit per window right now */
+#define DEF_WIN_CREDS 1
+
+static int64_t hcall_return_busy_check(int64_t 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 plpar_vas_allocate_window(struct vas_window *win, u64 *domain,
+ u8 wintype, u16 credits)
+{
+ long retbuf[PLPAR_HCALL9_BUFSIZE] = {0};
+ int64_t 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);
+
+ switch (rc) {
+ case H_SUCCESS:
+ win->winid = retbuf[0];
+ win->lpar.win_addr = retbuf[1];
+ win->lpar.complete_irq = retbuf[2];
+ win->lpar.fault_irq = retbuf[3];
+ if (win->lpar.win_addr == VAS_INVALID_WIN_ADDRESS) {
+ pr_err("HCALL(%x): COPY/PASTE is not supported\n",
+ H_ALLOCATE_VAS_WINDOW);
+ return -ENOTSUPP;
+ }
+ return 0;
+ case H_PARAMETER:
+ pr_err("HCALL(%x): Invalid window type (%u)\n",
+ H_ALLOCATE_VAS_WINDOW, wintype);
+ return -EINVAL;
+ case H_P2:
+ pr_err("HCALL(%x): Credits(%u) exceed maximum window credits\n",
+ H_ALLOCATE_VAS_WINDOW, credits);
+ return -EINVAL;
+ case H_COP_HW:
+ pr_err("HCALL(%x): User-mode COPY/PASTE is not supported\n",
+ H_ALLOCATE_VAS_WINDOW);
+ return -ENOTSUPP;
+ case H_RESOURCE:
+ pr_err("HCALL(%x): LPAR credit limit exceeds window limit\n",
+ H_ALLOCATE_VAS_WINDOW);
+ return -EPERM;
+ case H_CONSTRAINED:
+ pr_err("HCALL(%x): Credits (%u) are not available\n",
+ H_ALLOCATE_VAS_WINDOW, credits);
+ return -EPERM;
+ default:
+ pr_err("HCALL(%x): Unexpected error %lld\n",
+ H_ALLOCATE_VAS_WINDOW, rc);
+ return -EIO;
+ }
+}
+
+/*
+ * Deallocate VAS window HCALL.
+ */
+static int plpar_vas_deallocate_window(u64 winid)
+{
+ int64_t rc;
+
+ do {
+ rc = plpar_hcall_norets(H_DEALLOCATE_VAS_WINDOW, winid);
+
+ rc = hcall_return_busy_check(rc);
+ } while (rc == H_BUSY);
+
+ switch (rc) {
+ case H_SUCCESS:
+ return 0;
+ case H_PARAMETER:
+ pr_err("HCALL(%x): Invalid window ID %llu\n",
+ H_DEALLOCATE_VAS_WINDOW, winid);
+ return -EINVAL;
+ case H_STATE:
+ pr_err("HCALL(%x): Window(%llu): Invalid page table entries\n",
+ H_DEALLOCATE_VAS_WINDOW, winid);
+ return -EPERM;
+ default:
+ pr_err("HCALL(%x): Unexpected error %lld for window(%llu)\n",
+ H_DEALLOCATE_VAS_WINDOW, 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 plpar_vas_modify_window(struct vas_window *win)
+{
+ int64_t rc;
+ u32 lpid = mfspr(SPRN_PID);
+
+ /*
+ * AMR value is not supported in Linux implementation
+ * phyp ignores it if 0 is passed.
+ */
+ do {
+ rc = plpar_hcall_norets(H_MODIFY_VAS_WINDOW, win->winid,
+ lpid, 0, VAS_MOD_WIN_FLAGS,
+ VAS_AMR_VALUE);
+
+ rc = hcall_return_busy_check(rc);
+ } while (rc == H_BUSY);
+
+ switch (rc) {
+ case H_SUCCESS:
+ return 0;
+ case H_PARAMETER:
+ pr_err("HCALL(%x): Invalid window ID %u\n",
+ H_MODIFY_VAS_WINDOW, win->winid);
+ return -EINVAL;
+ case H_P2:
+ pr_err("HCALL(%x): Window(%d): Invalid LPAR Process ID %u\n",
+ H_MODIFY_VAS_WINDOW, lpid, win->winid);
+ return -EINVAL;
+ case H_P3:
+ /* LPAR thread ID is deprecated on P10 */
+ pr_err("HCALL(%x): Invalid LPAR Thread ID for window(%u)\n",
+ H_MODIFY_VAS_WINDOW, win->winid);
+ return -EINVAL;
+ case H_STATE:
+ pr_err("HCALL(%x): Jobs in progress, Can't modify window(%u)\n",
+ H_MODIFY_VAS_WINDOW, win->winid);
+ return -EBUSY;
+ default:
+ pr_err("HCALL(%x): Unexpected error %lld for window(%u)\n",
+ H_MODIFY_VAS_WINDOW, rc, win->winid);
+ return -EIO;
+ }
+}
+
+/*
+ * This HCALL is used to determine the capabilities that pHyp provides.
+ * @hcall: H_QUERY_VAS_CAPABILITIES or H_QUERY_NX_CAPABILITIES
+ * @query_type: If 0 is passed, phyp returns the overall capabilities
+ * which provides all feature(s) that are available. Then
+ * query phyp 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 plpar_vas_query_capabilities(const u64 hcall, u8 query_type,
+ u64 result)
+{
+ int64_t rc;
+
+ rc = plpar_hcall_norets(hcall, query_type, result);
+
+ switch (rc) {
+ case H_SUCCESS:
+ return 0;
+ case H_PARAMETER:
+ pr_err("HCALL(%llx): Invalid query type %u\n", hcall,
+ query_type);
+ return -EINVAL;
+ case H_PRIVILEGE:
+ pr_err("HCALL(%llx): Invalid result buffer 0x%llx\n",
+ hcall, result);
+ return -EACCES;
+ default:
+ pr_err("HCALL(%llx): Unexpected error %lld\n", hcall, rc);
+ return -EIO;
+ }
+}
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 09/16] powerpc/pseries/vas: Implement to get all capabilities
From: Haren Myneni @ 2021-04-17 21:08 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
pHyp provides various VAS capabilities such as GZIP default and QoS
capabilities which are used to determine total number of credits
available in LPAR, maximum window credits, maximum LPAR credits,
whether usermode copy/paste is supported, and etc.
So first retrieve overall vas capabilities using
H_QUERY_VAS_CAPABILITIES HCALL which tells the specific features that
are available. Then retrieve the specific capabilities by using the
feature type in H_QUERY_VAS_CAPABILITIES HCALL.
pHyp supports only GZIP default and GZIP QoS capabilities right now.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/pseries/vas.c | 130 +++++++++++++++++++++++++++
1 file changed, 130 insertions(+)
diff --git a/arch/powerpc/platforms/pseries/vas.c b/arch/powerpc/platforms/pseries/vas.c
index 06960151477c..35946fb02995 100644
--- a/arch/powerpc/platforms/pseries/vas.c
+++ b/arch/powerpc/platforms/pseries/vas.c
@@ -30,6 +30,13 @@
/* phyp allows one credit per window right now */
#define DEF_WIN_CREDS 1
+static struct vas_all_capabs capabs_all;
+static int copypaste_feat;
+
+struct vas_capabs vcapabs[VAS_MAX_FEAT_TYPE];
+
+DEFINE_MUTEX(vas_pseries_mutex);
+
static int64_t hcall_return_busy_check(int64_t rc)
{
/* Check if we are stalled for some time */
@@ -215,3 +222,126 @@ int plpar_vas_query_capabilities(const u64 hcall, u8 query_type,
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 vas_ct_capabs_be *capab_be)
+{
+ struct vas_ct_capabs *capab;
+ struct vas_capabs *vcapab;
+ int rc = 0;
+
+ vcapab = &vcapabs[type];
+ memset(vcapab, 0, sizeof(*vcapab));
+ INIT_LIST_HEAD(&vcapab->list);
+
+ capab = &vcapab->capab;
+
+ rc = plpar_vas_query_capabilities(H_QUERY_VAS_CAPABILITIES, feat,
+ (u64)virt_to_phys(capab_be));
+ if (rc)
+ return rc;
+
+ capab->user_mode = capab_be->user_mode;
+ if (!(capab->user_mode & VAS_COPY_PASTE_USER_MODE)) {
+ pr_err("User space COPY/PASTE is not supported\n");
+ return -ENOTSUPP;
+ }
+
+ snprintf(capab->name, VAS_DESCR_LEN + 1, "%.8s",
+ (char *)&capab_be->descriptor);
+ capab->descriptor = be64_to_cpu(capab_be->descriptor);
+ capab->win_type = capab_be->win_type;
+ if (capab->win_type >= VAS_MAX_FEAT_TYPE) {
+ pr_err("Unsupported window type %u\n", capab->win_type);
+ return -EINVAL;
+ }
+ capab->max_lpar_creds = be16_to_cpu(capab_be->max_lpar_creds);
+ capab->max_win_creds = be16_to_cpu(capab_be->max_win_creds);
+ atomic_set(&capab->target_lpar_creds,
+ be16_to_cpu(capab_be->target_lpar_creds));
+ if (feat == VAS_GZIP_DEF_FEAT) {
+ capab->def_lpar_creds = be16_to_cpu(capab_be->def_lpar_creds);
+
+ if (capab->max_win_creds < DEF_WIN_CREDS) {
+ pr_err("Window creds(%u) > max allowed window creds(%u)\n",
+ DEF_WIN_CREDS, capab->max_win_creds);
+ return -EINVAL;
+ }
+ }
+
+ copypaste_feat = 1;
+
+ return 0;
+}
+
+static int __init pseries_vas_init(void)
+{
+ struct vas_ct_capabs_be *ct_capabs_be;
+ struct vas_all_capabs_be *capabs_be;
+ 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;
+ }
+
+ capabs_be = kmalloc(sizeof(*capabs_be), GFP_KERNEL);
+ if (!capabs_be)
+ return -ENOMEM;
+ /*
+ * Get VAS overall capabilities by passing 0 to feature type.
+ */
+ rc = plpar_vas_query_capabilities(H_QUERY_VAS_CAPABILITIES, 0,
+ (u64)virt_to_phys(capabs_be));
+ if (rc)
+ goto out;
+
+ snprintf(capabs_all.name, VAS_DESCR_LEN, "%.7s",
+ (char *)&capabs_be->descriptor);
+ capabs_all.descriptor = be64_to_cpu(capabs_be->descriptor);
+ capabs_all.feat_type = be64_to_cpu(capabs_be->feat_type);
+
+ ct_capabs_be = kmalloc(sizeof(*ct_capabs_be), GFP_KERNEL);
+ if (!ct_capabs_be) {
+ rc = -ENOMEM;
+ goto out;
+ }
+ /*
+ * QOS capabilities available
+ */
+ if (capabs_all.feat_type & VAS_GZIP_QOS_FEAT_BIT) {
+ rc = get_vas_capabilities(VAS_GZIP_QOS_FEAT,
+ VAS_GZIP_QOS_FEAT_TYPE, ct_capabs_be);
+
+ if (rc)
+ goto out_ct;
+ }
+ /*
+ * Default capabilities available
+ */
+ if (capabs_all.feat_type & VAS_GZIP_DEF_FEAT_BIT) {
+ rc = get_vas_capabilities(VAS_GZIP_DEF_FEAT,
+ VAS_GZIP_DEF_FEAT_TYPE, ct_capabs_be);
+ if (rc)
+ goto out_ct;
+ }
+
+ if (!copypaste_feat)
+ pr_err("GZIP feature is not supported\n");
+
+ pr_info("GZIP feature is available\n");
+
+out_ct:
+ kfree(ct_capabs_be);
+out:
+ kfree(capabs_be);
+ return rc;
+}
+machine_device_initcall(pseries, pseries_vas_init);
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 10/16] powerpc/pseries/vas: Integrate API with open/close windows
From: Haren Myneni @ 2021-04-17 21:08 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
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.
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 <haren@linux.ibm.com>
---
arch/powerpc/include/asm/vas.h | 5 +
arch/powerpc/platforms/book3s/Kconfig | 2 +-
arch/powerpc/platforms/pseries/Makefile | 1 +
arch/powerpc/platforms/pseries/vas.c | 212 ++++++++++++++++++++++++
4 files changed, 219 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/include/asm/vas.h b/arch/powerpc/include/asm/vas.h
index d15784506a54..aa1974aba27e 100644
--- a/arch/powerpc/include/asm/vas.h
+++ b/arch/powerpc/include/asm/vas.h
@@ -270,6 +270,11 @@ struct vas_all_capabs {
u64 feat_type;
};
+int plpar_vas_query_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
/*
diff --git a/arch/powerpc/platforms/book3s/Kconfig b/arch/powerpc/platforms/book3s/Kconfig
index 51e14db83a79..bed21449e8e5 100644
--- a/arch/powerpc/platforms/book3s/Kconfig
+++ b/arch/powerpc/platforms/book3s/Kconfig
@@ -1,7 +1,7 @@
# SPDX-License-Identifier: GPL-2.0
config PPC_VAS
bool "IBM Virtual Accelerator Switchboard (VAS)"
- depends on PPC_POWERNV && PPC_64K_PAGES
+ depends on (PPC_POWERNV || PPC_PSERIES) && PPC_64K_PAGES
default y
help
This enables support for IBM Virtual Accelerator Switchboard (VAS).
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index c8a2b0b05ac0..4cda0ef87be0 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -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
diff --git a/arch/powerpc/platforms/pseries/vas.c b/arch/powerpc/platforms/pseries/vas.c
index 35946fb02995..0ade0d6d728f 100644
--- a/arch/powerpc/platforms/pseries/vas.c
+++ b/arch/powerpc/platforms/pseries/vas.c
@@ -222,6 +222,218 @@ int plpar_vas_query_capabilities(const u64 hcall, u8 query_type,
return -EIO;
}
}
+EXPORT_SYMBOL_GPL(plpar_vas_query_capabilities);
+
+/*
+ * Allocate window and setup IRQ mapping.
+ */
+static int allocate_setup_window(struct vas_window *txwin,
+ u64 *domain, u8 wintype)
+{
+ int rc;
+
+ rc = plpar_vas_allocate_window(txwin, domain, wintype, DEF_WIN_CREDS);
+ if (rc)
+ return rc;
+
+ txwin->wcreds_max = DEF_WIN_CREDS;
+
+ return 0;
+}
+
+static struct vas_window *vas_allocate_window(struct vas_tx_win_open_attr *uattr,
+ enum vas_cop_type cop_type)
+{
+ long domain[PLPAR_HCALL9_BUFSIZE] = {VAS_DEFAULT_DOMAIN_ID};
+ struct vas_ct_capabs *ct_capab;
+ struct vas_capabs *capabs;
+ struct vas_window *txwin;
+ int rc;
+
+ txwin = kzalloc(sizeof(*txwin), GFP_KERNEL);
+ if (!txwin)
+ return ERR_PTR(-ENOMEM);
+
+ /*
+ * A VAS window can have many credits which means that many
+ * requests can be issued simultaneously. But phyp restricts
+ * one credit per window.
+ * phyp introduces 2 different types of credits:
+ * Default credit type (Uses normal priority FIFO):
+ * A limited number of credits are assigned to partitions
+ * based on processor entitlement. But these credits may be
+ * over-committed on a system depends on whether the CPUs
+ * are in shared or dedicated modes - that is, more requests
+ * may be issued across the system than NX can service at
+ * once which can result in paste command failure (RMA_busy).
+ * Then the process has to resend requests or fall-back to
+ * SW compression.
+ * Quality of Service (QoS) credit type (Uses high priority FIFO):
+ * To avoid NX HW contention, the system admins can assign
+ * QoS credits for each LPAR so that this partition is
+ * guaranteed access to NX resources. These credits are
+ * assigned to partitions via the HMC.
+ * Refer PAPR for more information.
+ *
+ * Allocate window with QoS credits if user requested. Otherwise
+ * default credits are used.
+ */
+ if (uattr->flags & VAS_WIN_QOS_CREDITS)
+ capabs = &vcapabs[VAS_GZIP_QOS_FEAT_TYPE];
+ else
+ capabs = &vcapabs[VAS_GZIP_DEF_FEAT_TYPE];
+
+ ct_capab = &capabs->capab;
+
+ if (atomic_inc_return(&ct_capab->used_lpar_creds) >
+ atomic_read(&ct_capab->target_lpar_creds)) {
+ pr_err("Credits are not available to allocate window\n");
+ rc = -EINVAL;
+ goto out;
+ }
+
+ /*
+ * The user space is requesting to allocate a window on a VAS
+ * instance (or chip) where the process is executing.
+ * On powerVM, domain values are passed to pHyp to select chip /
+ * VAS instance. Useful if the process is affinity to NUMA node.
+ * pHyp selects VAS instance if VAS_DEFAULT_DOMAIN_ID (-1) is
+ * passed for domain values.
+ */
+ if (uattr->vas_id == -1) {
+ /*
+ * To allocate VAS window, pass same domain values returned
+ * from this HCALL.
+ */
+ rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, domain,
+ VPHN_FLAG_VCPU, smp_processor_id());
+ if (rc != H_SUCCESS) {
+ pr_err("HCALL(%x): failed with ret(%d)\n",
+ H_HOME_NODE_ASSOCIATIVITY, rc);
+ goto out;
+ }
+ }
+
+ /*
+ * Allocate / Deallocate window HCALLs and setup / free IRQs
+ * have to be protected with mutex. Otherwise, since IRQ is freed
+ * after deallocate HCALL, may see the case where window ID and
+ * fault interrupt could be reused before free IRQ (for the old
+ * window) in kernel. It can result in setup IRQ fail for the
+ * new window.
+ */
+ mutex_lock(&vas_pseries_mutex);
+ rc = allocate_setup_window(txwin, (u64 *)&domain[0],
+ ct_capab->win_type);
+ mutex_unlock(&vas_pseries_mutex);
+ if (rc)
+ goto out;
+
+ /*
+ * Modify window and it is ready to use.
+ */
+ rc = plpar_vas_modify_window(txwin);
+ if (!rc)
+ rc = vas_reference_task(&txwin->task);
+ if (rc)
+ goto out_free;
+
+ txwin->lpar.win_type = ct_capab->win_type;
+ mutex_lock(&vas_pseries_mutex);
+ list_add(&txwin->lpar.win_list, &capabs->list);
+ mutex_unlock(&vas_pseries_mutex);
+
+ return txwin;
+
+out_free:
+ plpar_vas_deallocate_window(txwin->winid);
+out:
+ atomic_dec(&ct_capab->used_lpar_creds);
+ kfree(txwin);
+ return ERR_PTR(rc);
+}
+
+static u64 vas_paste_address(void *addr)
+{
+ struct vas_window *win = addr;
+
+ return win->lpar.win_addr;
+}
+
+static int deallocate_free_window(struct vas_window *win)
+{
+ int rc = 0;
+
+ rc = plpar_vas_deallocate_window(win->winid);
+ if (!rc)
+ kfree(win->lpar.name);
+
+ return rc;
+}
+
+static int vas_deallocate_window(void *addr)
+{
+ struct vas_window *win = (struct vas_window *)addr;
+ struct vas_ct_capabs *capabs;
+ int rc = 0;
+
+ if (!win)
+ return -EINVAL;
+
+ /* Should not happen */
+ if (win->lpar.win_type >= VAS_MAX_FEAT_TYPE) {
+ pr_err("Window (%u): Invalid window type %u\n",
+ win->winid, win->lpar.win_type);
+ return -EINVAL;
+ }
+
+ capabs = &vcapabs[win->lpar.win_type].capab;
+ mutex_lock(&vas_pseries_mutex);
+ rc = deallocate_free_window(win);
+ if (rc) {
+ mutex_unlock(&vas_pseries_mutex);
+ return rc;
+ }
+
+ list_del(&win->lpar.win_list);
+ atomic_dec(&capabs->used_lpar_creds);
+ mutex_unlock(&vas_pseries_mutex);
+
+ vas_drop_reference_task(&win->task);
+
+ kfree(win);
+ return 0;
+}
+
+static struct vas_user_win_ops vops_pseries = {
+ .open_win = vas_allocate_window, /* Open and configure window */
+ .paste_addr = vas_paste_address, /* To do copy/paste */
+ .close_win = vas_deallocate_window, /* Close window */
+};
+
+/*
+ * Supporting only nx-gzip coprocessor type now, but this API code
+ * extended to other coprocessor types later.
+ */
+int vas_register_api_pseries(struct module *mod, enum vas_cop_type cop_type,
+ const char *name)
+{
+ int rc;
+
+ if (!copypaste_feat)
+ return -ENOTSUPP;
+
+ rc = vas_register_coproc_api(mod, cop_type, name, &vops_pseries);
+
+ return rc;
+}
+EXPORT_SYMBOL_GPL(vas_register_api_pseries);
+
+void vas_unregister_api_pseries(void)
+{
+ vas_unregister_coproc_api();
+}
+EXPORT_SYMBOL_GPL(vas_unregister_api_pseries);
/*
* Get the specific capabilities based on the feature type.
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 11/16] powerpc/pseries/vas: Setup IRQ and fault handling
From: Haren Myneni @ 2021-04-17 21:09 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
When NX sees a fault on the user space buffer, generates a fault
interrupt and pHyp forwards that interrupt to OS. Then the kernel
makes H_GET_NX_FAULT HCALL to retrieve the fault CRB information.
This patch adds changes to setup IRQ per each window and handles
fault by updating CSB.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/pseries/vas.c | 111 ++++++++++++++++++++++++++-
1 file changed, 110 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/platforms/pseries/vas.c b/arch/powerpc/platforms/pseries/vas.c
index 0ade0d6d728f..2106eca0862a 100644
--- a/arch/powerpc/platforms/pseries/vas.c
+++ b/arch/powerpc/platforms/pseries/vas.c
@@ -224,6 +224,62 @@ int plpar_vas_query_capabilities(const u64 hcall, u8 query_type,
}
EXPORT_SYMBOL_GPL(plpar_vas_query_capabilities);
+/*
+ * HCALL to get fault CRB from pHyp.
+ */
+static int plpar_get_nx_fault(u32 winid, u64 buffer)
+{
+ int64_t rc;
+
+ rc = plpar_hcall_norets(H_GET_NX_FAULT, winid, buffer);
+
+ switch (rc) {
+ case H_SUCCESS:
+ return 0;
+ case H_PARAMETER:
+ pr_err("HCALL(%x): Invalid window ID %u\n", H_GET_NX_FAULT,
+ winid);
+ return -EINVAL;
+ case H_STATE:
+ pr_err("HCALL(%x): No outstanding faults for window ID %u\n",
+ H_GET_NX_FAULT, winid);
+ return -EINVAL;
+ case H_PRIVILEGE:
+ pr_err("HCALL(%x): Window(%u): Invalid fault buffer 0x%llx\n",
+ H_GET_NX_FAULT, winid, buffer);
+ return -EACCES;
+ default:
+ pr_err("HCALL(%x): Unexpected error %lld for window(%u)\n",
+ H_GET_NX_FAULT, rc, winid);
+ return -EIO;
+ }
+}
+
+/*
+ * Handle the fault interrupt.
+ * When the fault interrupt is received for each window, query pHyp 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: pHyp 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 vas_window *txwin = data;
+ struct coprocessor_request_block crb;
+ struct vas_win_task *tsk;
+ int rc;
+
+ rc = plpar_get_nx_fault(txwin->winid, (u64)virt_to_phys(&crb));
+ if (!rc) {
+ tsk = &txwin->task;
+ vas_dump_crb(&crb);
+ vas_update_csb(&crb, tsk);
+ }
+
+ return IRQ_HANDLED;
+}
+
/*
* Allocate window and setup IRQ mapping.
*/
@@ -235,10 +291,51 @@ static int allocate_setup_window(struct vas_window *txwin,
rc = plpar_vas_allocate_window(txwin, domain, wintype, DEF_WIN_CREDS);
if (rc)
return rc;
+ /*
+ * On powerVM, pHyp setup and forwards the fault interrupt per
+ * window. So the IRQ setup and fault handling will be done for
+ * each open window separately.
+ */
+ txwin->lpar.fault_virq = irq_create_mapping(NULL,
+ txwin->lpar.fault_irq);
+ if (!txwin->lpar.fault_virq) {
+ pr_err("Failed irq mapping %d\n", txwin->lpar.fault_irq);
+ rc = -EINVAL;
+ goto out_win;
+ }
+
+ txwin->lpar.name = kasprintf(GFP_KERNEL, "vas-win-%d", txwin->winid);
+ if (!txwin->lpar.name) {
+ rc = -ENOMEM;
+ goto out_irq;
+ }
+
+ rc = request_threaded_irq(txwin->lpar.fault_virq, NULL,
+ pseries_vas_fault_thread_fn, IRQF_ONESHOT,
+ txwin->lpar.name, txwin);
+ if (rc) {
+ pr_err("VAS-Window[%d]: Request IRQ(%u) failed with %d\n",
+ txwin->winid, txwin->lpar.fault_virq, rc);
+ goto out_free;
+ }
txwin->wcreds_max = DEF_WIN_CREDS;
return 0;
+out_free:
+ kfree(txwin->lpar.name);
+out_irq:
+ irq_dispose_mapping(txwin->lpar.fault_virq);
+out_win:
+ plpar_vas_deallocate_window(txwin->winid);
+ return rc;
+}
+
+static inline void free_irq_setup(struct vas_window *txwin)
+{
+ free_irq(txwin->lpar.fault_virq, txwin);
+ irq_dispose_mapping(txwin->lpar.fault_virq);
+ kfree(txwin->lpar.name);
}
static struct vas_window *vas_allocate_window(struct vas_tx_win_open_attr *uattr,
@@ -346,6 +443,11 @@ static struct vas_window *vas_allocate_window(struct vas_tx_win_open_attr *uattr
return txwin;
out_free:
+ /*
+ * Window is not operational. Free IRQ before closing
+ * window so that do not have to hold mutex.
+ */
+ free_irq_setup(txwin);
plpar_vas_deallocate_window(txwin->winid);
out:
atomic_dec(&ct_capab->used_lpar_creds);
@@ -364,9 +466,16 @@ static int deallocate_free_window(struct vas_window *win)
{
int rc = 0;
+ /*
+ * Free IRQ after executing H_DEALLOCATE_VAS_WINDOW HCALL
+ * to close the window. pHyp waits for all requests including
+ * faults are processed before closing the window - Means all
+ * credits are returned. In the case of fault request, credit
+ * is returned after OS issues H_GET_NX_FAULT HCALL.
+ */
rc = plpar_vas_deallocate_window(win->winid);
if (!rc)
- kfree(win->lpar.name);
+ free_irq_setup(win);
return rc;
}
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 12/16] powerpc/pseries/vas: sysfs interface to export capabilities
From: Haren Myneni @ 2021-04-17 21:10 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
pHyp provides GZIP default and GZIP QoS capabilities which gives
the total number of credits are available in LPAR. This patch
creates sysfs entries and exports LPAR credits, the currently used
and the available credits for each feature.
/sys/kernel/vas/VasCaps/VDefGzip: (default GZIP capabilities)
avail_lpar_creds /* Available credits to use */
target_lpar_creds /* Total credits available which can be
/* changed with DLPAR operation */
used_lpar_creds /* Used credits */
/sys/kernel/vas/VasCaps/VQosGzip (QoS GZIP capabilities)
avail_lpar_creds
target_lpar_creds
used_lpar_creds
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/pseries/Makefile | 2 +-
arch/powerpc/platforms/pseries/vas-sysfs.c | 173 +++++++++++++++++++++
arch/powerpc/platforms/pseries/vas.c | 6 +
arch/powerpc/platforms/pseries/vas.h | 2 +
4 files changed, 182 insertions(+), 1 deletion(-)
create mode 100644 arch/powerpc/platforms/pseries/vas-sysfs.c
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 4cda0ef87be0..e24093bebc0b 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -30,4 +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
+obj-$(CONFIG_PPC_VAS) += vas.o vas-sysfs.o
diff --git a/arch/powerpc/platforms/pseries/vas-sysfs.c b/arch/powerpc/platforms/pseries/vas-sysfs.c
new file mode 100644
index 000000000000..5f01f8ba6806
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/vas-sysfs.c
@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright 2016-17 IBM Corp.
+ */
+
+#define pr_fmt(fmt) "vas: " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/kobject.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+
+#include "vas.h"
+
+#ifdef CONFIG_SYSFS
+static struct kobject *pseries_vas_kobj;
+static struct kobject *vas_capabs_kobj;
+
+struct vas_capabs_entry {
+ struct kobject kobj;
+ struct vas_ct_capabs *capabs;
+};
+
+#define to_capabs_entry(entry) container_of(entry, struct vas_capabs_entry, kobj)
+
+static ssize_t avail_lpar_creds_show(struct vas_ct_capabs *capabs, char *buf)
+{
+ int avail_creds = atomic_read(&capabs->target_lpar_creds) -
+ atomic_read(&capabs->used_lpar_creds);
+ return sprintf(buf, "%d\n", avail_creds);
+}
+
+#define sysfs_capbs_entry_read(_name) \
+static ssize_t _name##_show(struct vas_ct_capabs *capabs, char *buf) \
+{ \
+ return sprintf(buf, "%d\n", atomic_read(&capabs->_name)); \
+}
+
+struct vas_sysfs_entry {
+ struct attribute attr;
+ ssize_t (*show)(struct vas_ct_capabs *, char *);
+ ssize_t (*store)(struct vas_ct_capabs *, const char *, size_t);
+};
+
+#define VAS_ATTR_RO(_name) \
+ sysfs_capbs_entry_read(_name); \
+ static struct vas_sysfs_entry _name##_attribute = __ATTR(_name, \
+ 0444, _name##_show, NULL);
+
+VAS_ATTR_RO(target_lpar_creds);
+VAS_ATTR_RO(used_lpar_creds);
+
+static struct vas_sysfs_entry avail_lpar_creds_attribute =
+ __ATTR(avail_lpar_creds, 0444, avail_lpar_creds_show, NULL);
+
+static struct attribute *vas_capab_attrs[] = {
+ &target_lpar_creds_attribute.attr,
+ &used_lpar_creds_attribute.attr,
+ &avail_lpar_creds_attribute.attr,
+ NULL,
+};
+
+static ssize_t vas_type_show(struct kobject *kobj, struct attribute *attr,
+ char *buf)
+{
+ struct vas_capabs_entry *centry;
+ struct vas_ct_capabs *capabs;
+ struct vas_sysfs_entry *entry;
+
+ centry = to_capabs_entry(kobj);
+ capabs = centry->capabs;
+ entry = container_of(attr, struct vas_sysfs_entry, attr);
+
+ if (!entry->show)
+ return -EIO;
+
+ return entry->show(capabs, buf);
+}
+
+static ssize_t vas_type_store(struct kobject *kobj, struct attribute *attr,
+ const char *buf, size_t count)
+{
+ struct vas_capabs_entry *centry;
+ struct vas_ct_capabs *capabs;
+ struct vas_sysfs_entry *entry;
+
+ centry = to_capabs_entry(kobj);
+ capabs = centry->capabs;
+ entry = container_of(attr, struct vas_sysfs_entry, attr);
+ if (!entry->store)
+ return -EIO;
+
+ return entry->store(capabs, buf, count);
+}
+
+static void vas_type_release(struct kobject *kobj)
+{
+ struct vas_capabs_entry *centry = to_capabs_entry(kobj);
+ kfree(centry);
+}
+
+static const struct sysfs_ops vas_sysfs_ops = {
+ .show = vas_type_show,
+ .store = vas_type_store,
+};
+
+static struct kobj_type vas_attr_type = {
+ .release = vas_type_release,
+ .sysfs_ops = &vas_sysfs_ops,
+ .default_attrs = vas_capab_attrs,
+};
+
+/*
+ * Add feature specific capability dir entry.
+ * Ex: VDefGzip or VQosGzip
+ */
+int sysfs_add_vas_capabs(struct vas_ct_capabs *capabs)
+{
+ struct vas_capabs_entry *centry;
+ int ret = 0;
+
+ centry = kzalloc(sizeof(*centry), GFP_KERNEL);
+ if (!centry)
+ return -ENOMEM;
+
+ kobject_init(¢ry->kobj, &vas_attr_type);
+ centry->capabs = capabs;
+
+ ret = kobject_add(¢ry->kobj, vas_capabs_kobj, "%s",
+ capabs->name);
+
+ if (ret) {
+ pr_err("VAS: sysfs kobject add / event failed %d\n", ret);
+ kobject_put(¢ry->kobj);
+ }
+
+ return ret;
+}
+
+/*
+ * Add VAS and VasCaps (overall capabilities) dir entries.
+ */
+int __init sysfs_pseries_vas_init(struct vas_all_capabs *vas_caps)
+{
+ pseries_vas_kobj = kobject_create_and_add("vas", kernel_kobj);
+ if (!pseries_vas_kobj) {
+ pr_err("Failed to create VAS sysfs entry\n");
+ return -ENOMEM;
+ }
+
+ vas_capabs_kobj = kobject_create_and_add(vas_caps->name,
+ pseries_vas_kobj);
+ if (!vas_capabs_kobj) {
+ pr_err("Failed to create VAS capabilities kobject\n");
+ kobject_put(pseries_vas_kobj);
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+#else
+int sysfs_add_vas_capabs(struct vas_ct_capabs *capabs)
+{
+ return 0;
+}
+
+int __init sysfs_pseries_vas_init(struct vas_all_capabs *vas_caps)
+{
+ return 0;
+}
+#endif
diff --git a/arch/powerpc/platforms/pseries/vas.c b/arch/powerpc/platforms/pseries/vas.c
index 2106eca0862a..ac06fa09900c 100644
--- a/arch/powerpc/platforms/pseries/vas.c
+++ b/arch/powerpc/platforms/pseries/vas.c
@@ -594,6 +594,10 @@ static int get_vas_capabilities(u8 feat, enum vas_cop_feat_type type,
}
}
+ rc = sysfs_add_vas_capabs(capab);
+ if (rc)
+ return rc;
+
copypaste_feat = 1;
return 0;
@@ -629,6 +633,8 @@ static int __init pseries_vas_init(void)
capabs_all.descriptor = be64_to_cpu(capabs_be->descriptor);
capabs_all.feat_type = be64_to_cpu(capabs_be->feat_type);
+ sysfs_pseries_vas_init(&capabs_all);
+
ct_capabs_be = kmalloc(sizeof(*ct_capabs_be), GFP_KERNEL);
if (!ct_capabs_be) {
rc = -ENOMEM;
diff --git a/arch/powerpc/platforms/pseries/vas.h b/arch/powerpc/platforms/pseries/vas.h
index 208682fffa57..e64677f03f08 100644
--- a/arch/powerpc/platforms/pseries/vas.h
+++ b/arch/powerpc/platforms/pseries/vas.h
@@ -93,4 +93,6 @@ struct vas_win_lpar_be {
__be64 win_util; /* Number of bytes processed */
} __packed __aligned(0x1000);
+int sysfs_add_vas_capabs(struct vas_ct_capabs *capabs);
+int __init sysfs_pseries_vas_init(struct vas_all_capabs *vas_caps);
#endif /* _VAS_H */
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 13/16] crypto/nx: Rename nx-842-pseries file name to nx-common-pseries
From: Haren Myneni @ 2021-04-17 21:11 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
Rename 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.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
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%)
diff --git a/drivers/crypto/nx/Makefile b/drivers/crypto/nx/Makefile
index bc89a20e5d9d..d00181a26dd6 100644
--- a/drivers/crypto/nx/Makefile
+++ b/drivers/crypto/nx/Makefile
@@ -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
diff --git a/drivers/crypto/nx/nx-842-pseries.c b/drivers/crypto/nx/nx-common-pseries.c
similarity index 100%
rename from drivers/crypto/nx/nx-842-pseries.c
rename to drivers/crypto/nx/nx-common-pseries.c
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 14/16] crypto/nx: Register and unregister VAS interface
From: Haren Myneni @ 2021-04-17 21:12 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
Changes to create /dev/crypto/nx-gzip interface with VAS register
and to remove this interface with VAS unregister.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
drivers/crypto/nx/Kconfig | 1 +
drivers/crypto/nx/nx-common-pseries.c | 9 +++++++++
2 files changed, 10 insertions(+)
diff --git a/drivers/crypto/nx/Kconfig b/drivers/crypto/nx/Kconfig
index 23e3d0160e67..2a35e0e785bd 100644
--- a/drivers/crypto/nx/Kconfig
+++ b/drivers/crypto/nx/Kconfig
@@ -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
diff --git a/drivers/crypto/nx/nx-common-pseries.c b/drivers/crypto/nx/nx-common-pseries.c
index cc8dd3072b8b..9a40fca8a9e6 100644
--- a/drivers/crypto/nx/nx-common-pseries.c
+++ b/drivers/crypto/nx/nx-common-pseries.c
@@ -9,6 +9,7 @@
*/
#include <asm/vio.h>
+#include <asm/vas.h>
#include "nx-842.h"
#include "nx_csbcpb.h" /* struct nx_csbcpb */
@@ -1101,6 +1102,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;
}
@@ -1111,6 +1118,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);
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 15/16] crypto/nx: Get NX capabilities for GZIP coprocessor type
From: Haren Myneni @ 2021-04-17 21:12 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
phyp provides NX capabilities which gives recommended minimum
compression / decompression length and maximum request buffer size
in bytes.
Changes to get NX overall capabilities which points to the specific
features phyp supports. Then retrieve NXGZIP specific capabilities.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
drivers/crypto/nx/nx-common-pseries.c | 83 +++++++++++++++++++++++++++
1 file changed, 83 insertions(+)
diff --git a/drivers/crypto/nx/nx-common-pseries.c b/drivers/crypto/nx/nx-common-pseries.c
index 9a40fca8a9e6..49224870d05e 100644
--- a/drivers/crypto/nx/nx-common-pseries.c
+++ b/drivers/crypto/nx/nx-common-pseries.c
@@ -9,6 +9,7 @@
*/
#include <asm/vio.h>
+#include <asm/hvcall.h>
#include <asm/vas.h>
#include "nx-842.h"
@@ -20,6 +21,24 @@ MODULE_DESCRIPTION("842 H/W Compression driver for IBM Power processors");
MODULE_ALIAS_CRYPTO("842");
MODULE_ALIAS_CRYPTO("842-nx");
+struct nx_ct_capabs_be {
+ __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);
+
+struct nx_ct_capabs {
+ char name[VAS_DESCR_LEN + 1];
+ 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 */
+};
+
+u64 capab_feat = 0;
+struct nx_ct_capabs nx_ct_capab;
+
static struct nx842_constraints nx842_pseries_constraints = {
.alignment = DDE_BUFFER_ALIGN,
.multiple = DDE_BUFFER_LAST_MULT,
@@ -1066,6 +1085,66 @@ static void nx842_remove(struct vio_dev *viodev)
kfree(old_devdata);
}
+/*
+ * Get NX capabilities from pHyp.
+ * Only NXGZIP capabilities are available right now and these values
+ * are available through sysfs.
+ */
+static void __init nxct_get_capabilities(void)
+{
+ struct vas_all_capabs_be *capabs_be;
+ struct nx_ct_capabs_be *nxc_be;
+ int rc;
+
+ capabs_be = kmalloc(sizeof(*capabs_be), GFP_KERNEL);
+ if (!capabs_be)
+ return;
+ /*
+ * Get NX overall capabilities with feature type=0
+ */
+ rc = plpar_vas_query_capabilities(H_QUERY_NX_CAPABILITIES, 0,
+ (u64)virt_to_phys(capabs_be));
+ if (rc)
+ goto out;
+
+ capab_feat = be64_to_cpu(capabs_be->feat_type);
+ /*
+ * NX-GZIP feature available
+ */
+ if (capab_feat & VAS_NX_GZIP_FEAT_BIT) {
+ nxc_be = kmalloc(sizeof(*nxc_be), GFP_KERNEL);
+ if (!nxc_be)
+ goto out;
+ /*
+ * Get capabilities for NX-GZIP feature
+ */
+ rc = plpar_vas_query_capabilities(H_QUERY_NX_CAPABILITIES,
+ VAS_NX_GZIP_FEAT,
+ (u64)virt_to_phys(nxc_be));
+ } else {
+ pr_err("NX-GZIP feature is not available\n");
+ rc = -EINVAL;
+ }
+
+ if (!rc) {
+ snprintf(nx_ct_capab.name, VAS_DESCR_LEN + 1, "%.8s",
+ (char *)&nxc_be->descriptor);
+ nx_ct_capab.descriptor = be64_to_cpu(nxc_be->descriptor);
+ nx_ct_capab.req_max_processed_len =
+ be64_to_cpu(nxc_be->req_max_processed_len);
+ nx_ct_capab.min_compress_len =
+ be64_to_cpu(nxc_be->min_compress_len);
+ nx_ct_capab.min_decompress_len =
+ be64_to_cpu(nxc_be->min_decompress_len);
+ } else {
+ capab_feat = 0;
+ }
+
+ kfree(nxc_be);
+out:
+ kfree(capabs_be);
+}
+
static const struct vio_device_id nx842_vio_driver_ids[] = {
{"ibm,compression-v1", "ibm,compression"},
{"", ""},
@@ -1093,6 +1172,10 @@ static int __init nx842_pseries_init(void)
return -ENOMEM;
RCU_INIT_POINTER(devdata, new_devdata);
+ /*
+ * Get NX capabilities from pHyp which is used for NX-GZIP.
+ */
+ nxct_get_capabilities();
ret = vio_register_driver(&nx842_vio_driver);
if (ret) {
--
2.18.2
^ permalink raw reply related
* [V3 PATCH 16/16] crypto/nx: Add sysfs interface to export NX capabilities
From: Haren Myneni @ 2021-04-17 21:13 UTC (permalink / raw)
To: linuxppc-dev, linux-crypto, mpe, herbert, npiggin
In-Reply-To: <a910e5bd3f3398b4bd430b25a856500735b993c3.camel@linux.ibm.com>
Changes to export the following NXGZIP capabilities through sysfs:
/sys/devices/vio/ibm,compression-v1/NxGzCaps:
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 */
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
drivers/crypto/nx/nx-common-pseries.c | 43 +++++++++++++++++++++++++++
1 file changed, 43 insertions(+)
diff --git a/drivers/crypto/nx/nx-common-pseries.c b/drivers/crypto/nx/nx-common-pseries.c
index 49224870d05e..cc258d2c6475 100644
--- a/drivers/crypto/nx/nx-common-pseries.c
+++ b/drivers/crypto/nx/nx-common-pseries.c
@@ -962,6 +962,36 @@ static struct attribute_group nx842_attribute_group = {
.attrs = nx842_sysfs_entries,
};
+#define nxct_capab_read(_name) \
+static ssize_t nxct_##_name##_show(struct device *dev, \
+ struct device_attribute *attr, char *buf) \
+{ \
+ return sprintf(buf, "%lld\n", nx_ct_capab._name); \
+}
+
+#define NXCT_ATTR_RO(_name) \
+ nxct_capab_read(_name); \
+ static struct device_attribute dev_attr_##_name = __ATTR(_name, \
+ 0444, \
+ nxct_##_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 *nxct_capab_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 nxct_capab_attr_group = {
+ .name = nx_ct_capab.name,
+ .attrs = nxct_capab_sysfs_entries,
+};
+
static struct nx842_driver nx842_pseries_driver = {
.name = KBUILD_MODNAME,
.owner = THIS_MODULE,
@@ -1051,6 +1081,16 @@ static int nx842_probe(struct vio_dev *viodev,
goto error;
}
+ if (capab_feat) {
+ if (sysfs_create_group(&viodev->dev.kobj,
+ &nxct_capab_attr_group)) {
+ dev_err(&viodev->dev,
+ "Could not create sysfs NX capability entries\n");
+ ret = -1;
+ goto error;
+ }
+ }
+
return 0;
error_unlock:
@@ -1070,6 +1110,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 (capab_feat)
+ sysfs_remove_group(&viodev->dev.kobj, &nxct_capab_attr_group);
+
crypto_unregister_alg(&nx842_pseries_alg);
spin_lock_irqsave(&devdata_mutex, flags);
--
2.18.2
^ permalink raw reply related
* RE: [PATCH 2/2] mm: Indicate pfmemalloc pages in compound_head
From: David Laight @ 2021-04-17 21:13 UTC (permalink / raw)
To: 'Matthew Wilcox (Oracle)', brouer@redhat.com
Cc: arnd@kernel.org, grygorii.strashko@ti.com, netdev@vger.kernel.org,
ilias.apalodimas@linaro.org, linux-mips@vger.kernel.org,
linux-kernel@vger.kernel.org, mhocko@kernel.org,
linux-mm@kvack.org, mgorman@suse.de, mcroce@linux.microsoft.com,
linux-snps-arc@lists.infradead.org, linuxppc-dev@lists.ozlabs.org,
hch@lst.de, linux-arm-kernel@lists.infradead.org
In-Reply-To: <20210416230724.2519198-3-willy@infradead.org>
From: Matthew Wilcox (Oracle) <willy@infradead.org>
> Sent: 17 April 2021 00:07
>
> The net page_pool wants to use a magic value to identify page pool pages.
> The best place to put it is in the first word where it can be clearly a
> non-pointer value. That means shifting dma_addr up to alias with ->index,
> which means we need to find another way to indicate page_is_pfmemalloc().
> Since page_pool doesn't want to set its magic value on pages which are
> pfmemalloc, we can use bit 1 of compound_head to indicate that the page
> came from the memory reserves.
>
...
> struct { /* page_pool used by netstack */
> - /**
> - * @dma_addr: might require a 64-bit value on
> - * 32-bit architectures.
> - */
> + unsigned long pp_magic;
> + unsigned long xmi;
> + unsigned long _pp_mapping_pad;
> unsigned long dma_addr[2];
> };
You've deleted the comment.
I also think there should be a comment that dma_addr[0]
must be aliased to ->index.
(Or whatever all the exact requirements are.)
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
Registration No: 1397386 (Wales)
^ permalink raw reply
* RE: [PATCH 1/2] mm: Fix struct page layout on 32-bit systems
From: David Laight @ 2021-04-17 21:18 UTC (permalink / raw)
To: 'Matthew Wilcox', brouer@redhat.com
Cc: arnd@kernel.org, grygorii.strashko@ti.com, netdev@vger.kernel.org,
ilias.apalodimas@linaro.org, linux-mips@vger.kernel.org,
linux-kernel@vger.kernel.org, mhocko@kernel.org,
linux-mm@kvack.org, mgorman@suse.de, mcroce@linux.microsoft.com,
linux-snps-arc@lists.infradead.org, linuxppc-dev@lists.ozlabs.org,
hch@lst.de, linux-arm-kernel@lists.infradead.org
In-Reply-To: <20210417024522.GP2531743@casper.infradead.org>
From: Matthew Wilcox <willy@infradead.org>
> Sent: 17 April 2021 03:45
>
> Replacement patch to fix compiler warning.
...
> static inline dma_addr_t page_pool_get_dma_addr(struct page *page)
> {
> - return page->dma_addr;
> + dma_addr_t ret = page->dma_addr[0];
> + if (sizeof(dma_addr_t) > sizeof(unsigned long))
> + ret |= (dma_addr_t)page->dma_addr[1] << 16 << 16;
Ugly as well.
Why not just replace the (dma_addr_t) cast with a (u64) one?
Looks better than the double shift.
Same could be done for the '>> 32'.
Is there an upper_32_bits() that could be used??
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
Registration No: 1397386 (Wales)
^ permalink raw reply
* Re: swiotlb cleanups v3
From: Tom Lendacky @ 2021-04-17 21:20 UTC (permalink / raw)
To: hch; +Cc: xen-devel, konrad.wilk, dongli.zhang, iommu, tientzu,
linuxppc-dev
In-Reply-To: <0349082c-59c5-20d7-f324-279981c3f6ea@amd.com>
On 4/17/21 11:39 AM, Tom Lendacky wrote:
>> Hi Konrad,
>>
>> this series contains a bunch of swiotlb cleanups, mostly to reduce the
>> amount of internals exposed to code outside of swiotlb.c, which should
>> helper to prepare for supporting multiple different bounce buffer pools.
>
> Somewhere between the 1st and 2nd patch, specifying a specific swiotlb
> for an SEV guest is no longer honored. For example, if I start an SEV
> guest with 16GB of memory and specify swiotlb=131072 I used to get a
> 256MB SWIOTLB. However, after the 2nd patch, the swiotlb=131072 is no
> longer honored and I get a 982MB SWIOTLB (as set via sev_setup_arch() in
> arch/x86/mm/mem_encrypt.c).
>
> I can't be sure which patch caused the issue since an SEV guest fails to
> boot with the 1st patch but can boot with the 2nd patch, at which point
> the SWIOTLB comes in at 982MB (I haven't had a chance to debug it and so
> I'm hoping you might be able to quickly spot what's going on).
Ok, I figured out the 1st patch boot issue (which is gone when the
second patch is applied). Here's the issue if anyone is interested:
diff --git a/kernel/dma/swiotlb.c b/kernel/dma/swiotlb.c
index d9c097f0f78c..dbe369674afe 100644
--- a/kernel/dma/swiotlb.c
+++ b/kernel/dma/swiotlb.c
@@ -226,7 +226,7 @@ int __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose)
alloc_size = PAGE_ALIGN(mem->nslabs * sizeof(size_t));
mem->alloc_size = memblock_alloc(alloc_size, PAGE_SIZE);
- if (mem->alloc_size)
+ if (!mem->alloc_size)
panic("%s: Failed to allocate %zu bytes align=0x%lx\n",
__func__, alloc_size, PAGE_SIZE);
The 1st patch still allowed the command line specified size of 256MB
SWIOTLB. So that means the 2nd patch causes the command line specified
256MB SWIOTLB size to be ignored and results in a 982MB SWIOTLB size
for the 16GB guest.
Thanks,
Tom
>
> Thanks,
> Tom
>
>>
>> Changes since v2:
>> - fix a bisetion hazard that did not allocate the alloc_size array
>> - dropped all patches already merged
>>
>> Changes since v1:
>> - rebased to v5.12-rc1
>> - a few more cleanups
>> - merge and forward port the patch from Claire to move all the global
>> variables into a struct to prepare for multiple instances
>
^ permalink raw reply related
* Re: [PATCH 2/2] mm: Indicate pfmemalloc pages in compound_head
From: Matthew Wilcox @ 2021-04-17 21:28 UTC (permalink / raw)
To: David Laight
Cc: arnd@kernel.org, grygorii.strashko@ti.com, netdev@vger.kernel.org,
ilias.apalodimas@linaro.org, linux-kernel@vger.kernel.org,
linux-mips@vger.kernel.org, mhocko@kernel.org, linux-mm@kvack.org,
mgorman@suse.de, brouer@redhat.com, mcroce@linux.microsoft.com,
linux-snps-arc@lists.infradead.org, linuxppc-dev@lists.ozlabs.org,
hch@lst.de, linux-arm-kernel@lists.infradead.org
In-Reply-To: <2a531a42f23e4046833e0feb8faef0b5@AcuMS.aculab.com>
On Sat, Apr 17, 2021 at 09:13:45PM +0000, David Laight wrote:
> > struct { /* page_pool used by netstack */
> > - /**
> > - * @dma_addr: might require a 64-bit value on
> > - * 32-bit architectures.
> > - */
> > + unsigned long pp_magic;
> > + unsigned long xmi;
> > + unsigned long _pp_mapping_pad;
> > unsigned long dma_addr[2];
> > };
>
> You've deleted the comment.
Yes. It no longer added any value. You can see dma_addr now occupies
two words.
> I also think there should be a comment that dma_addr[0]
> must be aliased to ->index.
That's not a requirement. Moving the pfmemalloc indicator is a
requirement so that we _can_ use index, but there's no requirement about
how index is used.
^ permalink raw reply
* Re: [PATCH 1/2] mm: Fix struct page layout on 32-bit systems
From: Matthew Wilcox @ 2021-04-17 22:45 UTC (permalink / raw)
To: David Laight
Cc: arnd@kernel.org, grygorii.strashko@ti.com, netdev@vger.kernel.org,
ilias.apalodimas@linaro.org, linux-kernel@vger.kernel.org,
linux-mips@vger.kernel.org, mhocko@kernel.org, linux-mm@kvack.org,
mgorman@suse.de, brouer@redhat.com, mcroce@linux.microsoft.com,
linux-snps-arc@lists.infradead.org, linuxppc-dev@lists.ozlabs.org,
hch@lst.de, linux-arm-kernel@lists.infradead.org
In-Reply-To: <386d009232dc42bdaf83d4cc36b13864@AcuMS.aculab.com>
On Sat, Apr 17, 2021 at 09:18:57PM +0000, David Laight wrote:
> Ugly as well.
Thank you for expressing your opinion. Again.
^ permalink raw reply
* Re: mmu.c:undefined reference to `patch__hash_page_A0'
From: Randy Dunlap @ 2021-04-18 0:02 UTC (permalink / raw)
To: kernel test robot, Christophe Leroy; +Cc: PowerPC, kbuild-all, linux-kernel
In-Reply-To: <202102271820.WlZCxtzY-lkp@intel.com>
HI--
I no longer see this build error.
However:
On 2/27/21 2:24 AM, kernel test robot wrote:
> tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
> head: 3fb6d0e00efc958d01c2f109c8453033a2d96796
> commit: 259149cf7c3c6195e6199e045ca988c31d081cab powerpc/32s: Only build hash code when CONFIG_PPC_BOOK3S_604 is selected
> date: 4 weeks ago
> config: powerpc64-randconfig-r013-20210227 (attached as .config)
ktr/lkp, this is a PPC32 .config file that is attached, not PPC64.
Also:
> compiler: powerpc-linux-gcc (GCC) 9.3.0
> reproduce (this is a W=1 build):
> wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
> chmod +x ~/bin/make.cross
> # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=259149cf7c3c6195e6199e045ca988c31d081cab
> git remote add linus https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
> git fetch --no-tags linus master
> git checkout 259149cf7c3c6195e6199e045ca988c31d081cab
> # save the attached .config to linux build tree
> COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=powerpc64
>
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
>
> All errors (new ones prefixed by >>):
>
> powerpc-linux-ld: arch/powerpc/mm/book3s32/mmu.o: in function `MMU_init_hw_patch':
>>> mmu.c:(.init.text+0x75e): undefined reference to `patch__hash_page_A0'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x76a): undefined reference to `patch__hash_page_A0'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x776): undefined reference to `patch__hash_page_A1'
> powerpc-linux-ld: mmu.c:(.init.text+0x782): undefined reference to `patch__hash_page_A1'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x78e): undefined reference to `patch__hash_page_A2'
> powerpc-linux-ld: mmu.c:(.init.text+0x79a): undefined reference to `patch__hash_page_A2'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x7aa): undefined reference to `patch__hash_page_B'
> powerpc-linux-ld: mmu.c:(.init.text+0x7b6): undefined reference to `patch__hash_page_B'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x7c2): undefined reference to `patch__hash_page_C'
> powerpc-linux-ld: mmu.c:(.init.text+0x7ce): undefined reference to `patch__hash_page_C'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x7da): undefined reference to `patch__flush_hash_A0'
> powerpc-linux-ld: mmu.c:(.init.text+0x7e6): undefined reference to `patch__flush_hash_A0'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x7f2): undefined reference to `patch__flush_hash_A1'
> powerpc-linux-ld: mmu.c:(.init.text+0x7fe): undefined reference to `patch__flush_hash_A1'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x80a): undefined reference to `patch__flush_hash_A2'
> powerpc-linux-ld: mmu.c:(.init.text+0x816): undefined reference to `patch__flush_hash_A2'
>>> powerpc-linux-ld: mmu.c:(.init.text+0x83e): undefined reference to `patch__flush_hash_B'
> powerpc-linux-ld: mmu.c:(.init.text+0x84e): undefined reference to `patch__flush_hash_B'
> powerpc-linux-ld: arch/powerpc/mm/book3s32/mmu.o: in function `update_mmu_cache':
>>> mmu.c:(.text.update_mmu_cache+0xa0): undefined reference to `add_hash_page'
I do see this build error:
powerpc-linux-ld: arch/powerpc/boot/wrapper.a(decompress.o): in function `partial_decompress':
decompress.c:(.text+0x1f0): undefined reference to `__decompress'
when either
CONFIG_KERNEL_LZO=y
or
CONFIG_KERNEL_LZMA=y
but the build succeeds when either
CONFIG_KERNEL_GZIP=y
or
CONFIG_KERNEL_XZ=y
I guess that is due to arch/powerpc/boot/decompress.c doing this:
#ifdef CONFIG_KERNEL_GZIP
# include "decompress_inflate.c"
#endif
#ifdef CONFIG_KERNEL_XZ
# include "xz_config.h"
# include "../../../lib/decompress_unxz.c"
#endif
It would be nice to require one of KERNEL_GZIP or KERNEL_XZ
to be set/enabled (maybe unless a uImage is being built?).
ta.
--
~Randy
^ permalink raw reply
* [PATCH] powerpc/papr_scm: trivial: fix typo in a comment
From: Kajol Jain @ 2021-04-18 7:40 UTC (permalink / raw)
To: mpe; +Cc: maddy, trivial, kjain, linux-kernel, vaibhav, linuxppc-dev
There is a spelling mistake "byes" -> "bytes" in a comment of
function drc_pmem_query_stats(). Fix that typo.
Signed-off-by: Kajol Jain <kjain@linux.ibm.com>
---
arch/powerpc/platforms/pseries/papr_scm.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
index 835163f54244..ba4faa513a74 100644
--- a/arch/powerpc/platforms/pseries/papr_scm.c
+++ b/arch/powerpc/platforms/pseries/papr_scm.c
@@ -227,7 +227,7 @@ static int drc_pmem_query_n_bind(struct papr_scm_priv *p)
* Query the Dimm performance stats from PHYP and copy them (if returned) to
* provided struct papr_scm_perf_stats instance 'stats' that can hold atleast
* (num_stats + header) bytes.
- * - If buff_stats == NULL the return value is the size in byes of the buffer
+ * - If buff_stats == NULL the return value is the size in bytes of the buffer
* needed to hold all supported performance-statistics.
* - If buff_stats != NULL and num_stats == 0 then we copy all known
* performance-statistics to 'buff_stat' and expect to be large enough to
--
2.27.0
^ permalink raw reply related
* Re: [PATCH] powerpc/papr_scm: Reduce error severity if nvdimm stats inaccessible
From: kajoljain @ 2021-04-18 7:58 UTC (permalink / raw)
To: Vaibhav Jain, Ira Weiny
Cc: Aneesh Kumar K . V, Santosh Sivaraj, linuxppc-dev, Dan Williams,
linux-nvdimm
In-Reply-To: <87h7k7lqf8.fsf@vajain21.in.ibm.com>
On 4/15/21 5:18 PM, Vaibhav Jain wrote:
> Ira Weiny <ira.weiny@intel.com> writes:
>
>> On Wed, Apr 14, 2021 at 09:51:40PM +0530, Vaibhav Jain wrote:
>>> Thanks for looking into this patch Ira,
>>>
>>> Ira Weiny <ira.weiny@intel.com> writes:
>>>
>>>> On Wed, Apr 14, 2021 at 06:10:26PM +0530, Vaibhav Jain wrote:
>>>>> Currently drc_pmem_qeury_stats() generates a dev_err in case
>>>>> "Enable Performance Information Collection" feature is disabled from
>>>>> HMC. The error is of the form below:
>>>>>
>>>>> papr_scm ibm,persistent-memory:ibm,pmemory@44104001: Failed to query
>>>>> performance stats, Err:-10
>>>>>
>>>>> This error message confuses users as it implies a possible problem
>>>>> with the nvdimm even though its due to a disabled feature.
>>>>>
>>>>> So we fix this by explicitly handling the H_AUTHORITY error from the
>>>>> H_SCM_PERFORMANCE_STATS hcall and generating a warning instead of an
>>>>> error, saying that "Performance stats in-accessible".
>>>>>
>>>>> Fixes: 2d02bf835e57('powerpc/papr_scm: Fetch nvdimm performance stats from PHYP')
>>>>> Signed-off-by: Vaibhav Jain <vaibhav@linux.ibm.com>
>>>>> ---
>>>>> arch/powerpc/platforms/pseries/papr_scm.c | 3 +++
>>>>> 1 file changed, 3 insertions(+)
>>>>>
>>>>> diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
>>>>> index 835163f54244..9216424f8be3 100644
>>>>> --- a/arch/powerpc/platforms/pseries/papr_scm.c
>>>>> +++ b/arch/powerpc/platforms/pseries/papr_scm.c
>>>>> @@ -277,6 +277,9 @@ static ssize_t drc_pmem_query_stats(struct papr_scm_priv *p,
>>>>> dev_err(&p->pdev->dev,
>>>>> "Unknown performance stats, Err:0x%016lX\n", ret[0]);
>>>>> return -ENOENT;
>>>>> + } else if (rc == H_AUTHORITY) {
>>>>> + dev_warn(&p->pdev->dev, "Performance stats in-accessible");
>>>>> + return -EPERM;
>>>>
>>>> Is this because of a disabled feature or because of permissions?
>>>
>>> Its because of a disabled feature that revokes permission for a guest to
>>> retrieve performance statistics.
>>>
>>> The feature is called "Enable Performance Information Collection" and
>>> once disabled the hcall H_SCM_PERFORMANCE_STATS returns an error
>>> H_AUTHORITY indicating that the guest doesn't have permission to retrieve
>>> performance statistics.
>>
>> In that case would it be appropriate to have the error message indicate a
>> permission issue?
>>
>> Something like 'permission denied'?
>
> Yes, Something like "Permission denied while accessing performance
> stats" might be more clear and intuitive.
Hi Vaibhav,
Thanks for the patch. I agree with Ira and above warning message with "Permission denied" looks more clear.
With that change, patch looks good to me.
Reviewed-By: Kajol Jain<kjain@linux.ibm.com>
Thanks,
Kajol Jain
>
> Will update the warn message in v2.
>
>>
>> Ira
>>
>
^ permalink raw reply
* Re: mmu.c:undefined reference to `patch__hash_page_A0'
From: Christophe Leroy @ 2021-04-18 10:43 UTC (permalink / raw)
To: Randy Dunlap, kernel test robot; +Cc: PowerPC, kbuild-all, linux-kernel
In-Reply-To: <06227600-c5c5-3da7-a495-ae0b0849b62d@infradead.org>
Le 18/04/2021 à 02:02, Randy Dunlap a écrit :
> HI--
>
> I no longer see this build error.
Fixed by https://github.com/torvalds/linux/commit/acdad8fb4a1574323db88f98a38b630691574e16
> However:
>
> On 2/27/21 2:24 AM, kernel test robot wrote:
>> tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
>> head: 3fb6d0e00efc958d01c2f109c8453033a2d96796
>> commit: 259149cf7c3c6195e6199e045ca988c31d081cab powerpc/32s: Only build hash code when CONFIG_PPC_BOOK3S_604 is selected
>> date: 4 weeks ago
>> config: powerpc64-randconfig-r013-20210227 (attached as .config)
>
> ktr/lkp, this is a PPC32 .config file that is attached, not PPC64.
>
> Also:
>
>> compiler: powerpc-linux-gcc (GCC) 9.3.0
...
>
> I do see this build error:
>
> powerpc-linux-ld: arch/powerpc/boot/wrapper.a(decompress.o): in function `partial_decompress':
> decompress.c:(.text+0x1f0): undefined reference to `__decompress'
>
> when either
> CONFIG_KERNEL_LZO=y
> or
> CONFIG_KERNEL_LZMA=y
>
> but the build succeeds when either
> CONFIG_KERNEL_GZIP=y
> or
> CONFIG_KERNEL_XZ=y
>
> I guess that is due to arch/powerpc/boot/decompress.c doing this:
>
> #ifdef CONFIG_KERNEL_GZIP
> # include "decompress_inflate.c"
> #endif
>
> #ifdef CONFIG_KERNEL_XZ
> # include "xz_config.h"
> # include "../../../lib/decompress_unxz.c"
> #endif
>
>
> It would be nice to require one of KERNEL_GZIP or KERNEL_XZ
> to be set/enabled (maybe unless a uImage is being built?).
Can you test by
https://patchwork.ozlabs.org/project/linuxppc-dev/patch/a74fce4dfc9fa32da6ce3470bbedcecf795de1ec.1591189069.git.christophe.leroy@csgroup.eu/
?
Thanks
Christophe
^ permalink raw reply
* Re: [PATCH 1/2] mm: Fix struct page layout on 32-bit systems
From: Ilias Apalodimas @ 2021-04-18 11:21 UTC (permalink / raw)
To: Matthew Wilcox
Cc: arnd, grygorii.strashko, netdev, linux-kernel, linux-mips, mhocko,
linux-mm, mgorman, brouer, mcroce, linux-snps-arc, linuxppc-dev,
hch, linux-arm-kernel
In-Reply-To: <20210417202240.GS2531743@casper.infradead.org>
On Sat, Apr 17, 2021 at 09:22:40PM +0100, Matthew Wilcox wrote:
> On Sat, Apr 17, 2021 at 09:32:06PM +0300, Ilias Apalodimas wrote:
> > > +static inline void page_pool_set_dma_addr(struct page *page, dma_addr_t addr)
> > > +{
> > > + page->dma_addr[0] = addr;
> > > + if (sizeof(dma_addr_t) > sizeof(unsigned long))
> > > + page->dma_addr[1] = addr >> 16 >> 16;
> >
> > The 'error' that was reported will never trigger right?
> > I assume this was compiled with dma_addr_t as 32bits (so it triggered the
> > compilation error), but the if check will never allow this codepath to run.
> > If so can we add a comment explaining this, since none of us will remember why
> > in 6 months from now?
>
> That's right. I compiled it all three ways -- 32-bit, 64-bit dma, 32-bit long
> and 64-bit. The 32/64 bit case turn into:
>
> if (0)
> page->dma_addr[1] = addr >> 16 >> 16;
>
> which gets elided. So the only case that has to work is 64-bit dma and
> 32-bit long.
>
> I can replace this with upper_32_bits().
>
Ok up to you, I don't mind either way and thanks for solving this!
Acked-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
^ permalink raw reply
* [PATCH] powerpc: Only define _TASK_CPU for 32-bit
From: Michael Ellerman @ 2021-04-18 13:16 UTC (permalink / raw)
To: linuxppc-dev
We have some interesting code in our Makefile to define _TASK_CPU, based
on awk'ing the value out of asm-offsets.h. It exists to circumvent some
circular header dependencies that prevent us from referring to
task_struct in the relevant code. See the comment around _TASK_CPU in
smp.h for more detail.
Maybe one day we can come up with a better solution, but for now we can
at least limit that logic to 32-bit, because it's not needed for 64-bit.
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
---
arch/powerpc/Makefile | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index 32dd693b4e42..3212d076ac6a 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -438,12 +438,15 @@ endif
endif
ifdef CONFIG_SMP
+ifdef CONFIG_PPC32
prepare: task_cpu_prepare
PHONY += task_cpu_prepare
task_cpu_prepare: prepare0
$(eval KBUILD_CFLAGS += -D_TASK_CPU=$(shell awk '{if ($$2 == "TASK_CPU") print $$3;}' include/generated/asm-offsets.h))
-endif
+
+endif # CONFIG_PPC32
+endif # CONFIG_SMP
PHONY += checkbin
# Check toolchain versions:
--
2.25.1
^ permalink raw reply related
* [PATCH] powerpc/pseries: Stop calling printk in rtas_stop_self()
From: Michael Ellerman @ 2021-04-18 13:54 UTC (permalink / raw)
To: linuxppc-dev
RCU complains about us calling printk() from an offline CPU:
=============================
WARNING: suspicious RCU usage
5.12.0-rc7-02874-g7cf90e481cb8 #1 Not tainted
-----------------------------
kernel/locking/lockdep.c:3568 RCU-list traversed in non-reader section!!
other info that might help us debug this:
RCU used illegally from offline CPU!
rcu_scheduler_active = 2, debug_locks = 1
no locks held by swapper/0/0.
stack backtrace:
CPU: 0 PID: 0 Comm: swapper/0 Not tainted 5.12.0-rc7-02874-g7cf90e481cb8 #1
Call Trace:
dump_stack+0xec/0x144 (unreliable)
lockdep_rcu_suspicious+0x124/0x144
__lock_acquire+0x1098/0x28b0
lock_acquire+0x128/0x600
_raw_spin_lock_irqsave+0x6c/0xc0
down_trylock+0x2c/0x70
__down_trylock_console_sem+0x60/0x140
vprintk_emit+0x1a8/0x4b0
vprintk_func+0xcc/0x200
printk+0x40/0x54
pseries_cpu_offline_self+0xc0/0x120
arch_cpu_idle_dead+0x54/0x70
do_idle+0x174/0x4a0
cpu_startup_entry+0x38/0x40
rest_init+0x268/0x388
start_kernel+0x748/0x790
start_here_common+0x1c/0x614
Which happens because by the time we get to rtas_stop_self() we are
already offline. In addition the message can be spammy, and is not that
helpful for users, so remove it.
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
---
arch/powerpc/platforms/pseries/hotplug-cpu.c | 3 ---
1 file changed, 3 deletions(-)
diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c
index ec478f8a98ff..48d9dfc3fad1 100644
--- a/arch/powerpc/platforms/pseries/hotplug-cpu.c
+++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c
@@ -47,9 +47,6 @@ static void rtas_stop_self(void)
BUG_ON(rtas_stop_self_token == RTAS_UNKNOWN_SERVICE);
- printk("cpu %u (hwid %u) Ready to die...\n",
- smp_processor_id(), hard_smp_processor_id());
-
rtas_call_unlocked(&args, rtas_stop_self_token, 0, 1, NULL);
panic("Alas, I survived.\n");
--
2.25.1
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox