* [PATCH v4 01/15] spapr: nested: register nested-hv api hcalls only for cap-nested-hv
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
@ 2024-02-20 8:35 ` Harsh Prateek Bora
2024-02-27 8:51 ` Nicholas Piggin
2024-02-20 8:35 ` [PATCH v4 02/15] spapr: nested: move nested part of spapr_get_pate into spapr_nested.c Harsh Prateek Bora
` (13 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:35 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Since cap-nested-hv is an optional capability, it makes sense to register
api specfic hcalls only when respective capability is enabled. This
requires to introduce a new API to unregister hypercalls to maintain
sanity across guest reboot since caps are re-applied across reboots and
re-registeration of hypercalls would hit assert otherwise.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
---
include/hw/ppc/spapr.h | 3 +++
include/hw/ppc/spapr_nested.h | 1 -
hw/ppc/spapr_caps.c | 2 ++
hw/ppc/spapr_hcall.c | 24 ++++++++++++++++++++++--
hw/ppc/spapr_nested.c | 17 +++++++++++++++--
5 files changed, 42 insertions(+), 5 deletions(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index e91791a1a9..b7ad2a0360 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -631,6 +631,7 @@ typedef target_ulong (*spapr_hcall_fn)(PowerPCCPU *cpu, SpaprMachineState *sm,
target_ulong *args);
void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn);
+void spapr_unregister_hypercall(target_ulong opcode);
target_ulong spapr_hypercall(PowerPCCPU *cpu, target_ulong opcode,
target_ulong *args);
@@ -1025,5 +1026,7 @@ void spapr_vof_client_dt_finalize(SpaprMachineState *spapr, void *fdt);
/* H_WATCHDOG */
void spapr_watchdog_init(SpaprMachineState *spapr);
+void spapr_register_nested_hv(void);
+void spapr_unregister_nested_hv(void);
#endif /* HW_SPAPR_H */
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index d312a5d61d..09d95182b2 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -95,7 +95,6 @@ struct nested_ppc_state {
int64_t tb_offset;
};
-void spapr_register_nested(void);
void spapr_exit_nested(PowerPCCPU *cpu, int excp);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
index e889244e52..f0c2f4de78 100644
--- a/hw/ppc/spapr_caps.c
+++ b/hw/ppc/spapr_caps.c
@@ -487,6 +487,8 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
"or use threads=1 with -smp\n");
}
+ spapr_unregister_nested_hv(); /* reset across reboots */
+ spapr_register_nested_hv();
}
}
diff --git a/hw/ppc/spapr_hcall.c b/hw/ppc/spapr_hcall.c
index fcefd1d1c7..8dbc2863a8 100644
--- a/hw/ppc/spapr_hcall.c
+++ b/hw/ppc/spapr_hcall.c
@@ -1521,6 +1521,28 @@ void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn)
*slot = fn;
}
+void spapr_unregister_hypercall(target_ulong opcode)
+{
+ spapr_hcall_fn *slot;
+
+ if (opcode <= MAX_HCALL_OPCODE) {
+ assert((opcode & 0x3) == 0);
+
+ slot = &papr_hypercall_table[opcode / 4];
+ } else if (opcode >= SVM_HCALL_BASE && opcode <= SVM_HCALL_MAX) {
+ /* we only have SVM-related hcall numbers assigned in multiples of 4 */
+ assert((opcode & 0x3) == 0);
+
+ slot = &svm_hypercall_table[(opcode - SVM_HCALL_BASE) / 4];
+ } else {
+ assert((opcode >= KVMPPC_HCALL_BASE) && (opcode <= KVMPPC_HCALL_MAX));
+
+ slot = &kvmppc_hypercall_table[opcode - KVMPPC_HCALL_BASE];
+ }
+
+ *slot = NULL;
+}
+
target_ulong spapr_hypercall(PowerPCCPU *cpu, target_ulong opcode,
target_ulong *args)
{
@@ -1634,8 +1656,6 @@ static void hypercall_register_types(void)
spapr_register_hypercall(KVMPPC_H_CAS, h_client_architecture_support);
spapr_register_hypercall(KVMPPC_H_UPDATE_DT, h_update_dt);
-
- spapr_register_nested();
}
type_init(hypercall_register_types)
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 121aa96ddc..a071092eff 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -375,20 +375,33 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
address_space_unmap(CPU(cpu)->as, regs, len, len, true);
}
-void spapr_register_nested(void)
+void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
spapr_register_hypercall(KVMPPC_H_ENTER_NESTED, h_enter_nested);
spapr_register_hypercall(KVMPPC_H_TLB_INVALIDATE, h_tlb_invalidate);
spapr_register_hypercall(KVMPPC_H_COPY_TOFROM_GUEST, h_copy_tofrom_guest);
}
+
+void spapr_unregister_nested_hv(void)
+{
+ spapr_unregister_hypercall(KVMPPC_H_SET_PARTITION_TABLE);
+ spapr_unregister_hypercall(KVMPPC_H_ENTER_NESTED);
+ spapr_unregister_hypercall(KVMPPC_H_TLB_INVALIDATE);
+ spapr_unregister_hypercall(KVMPPC_H_COPY_TOFROM_GUEST);
+}
#else
void spapr_exit_nested(PowerPCCPU *cpu, int excp)
{
g_assert_not_reached();
}
-void spapr_register_nested(void)
+void spapr_register_nested_hv(void)
+{
+ /* DO NOTHING */
+}
+
+void spapr_unregister_nested_hv(void)
{
/* DO NOTHING */
}
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 01/15] spapr: nested: register nested-hv api hcalls only for cap-nested-hv
2024-02-20 8:35 ` [PATCH v4 01/15] spapr: nested: register nested-hv api hcalls only for cap-nested-hv Harsh Prateek Bora
@ 2024-02-27 8:51 ` Nicholas Piggin
0 siblings, 0 replies; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 8:51 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
> Since cap-nested-hv is an optional capability, it makes sense to register
> api specfic hcalls only when respective capability is enabled. This
> requires to introduce a new API to unregister hypercalls to maintain
> sanity across guest reboot since caps are re-applied across reboots and
> re-registeration of hypercalls would hit assert otherwise.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> include/hw/ppc/spapr.h | 3 +++
> include/hw/ppc/spapr_nested.h | 1 -
> hw/ppc/spapr_caps.c | 2 ++
> hw/ppc/spapr_hcall.c | 24 ++++++++++++++++++++++--
> hw/ppc/spapr_nested.c | 17 +++++++++++++++--
> 5 files changed, 42 insertions(+), 5 deletions(-)
>
> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> index e91791a1a9..b7ad2a0360 100644
> --- a/include/hw/ppc/spapr.h
> +++ b/include/hw/ppc/spapr.h
> @@ -631,6 +631,7 @@ typedef target_ulong (*spapr_hcall_fn)(PowerPCCPU *cpu, SpaprMachineState *sm,
> target_ulong *args);
>
> void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn);
> +void spapr_unregister_hypercall(target_ulong opcode);
> target_ulong spapr_hypercall(PowerPCCPU *cpu, target_ulong opcode,
> target_ulong *args);
>
> @@ -1025,5 +1026,7 @@ void spapr_vof_client_dt_finalize(SpaprMachineState *spapr, void *fdt);
>
> /* H_WATCHDOG */
> void spapr_watchdog_init(SpaprMachineState *spapr);
> +void spapr_register_nested_hv(void);
> +void spapr_unregister_nested_hv(void);
>
> #endif /* HW_SPAPR_H */
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index d312a5d61d..09d95182b2 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -95,7 +95,6 @@ struct nested_ppc_state {
> int64_t tb_offset;
> };
>
> -void spapr_register_nested(void);
> void spapr_exit_nested(PowerPCCPU *cpu, int excp);
>
> #endif /* HW_SPAPR_NESTED_H */
> diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
> index e889244e52..f0c2f4de78 100644
> --- a/hw/ppc/spapr_caps.c
> +++ b/hw/ppc/spapr_caps.c
> @@ -487,6 +487,8 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
> error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
> "or use threads=1 with -smp\n");
> }
> + spapr_unregister_nested_hv(); /* reset across reboots */
> + spapr_register_nested_hv();
This looks a bit odd. And actually it also ends up registering them in
the SMT error case (which seems harmelss but a bit inconsistent).
I wonder whether you could make a spapr_nested_reset() function called
by spapr_machine_reset that would take care of
unregistering and reregistering nested hypercalls based on the caps that
were set.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 02/15] spapr: nested: move nested part of spapr_get_pate into spapr_nested.c
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
2024-02-20 8:35 ` [PATCH v4 01/15] spapr: nested: register nested-hv api hcalls only for cap-nested-hv Harsh Prateek Bora
@ 2024-02-20 8:35 ` Harsh Prateek Bora
2024-02-20 8:35 ` [PATCH v4 03/15] spapr: nested: Introduce SpaprMachineStateNested to store related info Harsh Prateek Bora
` (12 subsequent siblings)
14 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:35 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Most of the nested code has already been moved to spapr_nested.c
This logic inside spapr_get_pate is related to nested guests and
better suited for spapr_nested.c, hence moving there.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
---
include/hw/ppc/spapr_nested.h | 3 ++-
hw/ppc/spapr.c | 28 ++-------------------------
hw/ppc/spapr_nested.c | 36 +++++++++++++++++++++++++++++++++++
3 files changed, 40 insertions(+), 27 deletions(-)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 09d95182b2..1df1ce14f6 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -96,5 +96,6 @@ struct nested_ppc_state {
};
void spapr_exit_nested(PowerPCCPU *cpu, int excp);
-
+bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 0d72d286d8..97b69c0e42 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -1362,7 +1362,6 @@ void spapr_init_all_lpcrs(target_ulong value, target_ulong mask)
}
}
-
static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
target_ulong lpid, ppc_v3_pate_t *entry)
{
@@ -1375,33 +1374,10 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
/* Copy PATE1:GR into PATE0:HR */
entry->dw0 = spapr->patb_entry & PATE0_HR;
entry->dw1 = spapr->patb_entry;
-
+ return true;
} else {
- uint64_t patb, pats;
-
- assert(lpid != 0);
-
- patb = spapr->nested_ptcr & PTCR_PATB;
- pats = spapr->nested_ptcr & PTCR_PATS;
-
- /* Check if partition table is properly aligned */
- if (patb & MAKE_64BIT_MASK(0, pats + 12)) {
- return false;
- }
-
- /* Calculate number of entries */
- pats = 1ull << (pats + 12 - 4);
- if (pats <= lpid) {
- return false;
- }
-
- /* Grab entry */
- patb += 16 * lpid;
- entry->dw0 = ldq_phys(CPU(cpu)->as, patb);
- entry->dw1 = ldq_phys(CPU(cpu)->as, patb + 8);
+ return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
}
-
- return true;
}
#define HPTE(_table, _i) (void *)(((uint64_t *)(_table)) + ((_i) * 2))
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index a071092eff..b38e2d0be5 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -6,8 +6,38 @@
#include "hw/ppc/spapr.h"
#include "hw/ppc/spapr_cpu_core.h"
#include "hw/ppc/spapr_nested.h"
+#include "mmu-book3s-v3.h"
#ifdef CONFIG_TCG
+
+bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry)
+{
+ uint64_t patb, pats;
+
+ assert(lpid != 0);
+
+ patb = spapr->nested_ptcr & PTCR_PATB;
+ pats = spapr->nested_ptcr & PTCR_PATS;
+
+ /* Check if partition table is properly aligned */
+ if (patb & MAKE_64BIT_MASK(0, pats + 12)) {
+ return false;
+ }
+
+ /* Calculate number of entries */
+ pats = 1ull << (pats + 12 - 4);
+ if (pats <= lpid) {
+ return false;
+ }
+
+ /* Grab entry */
+ patb += 16 * lpid;
+ entry->dw0 = ldq_phys(CPU(cpu)->as, patb);
+ entry->dw1 = ldq_phys(CPU(cpu)->as, patb + 8);
+ return true;
+}
+
#define PRTS_MASK 0x1f
static target_ulong h_set_ptbl(PowerPCCPU *cpu,
@@ -405,4 +435,10 @@ void spapr_unregister_nested_hv(void)
{
/* DO NOTHING */
}
+
+bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry)
+{
+ return false;
+}
#endif
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* [PATCH v4 03/15] spapr: nested: Introduce SpaprMachineStateNested to store related info.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
2024-02-20 8:35 ` [PATCH v4 01/15] spapr: nested: register nested-hv api hcalls only for cap-nested-hv Harsh Prateek Bora
2024-02-20 8:35 ` [PATCH v4 02/15] spapr: nested: move nested part of spapr_get_pate into spapr_nested.c Harsh Prateek Bora
@ 2024-02-20 8:35 ` Harsh Prateek Bora
2024-02-20 8:35 ` [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API Harsh Prateek Bora
` (11 subsequent siblings)
14 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:35 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Currently, nested_ptcr is being used by existing nested-hv API to store
nested guest related info. This need to be organised to extend support
for the nested PAPR API which would need to store additional info
related to nested guests in next series of patches.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
---
include/hw/ppc/spapr.h | 3 ++-
include/hw/ppc/spapr_nested.h | 5 +++++
hw/ppc/spapr_nested.c | 8 ++++----
3 files changed, 11 insertions(+), 5 deletions(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index b7ad2a0360..63e9d4c476 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -12,6 +12,7 @@
#include "hw/ppc/spapr_xive.h" /* For SpaprXive */
#include "hw/ppc/xics.h" /* For ICSState */
#include "hw/ppc/spapr_tpm_proxy.h"
+#include "hw/ppc/spapr_nested.h" /* For SpaprMachineStateNested */
struct SpaprVioBus;
struct SpaprPhbState;
@@ -213,7 +214,7 @@ struct SpaprMachineState {
uint32_t vsmt; /* Virtual SMT mode (KVM's "core stride") */
/* Nested HV support (TCG only) */
- uint64_t nested_ptcr;
+ SpaprMachineStateNested nested;
Notifier epow_notifier;
QTAILQ_HEAD(, SpaprEventLogEntry) pending_events;
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 1df1ce14f6..2488ea98da 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -3,6 +3,10 @@
#include "target/ppc/cpu.h"
+typedef struct SpaprMachineStateNested {
+ uint64_t ptcr;
+} SpaprMachineStateNested;
+
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
* New member must be added at the end.
@@ -96,6 +100,7 @@ struct nested_ppc_state {
};
void spapr_exit_nested(PowerPCCPU *cpu, int excp);
+typedef struct SpaprMachineState SpaprMachineState;
bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
target_ulong lpid, ppc_v3_pate_t *entry);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index b38e2d0be5..e43e867295 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -17,8 +17,8 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
assert(lpid != 0);
- patb = spapr->nested_ptcr & PTCR_PATB;
- pats = spapr->nested_ptcr & PTCR_PATS;
+ patb = spapr->nested.ptcr & PTCR_PATB;
+ pats = spapr->nested.ptcr & PTCR_PATS;
/* Check if partition table is properly aligned */
if (patb & MAKE_64BIT_MASK(0, pats + 12)) {
@@ -55,7 +55,7 @@ static target_ulong h_set_ptbl(PowerPCCPU *cpu,
return H_PARAMETER;
}
- spapr->nested_ptcr = ptcr; /* Save new partition table */
+ spapr->nested.ptcr = ptcr; /* Save new partition table */
return H_SUCCESS;
}
@@ -187,7 +187,7 @@ static target_ulong h_enter_nested(PowerPCCPU *cpu,
struct kvmppc_pt_regs *regs;
hwaddr len;
- if (spapr->nested_ptcr == 0) {
+ if (spapr->nested.ptcr == 0) {
return H_NOT_AVAILABLE;
}
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (2 preceding siblings ...)
2024-02-20 8:35 ` [PATCH v4 03/15] spapr: nested: Introduce SpaprMachineStateNested to store related info Harsh Prateek Bora
@ 2024-02-20 8:35 ` Harsh Prateek Bora
2024-02-27 8:54 ` Nicholas Piggin
2024-02-20 8:35 ` [PATCH v4 05/15] spapr: nested: Document Nested PAPR API Harsh Prateek Bora
` (10 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:35 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
spapr_exit_nested and spapr_get_pate_nested_hv contains code which
is specific to nested-hv API. Isolating code flows based on API
helps extending it to be used with different API as well.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Suggested-by: Nicholas Piggin <npiggin@gmail.com>
---
include/hw/ppc/spapr_nested.h | 4 ++++
hw/ppc/spapr.c | 7 ++++++-
hw/ppc/spapr_caps.c | 1 +
hw/ppc/spapr_nested.c | 27 ++++++++++++++++++++++++---
4 files changed, 35 insertions(+), 4 deletions(-)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 2488ea98da..3f07c81c3d 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -5,6 +5,8 @@
typedef struct SpaprMachineStateNested {
uint64_t ptcr;
+ uint8_t api;
+#define NESTED_API_KVM_HV 1
} SpaprMachineStateNested;
/*
@@ -103,4 +105,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp);
typedef struct SpaprMachineState SpaprMachineState;
bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
target_ulong lpid, ppc_v3_pate_t *entry);
+void spapr_nested_init(SpaprMachineState *spapr);
+uint8_t spapr_nested_api(SpaprMachineState *spapr);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 97b69c0e42..51a1be027a 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -1376,7 +1376,11 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
entry->dw1 = spapr->patb_entry;
return true;
} else {
- return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
+ assert(spapr_nested_api(spapr));
+ if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
+ return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
+ }
+ return false;
}
}
@@ -3443,6 +3447,7 @@ static void spapr_instance_init(Object *obj)
spapr_get_host_serial, spapr_set_host_serial);
object_property_set_description(obj, "host-serial",
"Host serial number to advertise in guest device tree");
+ spapr_nested_init(spapr);
}
static void spapr_machine_finalizefn(Object *obj)
diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
index f0c2f4de78..721ddad23b 100644
--- a/hw/ppc/spapr_caps.c
+++ b/hw/ppc/spapr_caps.c
@@ -487,6 +487,7 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
"or use threads=1 with -smp\n");
}
+ spapr->nested.api = NESTED_API_KVM_HV;
spapr_unregister_nested_hv(); /* reset across reboots */
spapr_register_nested_hv();
}
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index e43e867295..9096dd96a4 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -8,6 +8,16 @@
#include "hw/ppc/spapr_nested.h"
#include "mmu-book3s-v3.h"
+void spapr_nested_init(SpaprMachineState *spapr)
+{
+ spapr->nested.api = 0;
+}
+
+uint8_t spapr_nested_api(SpaprMachineState *spapr)
+{
+ return spapr->nested.api;
+}
+
#ifdef CONFIG_TCG
bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
@@ -302,7 +312,7 @@ static target_ulong h_enter_nested(PowerPCCPU *cpu,
return env->gpr[3];
}
-void spapr_exit_nested(PowerPCCPU *cpu, int excp)
+static void spapr_exit_nested_hv(PowerPCCPU *cpu, int excp)
{
CPUPPCState *env = &cpu->env;
SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
@@ -314,8 +324,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
struct kvmppc_pt_regs *regs;
hwaddr len;
- assert(spapr_cpu->in_nested);
-
nested_save_state(&l2_state, cpu);
hsrr0 = env->spr[SPR_HSRR0];
hsrr1 = env->spr[SPR_HSRR1];
@@ -405,6 +413,19 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
address_space_unmap(CPU(cpu)->as, regs, len, len, true);
}
+void spapr_exit_nested(PowerPCCPU *cpu, int excp)
+{
+ SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
+ SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+
+ assert(spapr_cpu->in_nested);
+ if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
+ spapr_exit_nested_hv(cpu, excp);
+ } else {
+ g_assert_not_reached();
+ }
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API.
2024-02-20 8:35 ` [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API Harsh Prateek Bora
@ 2024-02-27 8:54 ` Nicholas Piggin
2024-02-27 9:45 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 8:54 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
> spapr_exit_nested and spapr_get_pate_nested_hv contains code which
> is specific to nested-hv API. Isolating code flows based on API
> helps extending it to be used with different API as well.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> Suggested-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> include/hw/ppc/spapr_nested.h | 4 ++++
> hw/ppc/spapr.c | 7 ++++++-
> hw/ppc/spapr_caps.c | 1 +
> hw/ppc/spapr_nested.c | 27 ++++++++++++++++++++++++---
> 4 files changed, 35 insertions(+), 4 deletions(-)
>
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index 2488ea98da..3f07c81c3d 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -5,6 +5,8 @@
>
> typedef struct SpaprMachineStateNested {
> uint64_t ptcr;
> + uint8_t api;
> +#define NESTED_API_KVM_HV 1
> } SpaprMachineStateNested;
>
> /*
> @@ -103,4 +105,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp);
> typedef struct SpaprMachineState SpaprMachineState;
> bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
> target_ulong lpid, ppc_v3_pate_t *entry);
> +void spapr_nested_init(SpaprMachineState *spapr);
> +uint8_t spapr_nested_api(SpaprMachineState *spapr);
> #endif /* HW_SPAPR_NESTED_H */
> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> index 97b69c0e42..51a1be027a 100644
> --- a/hw/ppc/spapr.c
> +++ b/hw/ppc/spapr.c
> @@ -1376,7 +1376,11 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
> entry->dw1 = spapr->patb_entry;
> return true;
> } else {
> - return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
> + assert(spapr_nested_api(spapr));
> + if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
> + return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
> + }
> + return false;
> }
> }
>
> @@ -3443,6 +3447,7 @@ static void spapr_instance_init(Object *obj)
> spapr_get_host_serial, spapr_set_host_serial);
> object_property_set_description(obj, "host-serial",
> "Host serial number to advertise in guest device tree");
> + spapr_nested_init(spapr);
I would maybe make this init a reset instead, and then it could do
the hypercall unregistering as well? You could rework that part of
it into patch 1 (or reorder the patches).
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API.
2024-02-27 8:54 ` Nicholas Piggin
@ 2024-02-27 9:45 ` Harsh Prateek Bora
2024-02-27 10:40 ` Nicholas Piggin
0 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-27 9:45 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 14:24, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
>> spapr_exit_nested and spapr_get_pate_nested_hv contains code which
>> is specific to nested-hv API. Isolating code flows based on API
>> helps extending it to be used with different API as well.
>>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> Suggested-by: Nicholas Piggin <npiggin@gmail.com>
>> ---
>> include/hw/ppc/spapr_nested.h | 4 ++++
>> hw/ppc/spapr.c | 7 ++++++-
>> hw/ppc/spapr_caps.c | 1 +
>> hw/ppc/spapr_nested.c | 27 ++++++++++++++++++++++++---
>> 4 files changed, 35 insertions(+), 4 deletions(-)
>>
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index 2488ea98da..3f07c81c3d 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -5,6 +5,8 @@
>>
>> typedef struct SpaprMachineStateNested {
>> uint64_t ptcr;
>> + uint8_t api;
>> +#define NESTED_API_KVM_HV 1
>> } SpaprMachineStateNested;
>>
>> /*
>> @@ -103,4 +105,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp);
>> typedef struct SpaprMachineState SpaprMachineState;
>> bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> target_ulong lpid, ppc_v3_pate_t *entry);
>> +void spapr_nested_init(SpaprMachineState *spapr);
>> +uint8_t spapr_nested_api(SpaprMachineState *spapr);
>> #endif /* HW_SPAPR_NESTED_H */
>> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
>> index 97b69c0e42..51a1be027a 100644
>> --- a/hw/ppc/spapr.c
>> +++ b/hw/ppc/spapr.c
>> @@ -1376,7 +1376,11 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
>> entry->dw1 = spapr->patb_entry;
>> return true;
>> } else {
>> - return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
>> + assert(spapr_nested_api(spapr));
>> + if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
>> + return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
>> + }
>> + return false;
>> }
>> }
>>
>> @@ -3443,6 +3447,7 @@ static void spapr_instance_init(Object *obj)
>> spapr_get_host_serial, spapr_set_host_serial);
>> object_property_set_description(obj, "host-serial",
>> "Host serial number to advertise in guest device tree");
>> + spapr_nested_init(spapr);
>
> I would maybe make this init a reset instead, and then it could do
> the hypercall unregistering as well? You could rework that part of
> it into patch 1 (or reorder the patches).
If we do unregistering here, we still hit the assert during
spapr_machine_reset which tries to reapply the caps and thus re-register
hcalls. Also, We cant register hcalls in this since the caps havent been
applied when init is called here. So we can do as you have previously
suggested, reset in spapr_machine_reset based on caps applied.
Let me know if you think otherwise?
regards,
Harsh
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API.
2024-02-27 9:45 ` Harsh Prateek Bora
@ 2024-02-27 10:40 ` Nicholas Piggin
0 siblings, 0 replies; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:40 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 27, 2024 at 7:45 PM AEST, Harsh Prateek Bora wrote:
>
>
> On 2/27/24 14:24, Nicholas Piggin wrote:
> > On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
> >> spapr_exit_nested and spapr_get_pate_nested_hv contains code which
> >> is specific to nested-hv API. Isolating code flows based on API
> >> helps extending it to be used with different API as well.
> >>
> >> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> >> Suggested-by: Nicholas Piggin <npiggin@gmail.com>
> >> ---
> >> include/hw/ppc/spapr_nested.h | 4 ++++
> >> hw/ppc/spapr.c | 7 ++++++-
> >> hw/ppc/spapr_caps.c | 1 +
> >> hw/ppc/spapr_nested.c | 27 ++++++++++++++++++++++++---
> >> 4 files changed, 35 insertions(+), 4 deletions(-)
> >>
> >> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> >> index 2488ea98da..3f07c81c3d 100644
> >> --- a/include/hw/ppc/spapr_nested.h
> >> +++ b/include/hw/ppc/spapr_nested.h
> >> @@ -5,6 +5,8 @@
> >>
> >> typedef struct SpaprMachineStateNested {
> >> uint64_t ptcr;
> >> + uint8_t api;
> >> +#define NESTED_API_KVM_HV 1
> >> } SpaprMachineStateNested;
> >>
> >> /*
> >> @@ -103,4 +105,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp);
> >> typedef struct SpaprMachineState SpaprMachineState;
> >> bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
> >> target_ulong lpid, ppc_v3_pate_t *entry);
> >> +void spapr_nested_init(SpaprMachineState *spapr);
> >> +uint8_t spapr_nested_api(SpaprMachineState *spapr);
> >> #endif /* HW_SPAPR_NESTED_H */
> >> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> >> index 97b69c0e42..51a1be027a 100644
> >> --- a/hw/ppc/spapr.c
> >> +++ b/hw/ppc/spapr.c
> >> @@ -1376,7 +1376,11 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
> >> entry->dw1 = spapr->patb_entry;
> >> return true;
> >> } else {
> >> - return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
> >> + assert(spapr_nested_api(spapr));
> >> + if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
> >> + return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
> >> + }
> >> + return false;
> >> }
> >> }
> >>
> >> @@ -3443,6 +3447,7 @@ static void spapr_instance_init(Object *obj)
> >> spapr_get_host_serial, spapr_set_host_serial);
> >> object_property_set_description(obj, "host-serial",
> >> "Host serial number to advertise in guest device tree");
> >> + spapr_nested_init(spapr);
> >
> > I would maybe make this init a reset instead, and then it could do
> > the hypercall unregistering as well? You could rework that part of
> > it into patch 1 (or reorder the patches).
>
> If we do unregistering here, we still hit the assert during
> spapr_machine_reset which tries to reapply the caps and thus re-register
> hcalls. Also, We cant register hcalls in this since the caps havent been
> applied when init is called here. So we can do as you have previously
> suggested, reset in spapr_machine_reset based on caps applied.
> Let me know if you think otherwise?
Not unregistering here, I mean make it a spapr_nested_reset() call and
call it from spapr_machine_reset().
If you call it after spapr_caps_apply() then you don't need to do the
hcall registering in the caps functions, just do it in the
reset.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 05/15] spapr: nested: Document Nested PAPR API
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (3 preceding siblings ...)
2024-02-20 8:35 ` [PATCH v4 04/15] spapr: nested: keep nested-hv related code restricted to its API Harsh Prateek Bora
@ 2024-02-20 8:35 ` Harsh Prateek Bora
2024-02-27 9:29 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 06/15] spapr: nested: Introduce H_GUEST_[GET|SET]_CAPABILITIES hcalls Harsh Prateek Bora
` (9 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:35 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Adding initial documentation about Nested PAPR API to describe the set
of APIs and its usage. Also talks about the Guest State Buffer elements
and it's format which is used between L0/L1 to communicate L2 state.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
docs/devel/nested-papr.txt | 514 +++++++++++++++++++++++++++++++++++++
1 file changed, 514 insertions(+)
create mode 100644 docs/devel/nested-papr.txt
diff --git a/docs/devel/nested-papr.txt b/docs/devel/nested-papr.txt
new file mode 100644
index 0000000000..b8c00c5ce2
--- /dev/null
+++ b/docs/devel/nested-papr.txt
@@ -0,0 +1,514 @@
+Nested PAPR API (aka KVM on PowerVM)
+====================================
+
+This API aims at providing support to enable nested virtualization with
+KVM on PowerVM. While the existing support for nested KVM on PowerNV was
+introduced with cap-nested-hv option, however, with a slight design change,
+to enable this on papr/pseries, a new cap-nested-papr option is added. eg:
+
+ qemu-system-ppc64 -cpu POWER10 -machine pseries,cap-nested-papr=true ...
+
+Work by:
+ Michael Neuling <mikey@neuling.org>
+ Vaibhav Jain <vaibhav@linux.ibm.com>
+ Jordan Niethe <jniethe5@gmail.com>
+ Harsh Prateek Bora <harshpb@linux.ibm.com>
+ Shivaprasad G Bhat <sbhat@linux.ibm.com>
+ Kautuk Consul <kconsul@linux.vnet.ibm.com>
+
+Below taken from the kernel documentation:
+
+Introduction
+============
+
+This document explains how a guest operating system can act as a
+hypervisor and run nested guests through the use of hypercalls, if the
+hypervisor has implemented them. The terms L0, L1, and L2 are used to
+refer to different software entities. L0 is the hypervisor mode entity
+that would normally be called the "host" or "hypervisor". L1 is a
+guest virtual machine that is directly run under L0 and is initiated
+and controlled by L0. L2 is a guest virtual machine that is initiated
+and controlled by L1 acting as a hypervisor. A significant design change
+wrt existing API is that now the entire L2 state is maintained within L0.
+
+Existing Nested-HV API
+======================
+
+Linux/KVM has had support for Nesting as an L0 or L1 since 2018
+
+The L0 code was added::
+
+ commit 8e3f5fc1045dc49fd175b978c5457f5f51e7a2ce
+ Author: Paul Mackerras <paulus@ozlabs.org>
+ Date: Mon Oct 8 16:31:03 2018 +1100
+ KVM: PPC: Book3S HV: Framework and hcall stubs for nested virtualization
+
+The L1 code was added::
+
+ commit 360cae313702cdd0b90f82c261a8302fecef030a
+ Author: Paul Mackerras <paulus@ozlabs.org>
+ Date: Mon Oct 8 16:31:04 2018 +1100
+ KVM: PPC: Book3S HV: Nested guest entry via hypercall
+
+This API works primarily using a signal hcall h_enter_nested(). This
+call made by the L1 to tell the L0 to start an L2 vCPU with the given
+state. The L0 then starts this L2 and runs until an L2 exit condition
+is reached. Once the L2 exits, the state of the L2 is given back to
+the L1 by the L0. The full L2 vCPU state is always transferred from
+and to L1 when the L2 is run. The L0 doesn't keep any state on the L2
+vCPU (except in the short sequence in the L0 on L1 -> L2 entry and L2
+-> L1 exit).
+
+The only state kept by the L0 is the partition table. The L1 registers
+it's partition table using the h_set_partition_table() hcall. All
+other state held by the L0 about the L2s is cached state (such as
+shadow page tables).
+
+The L1 may run any L2 or vCPU without first informing the L0. It
+simply starts the vCPU using h_enter_nested(). The creation of L2s and
+vCPUs is done implicitly whenever h_enter_nested() is called.
+
+In this document, we call this existing API the v1 API.
+
+New PAPR API
+===============
+
+The new PAPR API changes from the v1 API such that the creating L2 and
+associated vCPUs is explicit. In this document, we call this the v2
+API.
+
+h_enter_nested() is replaced with H_GUEST_VCPU_RUN(). Before this can
+be called the L1 must explicitly create the L2 using h_guest_create()
+and any associated vCPUs() created with h_guest_create_vCPU(). Getting
+and setting vCPU state can also be performed using h_guest_{g|s}et
+hcall.
+
+The basic execution flow is for an L1 to create an L2, run it, and
+delete it is:
+
+- L1 and L0 negotiate capabilities with H_GUEST_{G,S}ET_CAPABILITIES()
+ (normally at L1 boot time).
+
+- L1 requests the L0 to create an L2 with H_GUEST_CREATE() and receives a token
+
+- L1 requests the L0 to create an L2 vCPU with H_GUEST_CREATE_VCPU()
+
+- L1 and L0 communicate the vCPU state using the H_GUEST_{G,S}ET() hcall
+
+- L1 requests the L0 to run the vCPU using H_GUEST_RUN_VCPU() hcall
+
+- L1 deletes L2 with H_GUEST_DELETE()
+
+More details of the individual hcalls follows:
+
+HCALL Details
+=============
+
+This documentation is provided to give an overall understating of the
+API. It doesn't aim to provide full details required to implement
+an L1 or L0. Latest PAPR spec shall be referred for more details.
+
+All these HCALLs are made by the L1 to the L0.
+
+H_GUEST_GET_CAPABILITIES()
+--------------------------
+
+This is called to get the capabilities of the L0 nested
+hypervisor. This includes capabilities such the CPU versions (eg
+POWER9, POWER10) that are supported as L2s.
+
+H_GUEST_SET_CAPABILITIES()
+--------------------------
+
+This is called to inform the L0 of the capabilities of the L1
+hypervisor. The set of flags passed here are the same as
+H_GUEST_GET_CAPABILITIES()
+
+Typically, GET will be called first and then SET will be called with a
+subset of the flags returned from GET. This process allows the L0 and
+L1 to negotiate a agreed set of capabilities.
+
+H_GUEST_CREATE()
+----------------
+
+This is called to create a L2. Returned is ID of the L2 created
+(similar to an LPID), which can be use on subsequent HCALLs to
+identify the L2.
+
+H_GUEST_CREATE_VCPU()
+---------------------
+
+This is called to create a vCPU associated with a L2. The L2 id
+(returned from H_GUEST_CREATE()) should be passed it. Also passed in
+is a unique (for this L2) vCPUid. This vCPUid is allocated by the
+L1.
+
+H_GUEST_SET_STATE()
+-------------------
+
+This is called to set L2 wide or vCPU specific L2 state. This info is
+passed via the Guest State Buffer (GSB), details below.
+
+This can set either L2 wide or vcpu specific information. Examples of
+L2 wide is the timebase offset or process scoped page table
+info. Examples of vCPU wide are GPRs or VSRs. A bit in the flags
+parameter specifies if this call is L2 wide or vCPU specific and the
+IDs in the GSB must match this.
+
+The L1 provides a pointer to the GSB as a parameter to this call. Also
+provided is the L2 and vCPU IDs associated with the state to set.
+
+The L1 writes all values in the GSB and the L0 only reads the GSB for
+this call
+
+H_GUEST_GET_STATE()
+-------------------
+
+This is called to get state associated with a L2 or L2 vCPU. This info
+passed via the GSB (details below).
+
+This can get either L2 wide or vcpu specific information. Examples of
+L2 wide is the timebase offset or process scoped page table
+info. Examples of vCPU wide are GPRs or VSRs. A bit in the flags
+parameter specifies if this call is L2 wide or vCPU specific and the
+IDs in the GSB must match this.
+
+The L1 provides a pointer to the GSB as a parameter to this call. Also
+provided is the L2 and vCPU IDs associated with the state to get.
+
+The L1 writes only the IDs and sizes in the GSB. L0 writes the
+associated values for each ID in the GSB.
+
+H_GUEST_RUN_VCPU()
+------------------
+
+This is called to run an L2 vCPU. The L2 and vCPU IDs are passed in as
+parameters. The vCPU runs with the state set previously using
+H_GUEST_SET_STATE(). When the L2 exits, the L1 will resume from this
+hcall.
+
+This hcall also has associated input and output GSBs. Unlike
+H_GUEST_{S,G}ET_STATE(), these GSB pointers are not passed in as
+parameters to the hcall (This was done in the interest of
+performance). The locations of these GSBs must be preregistered using
+the H_GUEST_SET_STATE() call with ID 0x0c00 and 0x0c01 (see table later
+below).
+
+The input GSB may contain only VCPU wide elements to be set. This GSB
+may also contain zero elements (ie 0 in the first 4 bytes of the GSB)
+if nothing needs to be set.
+
+On exit from the hcall, the output buffer is filled with elements
+determined by the L0. The reason for the exit is contained in GPR4 (ie
+NIP is put in GPR4). The elements returned depend on the exit
+type. For example, if the exit reason is the L2 doing a hcall (GPR4 =
+0xc00), then GPR3-12 are provided in the output GSB as this is the
+state likely needed to service the hcall. If additional state is
+needed, H_GUEST_GET_STATE() may be called by the L1.
+
+To synthesize interrupts in the L2, when calling H_GUEST_RUN_VCPU()
+the L1 may set a flag (as a hcall parameter) and the L0 will
+synthesize the interrupt in the L2. Alternatively, the L1 may
+synthesize the interrupt itself using H_GUEST_SET_STATE() or the
+H_GUEST_RUN_VCPU() input GSB to set the state appropriately.
+
+H_GUEST_DELETE()
+----------------
+
+This is called to delete an L2. All associated vCPUs are also
+deleted. No specific vCPU delete call is provided.
+
+A flag may be provided to delete all guests. This is used to reset the
+L0 in the case of kdump/kexec.
+
+Guest State Buffer (GSB)
+========================
+
+The Guest State Buffer (GSB) is the main method of communicating state
+about the L2 between the L1 and L0 via H_GUEST_{G,S}ET() and
+H_GUEST_VCPU_RUN() calls.
+
+State may be associated with a whole L2 (eg timebase offset) or a
+specific L2 vCPU (eg. GPR state). Only L2 VCPU state maybe be set by
+H_GUEST_VCPU_RUN().
+
+All data in the GSB is big endian (as is standard in PAPR)
+
+The Guest state buffer has a header which gives the number of
+elements, followed by the GSB elements themselves.
+
+GSB header:
+
++----------+----------+-------------------------------------------+
+| Offset | Size | Purpose |
+| Bytes | Bytes | |
++==========+==========+===========================================+
+| 0 | 4 | Number of elements |
++----------+----------+-------------------------------------------+
+| 4 | | Guest state buffer elements |
++----------+----------+-------------------------------------------+
+
+GSB element:
+
++----------+----------+-------------------------------------------+
+| Offset | Size | Purpose |
+| Bytes | Bytes | |
++==========+==========+===========================================+
+| 0 | 2 | ID |
++----------+----------+-------------------------------------------+
+| 2 | 2 | Size of Value |
++----------+----------+-------------------------------------------+
+| 4 | As above | Value |
++----------+----------+-------------------------------------------+
+
+The ID in the GSB element specifies what is to be set. This includes
+archtected state like GPRs, VSRs, SPRs, plus also some meta data about
+the partition like the timebase offset and partition scoped page
+table information.
+
++--------+-------+----+--------+----------------------------------+
+| ID | Size | RW | Thread | Details |
+| | Bytes | | Guest | |
+| | | | Scope | |
++========+=======+====+========+==================================+
+| 0x0000 | | RW | TG | NOP element |
++--------+-------+----+--------+----------------------------------+
+| 0x0001 | 0x08 | R | G | Size of L0 vCPU state |
++--------+-------+----+--------+----------------------------------+
+| 0x0002 | 0x08 | R | G | Size Run vCPU out buffer |
++--------+-------+----+--------+----------------------------------+
+| 0x0003 | 0x04 | RW | G | Logical PVR |
++--------+-------+----+--------+----------------------------------+
+| 0x0004 | 0x08 | RW | G | TB Offset (L1 relative) |
++--------+-------+----+--------+----------------------------------+
+| 0x0005 | 0x18 | RW | G |Partition scoped page tbl info: |
+| | | | | |
+| | | | |- 0x00 Addr part scope table |
+| | | | |- 0x08 Num addr bits |
+| | | | |- 0x10 Size root dir |
++--------+-------+----+--------+----------------------------------+
+| 0x0006 | 0x10 | RW | G |Process Table Information: |
+| | | | | |
+| | | | |- 0x0 Addr proc scope table |
+| | | | |- 0x8 Table size. |
++--------+-------+----+--------+----------------------------------+
+| 0x0007-| | | | Reserved |
+| 0x0BFF | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x0C00 | 0x10 | RW | T |Run vCPU Input Buffer: |
+| | | | | |
+| | | | |- 0x0 Addr of buffer |
+| | | | |- 0x8 Buffer Size. |
++--------+-------+----+--------+----------------------------------+
+| 0x0C01 | 0x10 | RW | T |Run vCPU Output Buffer: |
+| | | | | |
+| | | | |- 0x0 Addr of buffer |
+| | | | |- 0x8 Buffer Size. |
++--------+-------+----+--------+----------------------------------+
+| 0x0C02 | 0x08 | RW | T | vCPU VPA Address |
++--------+-------+----+--------+----------------------------------+
+| 0x0C03-| | | | Reserved |
+| 0x0FFF | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x1000-| 0x08 | RW | T | GPR 0-31 |
+| 0x101F | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x1020 | 0x08 | T | T | HDEC expiry TB |
++--------+-------+----+--------+----------------------------------+
+| 0x1021 | 0x08 | RW | T | NIA |
++--------+-------+----+--------+----------------------------------+
+| 0x1022 | 0x08 | RW | T | MSR |
++--------+-------+----+--------+----------------------------------+
+| 0x1023 | 0x08 | RW | T | LR |
++--------+-------+----+--------+----------------------------------+
+| 0x1024 | 0x08 | RW | T | XER |
++--------+-------+----+--------+----------------------------------+
+| 0x1025 | 0x08 | RW | T | CTR |
++--------+-------+----+--------+----------------------------------+
+| 0x1026 | 0x08 | RW | T | CFAR |
++--------+-------+----+--------+----------------------------------+
+| 0x1027 | 0x08 | RW | T | SRR0 |
++--------+-------+----+--------+----------------------------------+
+| 0x1028 | 0x08 | RW | T | SRR1 |
++--------+-------+----+--------+----------------------------------+
+| 0x1029 | 0x08 | RW | T | DAR |
++--------+-------+----+--------+----------------------------------+
+| 0x102A | 0x08 | RW | T | DEC expiry TB |
++--------+-------+----+--------+----------------------------------+
+| 0x102B | 0x08 | RW | T | VTB |
++--------+-------+----+--------+----------------------------------+
+| 0x102C | 0x08 | RW | T | LPCR |
++--------+-------+----+--------+----------------------------------+
+| 0x102D | 0x08 | RW | T | HFSCR |
++--------+-------+----+--------+----------------------------------+
+| 0x102E | 0x08 | RW | T | FSCR |
++--------+-------+----+--------+----------------------------------+
+| 0x102F | 0x08 | RW | T | FPSCR |
++--------+-------+----+--------+----------------------------------+
+| 0x1030 | 0x08 | RW | T | DAWR0 |
++--------+-------+----+--------+----------------------------------+
+| 0x1031 | 0x08 | RW | T | DAWR1 |
++--------+-------+----+--------+----------------------------------+
+| 0x1032 | 0x08 | RW | T | CIABR |
++--------+-------+----+--------+----------------------------------+
+| 0x1033 | 0x08 | RW | T | PURR |
++--------+-------+----+--------+----------------------------------+
+| 0x1034 | 0x08 | RW | T | SPURR |
++--------+-------+----+--------+----------------------------------+
+| 0x1035 | 0x08 | RW | T | IC |
++--------+-------+----+--------+----------------------------------+
+| 0x1036-| 0x08 | RW | T | SPRG 0-3 |
+| 0x1039 | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x103A | 0x08 | W | T | PPR |
++--------+-------+----+--------+----------------------------------+
+| 0x103B | 0x08 | RW | T | MMCR 0-3 |
+| 0x103E | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x103F | 0x08 | RW | T | MMCRA |
++--------+-------+----+--------+----------------------------------+
+| 0x1040 | 0x08 | RW | T | SIER |
++--------+-------+----+--------+----------------------------------+
+| 0x1041 | 0x08 | RW | T | SIER 2 |
++--------+-------+----+--------+----------------------------------+
+| 0x1042 | 0x08 | RW | T | SIER 3 |
++--------+-------+----+--------+----------------------------------+
+| 0x1043 | 0x08 | RW | T | BESCR |
++--------+-------+----+--------+----------------------------------+
+| 0x1044 | 0x08 | RW | T | EBBHR |
++--------+-------+----+--------+----------------------------------+
+| 0x1045 | 0x08 | RW | T | EBBRR |
++--------+-------+----+--------+----------------------------------+
+| 0x1046 | 0x08 | RW | T | AMR |
++--------+-------+----+--------+----------------------------------+
+| 0x1047 | 0x08 | RW | T | IAMR |
++--------+-------+----+--------+----------------------------------+
+| 0x1048 | 0x08 | RW | T | AMOR |
++--------+-------+----+--------+----------------------------------+
+| 0x1049 | 0x08 | RW | T | UAMOR |
++--------+-------+----+--------+----------------------------------+
+| 0x104A | 0x08 | RW | T | SDAR |
++--------+-------+----+--------+----------------------------------+
+| 0x104B | 0x08 | RW | T | SIAR |
++--------+-------+----+--------+----------------------------------+
+| 0x104C | 0x08 | RW | T | DSCR |
++--------+-------+----+--------+----------------------------------+
+| 0x104D | 0x08 | RW | T | TAR |
++--------+-------+----+--------+----------------------------------+
+| 0x104E | 0x08 | RW | T | DEXCR |
++--------+-------+----+--------+----------------------------------+
+| 0x104F | 0x08 | RW | T | HDEXCR |
++--------+-------+----+--------+----------------------------------+
+| 0x1050 | 0x08 | RW | T | HASHKEYR |
++--------+-------+----+--------+----------------------------------+
+| 0x1051 | 0x08 | RW | T | HASHPKEYR |
++--------+-------+----+--------+----------------------------------+
+| 0x1052 | 0x08 | RW | T | CTRL |
++--------+-------+----+--------+----------------------------------+
+| 0x1053-| | | | Reserved |
+| 0x1FFF | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x2000 | 0x04 | RW | T | CR |
++--------+-------+----+--------+----------------------------------+
+| 0x2001 | 0x04 | RW | T | PIDR |
++--------+-------+----+--------+----------------------------------+
+| 0x2002 | 0x04 | RW | T | DSISR |
++--------+-------+----+--------+----------------------------------+
+| 0x2003 | 0x04 | RW | T | VSCR |
++--------+-------+----+--------+----------------------------------+
+| 0x2004 | 0x04 | RW | T | VRSAVE |
++--------+-------+----+--------+----------------------------------+
+| 0x2005 | 0x04 | RW | T | DAWRX0 |
++--------+-------+----+--------+----------------------------------+
+| 0x2006 | 0x04 | RW | T | DAWRX1 |
++--------+-------+----+--------+----------------------------------+
+| 0x2007-| 0x04 | RW | T | PMC 1-6 |
+| 0x200c | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x200D | 0x04 | RW | T | WORT |
++--------+-------+----+--------+----------------------------------+
+| 0x200E | 0x04 | RW | T | PSPB |
++--------+-------+----+--------+----------------------------------+
+| 0x200F-| | | | Reserved |
+| 0x2FFF | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x3000-| 0x10 | RW | T | VSR 0-63 |
+| 0x303F | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0x3040-| | | | Reserved |
+| 0xEFFF | | | | |
++--------+-------+----+--------+----------------------------------+
+| 0xF000 | 0x08 | R | T | HDAR |
++--------+-------+----+--------+----------------------------------+
+| 0xF001 | 0x04 | R | T | HDSISR |
++--------+-------+----+--------+----------------------------------+
+| 0xF002 | 0x04 | R | T | HEIR |
++--------+-------+----+--------+----------------------------------+
+| 0xF003 | 0x08 | R | T | ASDR |
++--------+-------+----+--------+----------------------------------+
+
+Miscellaneous info
+==================
+
+State not in ptregs/hvregs
+--------------------------
+
+In the v1 API, some state is not in the ptregs/hvstate. This includes
+the vector register and some SPRs. For the L1 to set this state for
+the L2, the L1 loads up these hardware registers before the
+h_enter_nested() call and the L0 ensures they end up as the L2 state
+(by not touching them).
+
+The v2 API removes this and explicitly sets this state via the GSB.
+
+L1 Implementation details: Caching state
+----------------------------------------
+
+In the v1 API, all state is sent from the L1 to the L0 and vice versa
+on every h_enter_nested() hcall. If the L0 is not currently running
+any L2s, the L0 has no state information about them. The only
+exception to this is the location of the partition table, registered
+via h_set_partition_table().
+
+The v2 API changes this so that the L0 retains the L2 state even when
+it's vCPUs are no longer running. This means that the L1 only needs to
+communicate with the L0 about L2 state when it needs to modify the L2
+state, or when it's value is out of date. This provides an opportunity
+for performance optimisation.
+
+When a vCPU exits from a H_GUEST_RUN_VCPU() call, the L1 internally
+marks all L2 state as invalid. This means that if the L1 wants to know
+the L2 state (say via a kvm_get_one_reg() call), it needs to call
+H_GUEST_GET_STATE() to get that state. Once it's read, it's marked as
+valid in L1 until the L2 is run again.
+
+Also, when an L1 modifies L2 vcpu state, it doesn't need to write it
+to the L0 until that L2 vcpu runs again. Hence when the L1 updates
+state (say via a kvm_set_one_reg() call), it writes to an internal L1
+copy and only flushes this copy to the L0 when the L2 runs again via
+the H_GUEST_VCPU_RUN() input buffer.
+
+This lazy updating of state by the L1 avoids unnecessary
+H_GUEST_{G|S}ET_STATE() calls.
+
+References
+==========
+
+For more details, please refer:
+
+[1] Linux Kernel documentation (upstream documentation commit):
+
+commit 476652297f94a2e5e5ef29e734b0da37ade94110
+Author: Michael Neuling <mikey@neuling.org>
+Date: Thu Sep 14 13:06:00 2023 +1000
+
+ docs: powerpc: Document nested KVM on POWER
+
+ Document support for nested KVM on POWER using the existing API as well
+ as the new PAPR API. This includes the new HCALL interface and how it
+ used by KVM.
+
+ Signed-off-by: Michael Neuling <mikey@neuling.org>
+ Signed-off-by: Jordan Niethe <jniethe5@gmail.com>
+ Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
+ Link: https://msgid.link/20230914030600.16993-12-jniethe5@gmail.com
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 05/15] spapr: nested: Document Nested PAPR API
2024-02-20 8:35 ` [PATCH v4 05/15] spapr: nested: Document Nested PAPR API Harsh Prateek Bora
@ 2024-02-27 9:29 ` Nicholas Piggin
2024-02-27 9:31 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 9:29 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
> Adding initial documentation about Nested PAPR API to describe the set
> of APIs and its usage. Also talks about the Guest State Buffer elements
> and it's format which is used between L0/L1 to communicate L2 state.
>
> Signed-off-by: Michael Neuling <mikey@neuling.org>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
v2 is upstream in Linux now, I suppose you could reference that too?
Otherwise looks okay
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> docs/devel/nested-papr.txt | 514 +++++++++++++++++++++++++++++++++++++
> 1 file changed, 514 insertions(+)
> create mode 100644 docs/devel/nested-papr.txt
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v4 05/15] spapr: nested: Document Nested PAPR API
2024-02-27 9:29 ` Nicholas Piggin
@ 2024-02-27 9:31 ` Harsh Prateek Bora
2024-02-27 10:39 ` Nicholas Piggin
0 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-27 9:31 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 14:59, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
>> Adding initial documentation about Nested PAPR API to describe the set
>> of APIs and its usage. Also talks about the Guest State Buffer elements
>> and it's format which is used between L0/L1 to communicate L2 state.
>>
>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>
> v2 is upstream in Linux now, I suppose you could reference that too?
>
Yes, upstream Linux commit is mentioned in the doc at the end.
> Otherwise looks okay
>
> Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Thanks
Harsh
>
>> ---
>> docs/devel/nested-papr.txt | 514 +++++++++++++++++++++++++++++++++++++
>> 1 file changed, 514 insertions(+)
>> create mode 100644 docs/devel/nested-papr.txt
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v4 05/15] spapr: nested: Document Nested PAPR API
2024-02-27 9:31 ` Harsh Prateek Bora
@ 2024-02-27 10:39 ` Nicholas Piggin
2024-02-29 5:46 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:39 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 27, 2024 at 7:31 PM AEST, Harsh Prateek Bora wrote:
>
>
> On 2/27/24 14:59, Nicholas Piggin wrote:
> > On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
> >> Adding initial documentation about Nested PAPR API to describe the set
> >> of APIs and its usage. Also talks about the Guest State Buffer elements
> >> and it's format which is used between L0/L1 to communicate L2 state.
> >>
> >> Signed-off-by: Michael Neuling <mikey@neuling.org>
> >> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> >
> > v2 is upstream in Linux now, I suppose you could reference that too?
> >
> Yes, upstream Linux commit is mentioned in the doc at the end.
The API doc commit is mentioned as a reference. I would expect something
following the comments under the Existing Nested-HV API heading for the
New PAPR API.
Oh, is it lifted directly from linux.git docs? Sigh, in that case never
mind, it's better to stick with them. Although could be just a link or
reference.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v4 05/15] spapr: nested: Document Nested PAPR API
2024-02-27 10:39 ` Nicholas Piggin
@ 2024-02-29 5:46 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-29 5:46 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 16:09, Nicholas Piggin wrote:
> On Tue Feb 27, 2024 at 7:31 PM AEST, Harsh Prateek Bora wrote:
>>
>>
>> On 2/27/24 14:59, Nicholas Piggin wrote:
>>> On Tue Feb 20, 2024 at 6:35 PM AEST, Harsh Prateek Bora wrote:
>>>> Adding initial documentation about Nested PAPR API to describe the set
>>>> of APIs and its usage. Also talks about the Guest State Buffer elements
>>>> and it's format which is used between L0/L1 to communicate L2 state.
>>>>
>>>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>>>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>>>
>>> v2 is upstream in Linux now, I suppose you could reference that too?
>>>
>> Yes, upstream Linux commit is mentioned in the doc at the end.
>
> The API doc commit is mentioned as a reference. I would expect something
> following the comments under the Existing Nested-HV API heading for the
> New PAPR API.
>
> Oh, is it lifted directly from linux.git docs? Sigh, in that case never
> mind, it's better to stick with them. Although could be just a link or
> reference.
>
Well, initially the documentation was floated across with both
kernel/qemu patches, and now we have the kernel side merged. Although, I
think it would be more appropriate to keep it in Qemu which actually
implements the L0 functionality and the related APIs, however, for now,
let's keep a single source of documentation and we can provide a link
after the brief intro about the two APIs.
regards,
Harsh
> Thanks,
> Nick
>
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 06/15] spapr: nested: Introduce H_GUEST_[GET|SET]_CAPABILITIES hcalls.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (4 preceding siblings ...)
2024-02-20 8:35 ` [PATCH v4 05/15] spapr: nested: Document Nested PAPR API Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-20 8:36 ` [PATCH v4 07/15] spapr: nested: Introduce H_GUEST_[CREATE|DELETE] hcalls Harsh Prateek Bora
` (8 subsequent siblings)
14 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Introduce the nested PAPR hcalls:
- H_GUEST_GET_CAPABILITIES which is used to query the capabilities
of the API and the L2 guests it provides.
- H_GUEST_SET_CAPABILITIES which is used to set the Guest API
capabilities that the Host Partition supports and may use.
[amachhiw: support for p9 compat mode and return register bug fixes]
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 6 +-
include/hw/ppc/spapr_nested.h | 12 ++++
hw/ppc/spapr_nested.c | 100 ++++++++++++++++++++++++++++++++++
3 files changed, 117 insertions(+), 1 deletion(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index 63e9d4c476..d745d487a1 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -364,6 +364,7 @@ struct SpaprMachineState {
#define H_NOOP -63
#define H_UNSUPPORTED -67
#define H_OVERLAP -68
+#define H_STATE -75
#define H_UNSUPPORTED_FLAG -256
#define H_MULTI_THREADS_ACTIVE -9005
@@ -583,8 +584,10 @@ struct SpaprMachineState {
#define H_RPT_INVALIDATE 0x448
#define H_SCM_FLUSH 0x44C
#define H_WATCHDOG 0x45C
+#define H_GUEST_GET_CAPABILITIES 0x460
+#define H_GUEST_SET_CAPABILITIES 0x464
-#define MAX_HCALL_OPCODE H_WATCHDOG
+#define MAX_HCALL_OPCODE H_GUEST_SET_CAPABILITIES
/* The hcalls above are standardized in PAPR and implemented by pHyp
* as well.
@@ -1029,5 +1032,6 @@ void spapr_vof_client_dt_finalize(SpaprMachineState *spapr, void *fdt);
void spapr_watchdog_init(SpaprMachineState *spapr);
void spapr_register_nested_hv(void);
void spapr_unregister_nested_hv(void);
+void spapr_register_nested_papr(void);
#endif /* HW_SPAPR_H */
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 3f07c81c3d..599373692b 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -7,8 +7,20 @@ typedef struct SpaprMachineStateNested {
uint64_t ptcr;
uint8_t api;
#define NESTED_API_KVM_HV 1
+ bool capabilities_set;
+ uint32_t pvr_base;
} SpaprMachineStateNested;
+/* Nested PAPR API related macros */
+#define H_GUEST_CAPABILITIES_COPY_MEM 0x8000000000000000
+#define H_GUEST_CAPABILITIES_P9_MODE 0x4000000000000000
+#define H_GUEST_CAPABILITIES_P10_MODE 0x2000000000000000
+#define H_GUEST_CAP_VALID_MASK (H_GUEST_CAPABILITIES_P10_MODE | \
+ H_GUEST_CAPABILITIES_P9_MODE)
+#define H_GUEST_CAP_COPY_MEM_BMAP 0
+#define H_GUEST_CAP_P9_MODE_BMAP 1
+#define H_GUEST_CAP_P10_MODE_BMAP 2
+
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
* New member must be added at the end.
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 9096dd96a4..012af27881 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -7,10 +7,12 @@
#include "hw/ppc/spapr_cpu_core.h"
#include "hw/ppc/spapr_nested.h"
#include "mmu-book3s-v3.h"
+#include "cpu-models.h"
void spapr_nested_init(SpaprMachineState *spapr)
{
spapr->nested.api = 0;
+ spapr->nested.capabilities_set = false;
}
uint8_t spapr_nested_api(SpaprMachineState *spapr)
@@ -426,6 +428,92 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
}
}
+static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ CPUPPCState *env = &cpu->env;
+ target_ulong flags = args[0];
+
+ if (flags) { /* don't handle any flags capabilities for now */
+ return H_PARAMETER;
+ }
+
+ /* P10 capabilities */
+ if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_10, 0,
+ spapr->max_compat_pvr)) {
+ env->gpr[4] |= H_GUEST_CAPABILITIES_P10_MODE;
+ }
+
+ /* P9 capabilities */
+ if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_00, 0,
+ spapr->max_compat_pvr)) {
+ env->gpr[4] |= H_GUEST_CAPABILITIES_P9_MODE;
+ }
+
+ return H_SUCCESS;
+}
+
+static target_ulong h_guest_set_capabilities(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ CPUPPCState *env = &cpu->env;
+ target_ulong flags = args[0];
+ target_ulong capabilities = args[1];
+ env->gpr[4] = 0;
+
+ if (flags) { /* don't handle any flags capabilities for now */
+ return H_PARAMETER;
+ }
+
+ if (capabilities & H_GUEST_CAPABILITIES_COPY_MEM) {
+ env->gpr[4] = 1;
+ return H_P2; /* isn't supported */
+ }
+
+ /* If there are no capabilities configured, set the R5 to the index of
+ * the first supported Power Processor Mode
+ */
+ if (!capabilities) {
+ env->gpr[4] = 1;
+
+ /* set R5 to the first supported Power Processor Mode */
+ if(ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_10, 0,
+ spapr->max_compat_pvr)) {
+ env->gpr[5] = H_GUEST_CAP_P10_MODE_BMAP;
+ }
+ else if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_00, 0,
+ spapr->max_compat_pvr)) {
+ env->gpr[5] = H_GUEST_CAP_P9_MODE_BMAP;
+ }
+
+ return H_P2;
+ }
+
+ /* If an invalid capability is set, R5 should contain the index of the
+ * invalid capability bit
+ */
+ if (capabilities & ~H_GUEST_CAP_VALID_MASK) {
+ env->gpr[4] = 1;
+
+ /* Set R5 to the index of the invalid capability */
+ env->gpr[5] = 63 - ctz64(capabilities);
+
+ return H_P2;
+ }
+
+ if (!spapr->nested.capabilities_set) {
+ spapr->nested.capabilities_set = true;
+ spapr->nested.pvr_base = env->spr[SPR_PVR];
+ return H_SUCCESS;
+ } else {
+ return H_STATE;
+ }
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
@@ -441,6 +529,13 @@ void spapr_unregister_nested_hv(void)
spapr_unregister_hypercall(KVMPPC_H_TLB_INVALIDATE);
spapr_unregister_hypercall(KVMPPC_H_COPY_TOFROM_GUEST);
}
+
+void spapr_register_nested_papr(void)
+{
+ spapr_register_hypercall(H_GUEST_GET_CAPABILITIES, h_guest_get_capabilities);
+ spapr_register_hypercall(H_GUEST_SET_CAPABILITIES, h_guest_set_capabilities);
+}
+
#else
void spapr_exit_nested(PowerPCCPU *cpu, int excp)
{
@@ -462,4 +557,9 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
{
return false;
}
+
+void spapr_register_nested_papr(void)
+{
+ /* DO NOTHING */
+}
#endif
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* [PATCH v4 07/15] spapr: nested: Introduce H_GUEST_[CREATE|DELETE] hcalls.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (5 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 06/15] spapr: nested: Introduce H_GUEST_[GET|SET]_CAPABILITIES hcalls Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-20 8:36 ` [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall Harsh Prateek Bora
` (7 subsequent siblings)
14 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Introduce the nested PAPR hcalls:
- H_GUEST_CREATE which is used to create and allocate resources for
nested guest being created.
- H_GUEST_DELETE which is used to delete and deallocate resources
for the nested guest being deleted. It also supports deleting all nested
guests at once using a deleteAll flag.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 4 +-
include/hw/ppc/spapr_nested.h | 7 +++
hw/ppc/spapr_nested.c | 101 ++++++++++++++++++++++++++++++++++
3 files changed, 111 insertions(+), 1 deletion(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index d745d487a1..c4a79a1785 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -586,8 +586,10 @@ struct SpaprMachineState {
#define H_WATCHDOG 0x45C
#define H_GUEST_GET_CAPABILITIES 0x460
#define H_GUEST_SET_CAPABILITIES 0x464
+#define H_GUEST_CREATE 0x470
+#define H_GUEST_DELETE 0x488
-#define MAX_HCALL_OPCODE H_GUEST_SET_CAPABILITIES
+#define MAX_HCALL_OPCODE H_GUEST_DELETE
/* The hcalls above are standardized in PAPR and implemented by pHyp
* as well.
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 599373692b..f282479275 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -9,8 +9,13 @@ typedef struct SpaprMachineStateNested {
#define NESTED_API_KVM_HV 1
bool capabilities_set;
uint32_t pvr_base;
+ GHashTable *guests;
} SpaprMachineStateNested;
+typedef struct SpaprMachineStateNestedGuest {
+ uint32_t pvr_logical;
+} SpaprMachineStateNestedGuest;
+
/* Nested PAPR API related macros */
#define H_GUEST_CAPABILITIES_COPY_MEM 0x8000000000000000
#define H_GUEST_CAPABILITIES_P9_MODE 0x4000000000000000
@@ -20,6 +25,8 @@ typedef struct SpaprMachineStateNested {
#define H_GUEST_CAP_COPY_MEM_BMAP 0
#define H_GUEST_CAP_P9_MODE_BMAP 1
#define H_GUEST_CAP_P10_MODE_BMAP 2
+#define PAPR_NESTED_GUEST_MAX 4096
+#define H_GUEST_DELETE_ALL_FLAG 0x8000000000000000ULL
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 012af27881..09c4a35908 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -514,6 +514,105 @@ static target_ulong h_guest_set_capabilities(PowerPCCPU *cpu,
}
}
+static void
+destroy_guest_helper(gpointer value)
+{
+ struct SpaprMachineStateNestedGuest *guest = value;
+ g_free(guest);
+}
+
+static target_ulong h_guest_create(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ CPUPPCState *env = &cpu->env;
+ target_ulong flags = args[0];
+ target_ulong continue_token = args[1];
+ uint64_t guestid;
+ int nguests = 0;
+ struct SpaprMachineStateNestedGuest *guest;
+
+ if (flags) { /* don't handle any flags for now */
+ return H_UNSUPPORTED_FLAG;
+ }
+
+ if (continue_token != -1) {
+ return H_P2;
+ }
+
+ if (!spapr->nested.capabilities_set) {
+ return H_STATE;
+ }
+
+ if (!spapr->nested.guests) {
+ spapr->nested.guests = g_hash_table_new_full(NULL,
+ NULL,
+ NULL,
+ destroy_guest_helper);
+ }
+
+ nguests = g_hash_table_size(spapr->nested.guests);
+
+ if (nguests == PAPR_NESTED_GUEST_MAX) {
+ return H_NO_MEM;
+ }
+
+ /* Lookup for available guestid */
+ for (guestid = 1; guestid < PAPR_NESTED_GUEST_MAX; guestid++) {
+ if (!(g_hash_table_lookup(spapr->nested.guests,
+ GINT_TO_POINTER(guestid)))) {
+ break;
+ }
+ }
+
+ if (guestid == PAPR_NESTED_GUEST_MAX) {
+ return H_NO_MEM;
+ }
+
+ guest = g_try_new0(struct SpaprMachineStateNestedGuest, 1);
+ if (!guest) {
+ return H_NO_MEM;
+ }
+
+ guest->pvr_logical = spapr->nested.pvr_base;
+ g_hash_table_insert(spapr->nested.guests, GINT_TO_POINTER(guestid), guest);
+ env->gpr[4] = guestid;
+
+ return H_SUCCESS;
+}
+
+static target_ulong h_guest_delete(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ target_ulong flags = args[0];
+ target_ulong guestid = args[1];
+ struct SpaprMachineStateNestedGuest *guest;
+
+ /*
+ * handle flag deleteAllGuests, if set:
+ * guestid is ignored and all guests are deleted
+ *
+ */
+ if (flags & ~H_GUEST_DELETE_ALL_FLAG) {
+ return H_UNSUPPORTED_FLAG; /* other flag bits reserved */
+ } else if (flags & H_GUEST_DELETE_ALL_FLAG) {
+ g_hash_table_destroy(spapr->nested.guests);
+ return H_SUCCESS;
+ }
+
+ guest = g_hash_table_lookup(spapr->nested.guests, GINT_TO_POINTER(guestid));
+ if (!guest) {
+ return H_P2;
+ }
+
+ g_hash_table_remove(spapr->nested.guests, GINT_TO_POINTER(guestid));
+
+ return H_SUCCESS;
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
@@ -534,6 +633,8 @@ void spapr_register_nested_papr(void)
{
spapr_register_hypercall(H_GUEST_GET_CAPABILITIES, h_guest_get_capabilities);
spapr_register_hypercall(H_GUEST_SET_CAPABILITIES, h_guest_set_capabilities);
+ spapr_register_hypercall(H_GUEST_CREATE , h_guest_create);
+ spapr_register_hypercall(H_GUEST_DELETE , h_guest_delete);
}
#else
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (6 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 07/15] spapr: nested: Introduce H_GUEST_[CREATE|DELETE] hcalls Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 9:51 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API Harsh Prateek Bora
` (6 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Introduce the nested PAPR hcall H_GUEST_CREATE_VCPU which is used to
create and initialize the specified VCPU resource for the previously
created guest. Each guest can have multiple VCPUs upto max 2048.
All VCPUs for a guest gets deallocated on guest delete.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 2 +
include/hw/ppc/spapr_nested.h | 10 ++++
hw/ppc/spapr_nested.c | 96 +++++++++++++++++++++++++++++++++++
3 files changed, 108 insertions(+)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index c4a79a1785..82b077bdd2 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -365,6 +365,7 @@ struct SpaprMachineState {
#define H_UNSUPPORTED -67
#define H_OVERLAP -68
#define H_STATE -75
+#define H_IN_USE -77
#define H_UNSUPPORTED_FLAG -256
#define H_MULTI_THREADS_ACTIVE -9005
@@ -587,6 +588,7 @@ struct SpaprMachineState {
#define H_GUEST_GET_CAPABILITIES 0x460
#define H_GUEST_SET_CAPABILITIES 0x464
#define H_GUEST_CREATE 0x470
+#define H_GUEST_CREATE_VCPU 0x474
#define H_GUEST_DELETE 0x488
#define MAX_HCALL_OPCODE H_GUEST_DELETE
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index f282479275..24e87bca08 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -14,6 +14,8 @@ typedef struct SpaprMachineStateNested {
typedef struct SpaprMachineStateNestedGuest {
uint32_t pvr_logical;
+ unsigned long vcpus;
+ struct SpaprMachineStateNestedGuestVcpu *vcpu;
} SpaprMachineStateNestedGuest;
/* Nested PAPR API related macros */
@@ -27,6 +29,7 @@ typedef struct SpaprMachineStateNestedGuest {
#define H_GUEST_CAP_P10_MODE_BMAP 2
#define PAPR_NESTED_GUEST_MAX 4096
#define H_GUEST_DELETE_ALL_FLAG 0x8000000000000000ULL
+#define PAPR_NESTED_GUEST_VCPU_MAX 2048
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
@@ -118,8 +121,15 @@ struct nested_ppc_state {
uint64_t ppr;
int64_t tb_offset;
+ /* Nested PAPR API */
+ uint64_t pvr;
};
+typedef struct SpaprMachineStateNestedGuestVcpu {
+ bool enabled;
+ struct nested_ppc_state state;
+} SpaprMachineStateNestedGuestVcpu;
+
void spapr_exit_nested(PowerPCCPU *cpu, int excp);
typedef struct SpaprMachineState SpaprMachineState;
bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 09c4a35908..3cc704adda 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -428,6 +428,41 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
}
}
+static
+SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
+ target_ulong guestid)
+{
+ SpaprMachineStateNestedGuest *guest;
+
+ guest = g_hash_table_lookup(spapr->nested.guests, GINT_TO_POINTER(guestid));
+ return guest;
+}
+
+static bool spapr_nested_vcpu_check(SpaprMachineStateNestedGuest *guest,
+ target_ulong vcpuid)
+{
+ struct SpaprMachineStateNestedGuestVcpu *vcpu;
+ /*
+ * Perform sanity checks for the provided vcpuid of a guest.
+ * For now, ensure its valid, allocated and enabled for use.
+ */
+
+ if (vcpuid >= PAPR_NESTED_GUEST_VCPU_MAX) {
+ return false;
+ }
+
+ if (!(vcpuid < guest->vcpus)) {
+ return false;
+ }
+
+ vcpu = &guest->vcpu[vcpuid];
+ if (!vcpu->enabled) {
+ return false;
+ }
+
+ return true;
+}
+
static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
SpaprMachineState *spapr,
target_ulong opcode,
@@ -518,6 +553,7 @@ static void
destroy_guest_helper(gpointer value)
{
struct SpaprMachineStateNestedGuest *guest = value;
+ g_free(guest->vcpu);
g_free(guest);
}
@@ -613,6 +649,65 @@ static target_ulong h_guest_delete(PowerPCCPU *cpu,
return H_SUCCESS;
}
+static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ CPUPPCState *env = &cpu->env;
+ struct nested_ppc_state *l2_state;
+ target_ulong flags = args[0];
+ target_ulong guestid = args[1];
+ target_ulong vcpuid = args[2];
+ SpaprMachineStateNestedGuest *guest;
+
+ if (flags) { /* don't handle any flags for now */
+ return H_UNSUPPORTED_FLAG;
+ }
+
+ guest = spapr_get_nested_guest(spapr, guestid);
+ if (!guest) {
+ return H_P2;
+ }
+
+ if (vcpuid < guest->vcpus) {
+ return H_IN_USE;
+ }
+
+ if (guest->vcpus >= PAPR_NESTED_GUEST_VCPU_MAX) {
+ return H_P3;
+ }
+
+ if (guest->vcpus) {
+ SpaprMachineStateNestedGuestVcpu *vcpus;
+ vcpus = g_try_renew(struct SpaprMachineStateNestedGuestVcpu,
+ guest->vcpu,
+ guest->vcpus + 1);
+ if (!vcpus) {
+ return H_NO_MEM;
+ }
+ memset(&vcpus[guest->vcpus], 0,
+ sizeof(SpaprMachineStateNestedGuestVcpu));
+ guest->vcpu = vcpus;
+ } else {
+ guest->vcpu = g_try_new0(SpaprMachineStateNestedGuestVcpu, 1);
+ if (guest->vcpu == NULL) {
+ return H_NO_MEM;
+ }
+ }
+ l2_state = &guest->vcpu[guest->vcpus].state;
+ guest->vcpus++;
+ assert(vcpuid < guest->vcpus); /* linear vcpuid allocation only */
+ /* Set L1 PVR as L2 default */
+ l2_state->pvr = env->spr[SPR_PVR];
+ guest->vcpu[vcpuid].enabled = true;
+
+ if (!spapr_nested_vcpu_check(guest, vcpuid)) {
+ return H_PARAMETER;
+ }
+ return H_SUCCESS;
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
@@ -635,6 +730,7 @@ void spapr_register_nested_papr(void)
spapr_register_hypercall(H_GUEST_SET_CAPABILITIES, h_guest_set_capabilities);
spapr_register_hypercall(H_GUEST_CREATE , h_guest_create);
spapr_register_hypercall(H_GUEST_DELETE , h_guest_delete);
+ spapr_register_hypercall(H_GUEST_CREATE_VCPU , h_guest_create_vcpu);
}
#else
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall.
2024-02-20 8:36 ` [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall Harsh Prateek Bora
@ 2024-02-27 9:51 ` Nicholas Piggin
2024-02-29 9:39 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 9:51 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> Introduce the nested PAPR hcall H_GUEST_CREATE_VCPU which is used to
> create and initialize the specified VCPU resource for the previously
> created guest. Each guest can have multiple VCPUs upto max 2048.
> All VCPUs for a guest gets deallocated on guest delete.
>
> Signed-off-by: Michael Neuling <mikey@neuling.org>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> include/hw/ppc/spapr.h | 2 +
> include/hw/ppc/spapr_nested.h | 10 ++++
> hw/ppc/spapr_nested.c | 96 +++++++++++++++++++++++++++++++++++
> 3 files changed, 108 insertions(+)
>
> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> index c4a79a1785..82b077bdd2 100644
> --- a/include/hw/ppc/spapr.h
> +++ b/include/hw/ppc/spapr.h
> @@ -365,6 +365,7 @@ struct SpaprMachineState {
> #define H_UNSUPPORTED -67
> #define H_OVERLAP -68
> #define H_STATE -75
> +#define H_IN_USE -77
> #define H_UNSUPPORTED_FLAG -256
> #define H_MULTI_THREADS_ACTIVE -9005
>
> @@ -587,6 +588,7 @@ struct SpaprMachineState {
> #define H_GUEST_GET_CAPABILITIES 0x460
> #define H_GUEST_SET_CAPABILITIES 0x464
> #define H_GUEST_CREATE 0x470
> +#define H_GUEST_CREATE_VCPU 0x474
> #define H_GUEST_DELETE 0x488
>
> #define MAX_HCALL_OPCODE H_GUEST_DELETE
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index f282479275..24e87bca08 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -14,6 +14,8 @@ typedef struct SpaprMachineStateNested {
>
> typedef struct SpaprMachineStateNestedGuest {
> uint32_t pvr_logical;
> + unsigned long vcpus;
> + struct SpaprMachineStateNestedGuestVcpu *vcpu;
> } SpaprMachineStateNestedGuest;
>
> /* Nested PAPR API related macros */
> @@ -27,6 +29,7 @@ typedef struct SpaprMachineStateNestedGuest {
> #define H_GUEST_CAP_P10_MODE_BMAP 2
> #define PAPR_NESTED_GUEST_MAX 4096
> #define H_GUEST_DELETE_ALL_FLAG 0x8000000000000000ULL
> +#define PAPR_NESTED_GUEST_VCPU_MAX 2048
>
> /*
> * Register state for entering a nested guest with H_ENTER_NESTED.
> @@ -118,8 +121,15 @@ struct nested_ppc_state {
> uint64_t ppr;
>
> int64_t tb_offset;
> + /* Nested PAPR API */
> + uint64_t pvr;
> };
>
> +typedef struct SpaprMachineStateNestedGuestVcpu {
> + bool enabled;
> + struct nested_ppc_state state;
> +} SpaprMachineStateNestedGuestVcpu;
> +
> void spapr_exit_nested(PowerPCCPU *cpu, int excp);
> typedef struct SpaprMachineState SpaprMachineState;
> bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index 09c4a35908..3cc704adda 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -428,6 +428,41 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
> }
> }
>
> +static
> +SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
> + target_ulong guestid)
> +{
> + SpaprMachineStateNestedGuest *guest;
> +
> + guest = g_hash_table_lookup(spapr->nested.guests, GINT_TO_POINTER(guestid));
> + return guest;
> +}
> +
> +static bool spapr_nested_vcpu_check(SpaprMachineStateNestedGuest *guest,
> + target_ulong vcpuid)
> +{
> + struct SpaprMachineStateNestedGuestVcpu *vcpu;
> + /*
> + * Perform sanity checks for the provided vcpuid of a guest.
> + * For now, ensure its valid, allocated and enabled for use.
> + */
> +
> + if (vcpuid >= PAPR_NESTED_GUEST_VCPU_MAX) {
> + return false;
> + }
> +
> + if (!(vcpuid < guest->vcpus)) {
> + return false;
> + }
> +
> + vcpu = &guest->vcpu[vcpuid];
> + if (!vcpu->enabled) {
> + return false;
> + }
> +
> + return true;
> +}
> +
> static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
> SpaprMachineState *spapr,
> target_ulong opcode,
> @@ -518,6 +553,7 @@ static void
> destroy_guest_helper(gpointer value)
> {
> struct SpaprMachineStateNestedGuest *guest = value;
> + g_free(guest->vcpu);
> g_free(guest);
> }
>
> @@ -613,6 +649,65 @@ static target_ulong h_guest_delete(PowerPCCPU *cpu,
> return H_SUCCESS;
> }
>
> +static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
> + SpaprMachineState *spapr,
> + target_ulong opcode,
> + target_ulong *args)
> +{
> + CPUPPCState *env = &cpu->env;
> + struct nested_ppc_state *l2_state;
> + target_ulong flags = args[0];
> + target_ulong guestid = args[1];
> + target_ulong vcpuid = args[2];
> + SpaprMachineStateNestedGuest *guest;
> +
> + if (flags) { /* don't handle any flags for now */
> + return H_UNSUPPORTED_FLAG;
> + }
> +
> + guest = spapr_get_nested_guest(spapr, guestid);
> + if (!guest) {
> + return H_P2;
> + }
> +
> + if (vcpuid < guest->vcpus) {
> + return H_IN_USE;
> + }
Linear allocation isn't really a constraint of the API right? I
would add an UNIMP log message to say what the problem is otherwise
hypervisor developer might struggle to understand the problem.
> +
> + if (guest->vcpus >= PAPR_NESTED_GUEST_VCPU_MAX) {
> + return H_P3;
> + }
> +
> + if (guest->vcpus) {
> + SpaprMachineStateNestedGuestVcpu *vcpus;
> + vcpus = g_try_renew(struct SpaprMachineStateNestedGuestVcpu,
> + guest->vcpu,
> + guest->vcpus + 1);
> + if (!vcpus) {
> + return H_NO_MEM;
> + }
> + memset(&vcpus[guest->vcpus], 0,
> + sizeof(SpaprMachineStateNestedGuestVcpu));
> + guest->vcpu = vcpus;
> + } else {
> + guest->vcpu = g_try_new0(SpaprMachineStateNestedGuestVcpu, 1);
> + if (guest->vcpu == NULL) {
> + return H_NO_MEM;
> + }
> + }
g_try_renew works with NULL AFAIKS, so no need for the branch. I would
also create a local variable for the new nested guest vcpu created
here so you only have to index it once.
> + l2_state = &guest->vcpu[guest->vcpus].state;
> + guest->vcpus++;
> + assert(vcpuid < guest->vcpus); /* linear vcpuid allocation only */
Target can trigger this assert if using a smaller vcpu id number than
already allocated? I would check above that it is exactly equal to
vcpus, and remove it from here.
> + /* Set L1 PVR as L2 default */
> + l2_state->pvr = env->spr[SPR_PVR];
Why is this here and not in H_GUEST_CREATE? I think you can use pcc->pvr
for this?
> + guest->vcpu[vcpuid].enabled = true;
> +
> + if (!spapr_nested_vcpu_check(guest, vcpuid)) {
> + return H_PARAMETER;
> + }
This doesn't clean up on failure. Just remove "sanity" checks if they
are already checked in the same function. Any useful ones should be
properly hanlded or done before cleanup is needed.
If you're respinning could you call vcpus nr_vcpus, then call vcpu
(the array of vcpus) vcpus.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall.
2024-02-27 9:51 ` Nicholas Piggin
@ 2024-02-29 9:39 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-29 9:39 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 15:21, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> Introduce the nested PAPR hcall H_GUEST_CREATE_VCPU which is used to
>> create and initialize the specified VCPU resource for the previously
>> created guest. Each guest can have multiple VCPUs upto max 2048.
>> All VCPUs for a guest gets deallocated on guest delete.
>>
>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> include/hw/ppc/spapr.h | 2 +
>> include/hw/ppc/spapr_nested.h | 10 ++++
>> hw/ppc/spapr_nested.c | 96 +++++++++++++++++++++++++++++++++++
>> 3 files changed, 108 insertions(+)
>>
>> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
>> index c4a79a1785..82b077bdd2 100644
>> --- a/include/hw/ppc/spapr.h
>> +++ b/include/hw/ppc/spapr.h
>> @@ -365,6 +365,7 @@ struct SpaprMachineState {
>> #define H_UNSUPPORTED -67
>> #define H_OVERLAP -68
>> #define H_STATE -75
>> +#define H_IN_USE -77
>> #define H_UNSUPPORTED_FLAG -256
>> #define H_MULTI_THREADS_ACTIVE -9005
>>
>> @@ -587,6 +588,7 @@ struct SpaprMachineState {
>> #define H_GUEST_GET_CAPABILITIES 0x460
>> #define H_GUEST_SET_CAPABILITIES 0x464
>> #define H_GUEST_CREATE 0x470
>> +#define H_GUEST_CREATE_VCPU 0x474
>> #define H_GUEST_DELETE 0x488
>>
>> #define MAX_HCALL_OPCODE H_GUEST_DELETE
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index f282479275..24e87bca08 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -14,6 +14,8 @@ typedef struct SpaprMachineStateNested {
>>
>> typedef struct SpaprMachineStateNestedGuest {
>> uint32_t pvr_logical;
>> + unsigned long vcpus;
>> + struct SpaprMachineStateNestedGuestVcpu *vcpu;
>> } SpaprMachineStateNestedGuest;
>>
>> /* Nested PAPR API related macros */
>> @@ -27,6 +29,7 @@ typedef struct SpaprMachineStateNestedGuest {
>> #define H_GUEST_CAP_P10_MODE_BMAP 2
>> #define PAPR_NESTED_GUEST_MAX 4096
>> #define H_GUEST_DELETE_ALL_FLAG 0x8000000000000000ULL
>> +#define PAPR_NESTED_GUEST_VCPU_MAX 2048
>>
>> /*
>> * Register state for entering a nested guest with H_ENTER_NESTED.
>> @@ -118,8 +121,15 @@ struct nested_ppc_state {
>> uint64_t ppr;
>>
>> int64_t tb_offset;
>> + /* Nested PAPR API */
>> + uint64_t pvr;
>> };
>>
>> +typedef struct SpaprMachineStateNestedGuestVcpu {
>> + bool enabled;
>> + struct nested_ppc_state state;
>> +} SpaprMachineStateNestedGuestVcpu;
>> +
>> void spapr_exit_nested(PowerPCCPU *cpu, int excp);
>> typedef struct SpaprMachineState SpaprMachineState;
>> bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index 09c4a35908..3cc704adda 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -428,6 +428,41 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
>> }
>> }
>>
>> +static
>> +SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
>> + target_ulong guestid)
>> +{
>> + SpaprMachineStateNestedGuest *guest;
>> +
>> + guest = g_hash_table_lookup(spapr->nested.guests, GINT_TO_POINTER(guestid));
>> + return guest;
>> +}
>> +
>> +static bool spapr_nested_vcpu_check(SpaprMachineStateNestedGuest *guest,
>> + target_ulong vcpuid)
>> +{
>> + struct SpaprMachineStateNestedGuestVcpu *vcpu;
>> + /*
>> + * Perform sanity checks for the provided vcpuid of a guest.
>> + * For now, ensure its valid, allocated and enabled for use.
>> + */
>> +
>> + if (vcpuid >= PAPR_NESTED_GUEST_VCPU_MAX) {
>> + return false;
>> + }
>> +
>> + if (!(vcpuid < guest->vcpus)) {
>> + return false;
>> + }
>> +
>> + vcpu = &guest->vcpu[vcpuid];
>> + if (!vcpu->enabled) {
>> + return false;
>> + }
>> +
>> + return true;
>> +}
>> +
>> static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
>> SpaprMachineState *spapr,
>> target_ulong opcode,
>> @@ -518,6 +553,7 @@ static void
>> destroy_guest_helper(gpointer value)
>> {
>> struct SpaprMachineStateNestedGuest *guest = value;
>> + g_free(guest->vcpu);
>> g_free(guest);
>> }
>>
>> @@ -613,6 +649,65 @@ static target_ulong h_guest_delete(PowerPCCPU *cpu,
>> return H_SUCCESS;
>> }
>>
>> +static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
>> + SpaprMachineState *spapr,
>> + target_ulong opcode,
>> + target_ulong *args)
>> +{
>> + CPUPPCState *env = &cpu->env;
>> + struct nested_ppc_state *l2_state;
>> + target_ulong flags = args[0];
>> + target_ulong guestid = args[1];
>> + target_ulong vcpuid = args[2];
>> + SpaprMachineStateNestedGuest *guest;
>> +
>> + if (flags) { /* don't handle any flags for now */
>> + return H_UNSUPPORTED_FLAG;
>> + }
>> +
>> + guest = spapr_get_nested_guest(spapr, guestid);
>> + if (!guest) {
>> + return H_P2;
>> + }
>> +
>> + if (vcpuid < guest->vcpus) {
>> + return H_IN_USE;
>> + }
>
> Linear allocation isn't really a constraint of the API right? I
> would add an UNIMP log message to say what the problem is otherwise
> hypervisor developer might struggle to understand the problem.
>
Sure, will add an UNIMP log msg and move the below assert up here.
>> +
>> + if (guest->vcpus >= PAPR_NESTED_GUEST_VCPU_MAX) {
>> + return H_P3;
>> + }
>> +
>> + if (guest->vcpus) {
>> + SpaprMachineStateNestedGuestVcpu *vcpus;
>> + vcpus = g_try_renew(struct SpaprMachineStateNestedGuestVcpu,
>> + guest->vcpu,
>> + guest->vcpus + 1);
>> + if (!vcpus) {
>> + return H_NO_MEM;
>> + }
>> + memset(&vcpus[guest->vcpus], 0,
>> + sizeof(SpaprMachineStateNestedGuestVcpu));
>> + guest->vcpu = vcpus;
>> + } else {
>> + guest->vcpu = g_try_new0(SpaprMachineStateNestedGuestVcpu, 1);
>> + if (guest->vcpu == NULL) {
>> + return H_NO_MEM;
>> + }
>> + }
>
> g_try_renew works with NULL AFAIKS, so no need for the branch. I would
> also create a local variable for the new nested guest vcpu created
> here so you only have to index it once.
>
Ok, will update.
>> + l2_state = &guest->vcpu[guest->vcpus].state;
>> + guest->vcpus++;
>> + assert(vcpuid < guest->vcpus); /* linear vcpuid allocation only */
>
> Target can trigger this assert if using a smaller vcpu id number than
> already allocated? I would check above that it is exactly equal to
> vcpus, and remove it from here.
Moving up as suggested.
>
>> + /* Set L1 PVR as L2 default */
>> + l2_state->pvr = env->spr[SPR_PVR];
>
> Why is this here and not in H_GUEST_CREATE? I think you can use pcc->pvr
> for this?
>
This is vcpu specific nested_ppc_state which needs to be initialized on
vcpu creation. We can assign it to spapr->nested.pvr_base as well.
>> + guest->vcpu[vcpuid].enabled = true;
>> +
>> + if (!spapr_nested_vcpu_check(guest, vcpuid)) {
>> + return H_PARAMETER;
>> + }
>
> This doesn't clean up on failure. Just remove "sanity" checks if they
> are already checked in the same function. Any useful ones should be
> properly hanlded or done before cleanup is needed.
We can actually remove this sanity check since it is already taken care
above and move this helper in a later patch where used.
>
> If you're respinning could you call vcpus nr_vcpus, then call vcpu
> (the array of vcpus) vcpus.
Sure, will update.
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (7 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 08/15] spapr: nested: Introduce H_GUEST_CREATE_VCPU hcall Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 9:59 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table Harsh Prateek Bora
` (5 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Currently, nested_ppc_state stores a certain set of registers and works
with nested_[load|save]_state() for state transfer as reqd for nested-hv API.
Extending these with additional registers state as reqd for nested PAPR API.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Suggested-by: Nicholas Piggin <npiggin@gmail.com>
---
include/hw/ppc/spapr_nested.h | 49 ++++++++++++++++
target/ppc/cpu.h | 2 +
hw/ppc/spapr_nested.c | 106 ++++++++++++++++++++++++++++++++++
3 files changed, 157 insertions(+)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 24e87bca08..a3b61eb79a 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -7,6 +7,7 @@ typedef struct SpaprMachineStateNested {
uint64_t ptcr;
uint8_t api;
#define NESTED_API_KVM_HV 1
+#define NESTED_API_PAPR 2
bool capabilities_set;
uint32_t pvr_base;
GHashTable *guests;
@@ -123,6 +124,54 @@ struct nested_ppc_state {
int64_t tb_offset;
/* Nested PAPR API */
uint64_t pvr;
+ uint64_t amor;
+ uint64_t dawr0;
+ uint64_t dawrx0;
+ uint64_t ciabr;
+ uint64_t purr;
+ uint64_t spurr;
+ uint64_t ic;
+ uint64_t vtb;
+ uint64_t hdar;
+ uint64_t hdsisr;
+ uint64_t heir;
+ uint64_t asdr;
+ uint64_t dawr1;
+ uint64_t dawrx1;
+ uint64_t dexcr;
+ uint64_t hdexcr;
+ uint64_t hashkeyr;
+ uint64_t hashpkeyr;
+ ppc_vsr_t vsr[64] QEMU_ALIGNED(16);
+ uint64_t ebbhr;
+ uint64_t tar;
+ uint64_t ebbrr;
+ uint64_t bescr;
+ uint64_t iamr;
+ uint64_t amr;
+ uint64_t uamor;
+ uint64_t dscr;
+ uint64_t fscr;
+ uint64_t pspb;
+ uint64_t ctrl;
+ uint64_t vrsave;
+ uint64_t dar;
+ uint64_t dsisr;
+ uint64_t pmc1;
+ uint64_t pmc2;
+ uint64_t pmc3;
+ uint64_t pmc4;
+ uint64_t pmc5;
+ uint64_t pmc6;
+ uint64_t mmcr0;
+ uint64_t mmcr1;
+ uint64_t mmcr2;
+ uint64_t mmcra;
+ uint64_t sdar;
+ uint64_t siar;
+ uint64_t sier;
+ uint32_t vscr;
+ uint64_t fpscr;
};
typedef struct SpaprMachineStateNestedGuestVcpu {
diff --git a/target/ppc/cpu.h b/target/ppc/cpu.h
index a44de22ca4..11205bb9e3 100644
--- a/target/ppc/cpu.h
+++ b/target/ppc/cpu.h
@@ -1737,9 +1737,11 @@ void ppc_compat_add_property(Object *obj, const char *name,
#define SPR_PSPB (0x09F)
#define SPR_DPDES (0x0B0)
#define SPR_DAWR0 (0x0B4)
+#define SPR_DAWR1 (0x0B5)
#define SPR_RPR (0x0BA)
#define SPR_CIABR (0x0BB)
#define SPR_DAWRX0 (0x0BC)
+#define SPR_DAWRX1 (0x0BD)
#define SPR_HFSCR (0x0BE)
#define SPR_VRSAVE (0x100)
#define SPR_USPRG0 (0x100)
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 3cc704adda..39d0c087f1 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -101,6 +101,7 @@ static target_ulong h_copy_tofrom_guest(PowerPCCPU *cpu,
static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
{
CPUPPCState *env = &cpu->env;
+ SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
memcpy(save->gpr, env->gpr, sizeof(save->gpr));
@@ -127,6 +128,58 @@ static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
save->pidr = env->spr[SPR_BOOKS_PID];
save->ppr = env->spr[SPR_PPR];
+ if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
+ save->pvr = env->spr[SPR_PVR];
+ save->amor = env->spr[SPR_AMOR];
+ save->dawr0 = env->spr[SPR_DAWR0];
+ save->dawrx0 = env->spr[SPR_DAWRX0];
+ save->ciabr = env->spr[SPR_CIABR];
+ save->purr = env->spr[SPR_PURR];
+ save->spurr = env->spr[SPR_SPURR];
+ save->ic = env->spr[SPR_IC];
+ save->vtb = env->spr[SPR_VTB];
+ save->hdar = env->spr[SPR_HDAR];
+ save->hdsisr = env->spr[SPR_HDSISR];
+ save->heir = env->spr[SPR_HEIR];
+ save->asdr = env->spr[SPR_ASDR];
+ save->dawr1 = env->spr[SPR_DAWR1];
+ save->dawrx1 = env->spr[SPR_DAWRX1];
+ save->dexcr = env->spr[SPR_DEXCR];
+ save->hdexcr = env->spr[SPR_HDEXCR];
+ save->hashkeyr = env->spr[SPR_HASHKEYR];
+ save->hashpkeyr = env->spr[SPR_HASHPKEYR];
+ memcpy(save->vsr, env->vsr, sizeof(save->vsr));
+ save->ebbhr = env->spr[SPR_EBBHR];
+ save->tar = env->spr[SPR_TAR];
+ save->ebbrr = env->spr[SPR_EBBRR];
+ save->bescr = env->spr[SPR_BESCR];
+ save->iamr = env->spr[SPR_IAMR];
+ save->amr = env->spr[SPR_AMR];
+ save->uamor = env->spr[SPR_UAMOR];
+ save->dscr = env->spr[SPR_DSCR];
+ save->fscr = env->spr[SPR_FSCR];
+ save->pspb = env->spr[SPR_PSPB];
+ save->ctrl = env->spr[SPR_CTRL];
+ save->vrsave = env->spr[SPR_VRSAVE];
+ save->dar = env->spr[SPR_DAR];
+ save->dsisr = env->spr[SPR_DSISR];
+ save->pmc1 = env->spr[SPR_POWER_PMC1];
+ save->pmc2 = env->spr[SPR_POWER_PMC2];
+ save->pmc3 = env->spr[SPR_POWER_PMC3];
+ save->pmc4 = env->spr[SPR_POWER_PMC4];
+ save->pmc5 = env->spr[SPR_POWER_PMC5];
+ save->pmc6 = env->spr[SPR_POWER_PMC6];
+ save->mmcr0 = env->spr[SPR_POWER_MMCR0];
+ save->mmcr1 = env->spr[SPR_POWER_MMCR1];
+ save->mmcr2 = env->spr[SPR_POWER_MMCR2];
+ save->mmcra = env->spr[SPR_POWER_MMCRA];
+ save->sdar = env->spr[SPR_POWER_SDAR];
+ save->siar = env->spr[SPR_POWER_SIAR];
+ save->sier = env->spr[SPR_POWER_SIER];
+ save->vscr = ppc_get_vscr(env);
+ save->fpscr = env->fpscr;
+ }
+
save->tb_offset = env->tb_env->tb_offset;
}
@@ -134,6 +187,7 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
+ SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
memcpy(env->gpr, load->gpr, sizeof(env->gpr));
@@ -160,6 +214,58 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
env->spr[SPR_BOOKS_PID] = load->pidr;
env->spr[SPR_PPR] = load->ppr;
+ if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
+ env->spr[SPR_PVR] = load->pvr;
+ env->spr[SPR_AMOR] = load->amor;
+ env->spr[SPR_DAWR0] = load->dawr0;
+ env->spr[SPR_DAWRX0] = load->dawrx0;
+ env->spr[SPR_CIABR] = load->ciabr;
+ env->spr[SPR_PURR] = load->purr;
+ env->spr[SPR_SPURR] = load->purr;
+ env->spr[SPR_IC] = load->ic;
+ env->spr[SPR_VTB] = load->vtb;
+ env->spr[SPR_HDAR] = load->hdar;
+ env->spr[SPR_HDSISR] = load->hdsisr;
+ env->spr[SPR_HEIR] = load->heir;
+ env->spr[SPR_ASDR] = load->asdr;
+ env->spr[SPR_DAWR1] = load->dawr1;
+ env->spr[SPR_DAWRX1] = load->dawrx1;
+ env->spr[SPR_DEXCR] = load->dexcr;
+ env->spr[SPR_HDEXCR] = load->hdexcr;
+ env->spr[SPR_HASHKEYR] = load->hashkeyr;
+ env->spr[SPR_HASHPKEYR] = load->hashpkeyr;
+ memcpy(env->vsr, load->vsr, sizeof(env->vsr));
+ env->spr[SPR_EBBHR] = load->ebbhr;
+ env->spr[SPR_TAR] = load->tar;
+ env->spr[SPR_EBBRR] = load->ebbrr;
+ env->spr[SPR_BESCR] = load->bescr;
+ env->spr[SPR_IAMR] = load->iamr;
+ env->spr[SPR_AMR] = load->amr;
+ env->spr[SPR_UAMOR] = load->uamor;
+ env->spr[SPR_DSCR] = load->dscr;
+ env->spr[SPR_FSCR] = load->fscr;
+ env->spr[SPR_PSPB] = load->pspb;
+ env->spr[SPR_CTRL] = load->ctrl;
+ env->spr[SPR_VRSAVE] = load->vrsave;
+ env->spr[SPR_DAR] = load->dar;
+ env->spr[SPR_DSISR] = load->dsisr;
+ env->spr[SPR_POWER_PMC1] = load->pmc1;
+ env->spr[SPR_POWER_PMC2] = load->pmc2;
+ env->spr[SPR_POWER_PMC3] = load->pmc3;
+ env->spr[SPR_POWER_PMC4] = load->pmc4;
+ env->spr[SPR_POWER_PMC5] = load->pmc5;
+ env->spr[SPR_POWER_PMC6] = load->pmc6;
+ env->spr[SPR_POWER_MMCR0] = load->mmcr0;
+ env->spr[SPR_POWER_MMCR1] = load->mmcr1;
+ env->spr[SPR_POWER_MMCR2] = load->mmcr2;
+ env->spr[SPR_POWER_MMCRA] = load->mmcra;
+ env->spr[SPR_POWER_SDAR] = load->sdar;
+ env->spr[SPR_POWER_SIAR] = load->siar;
+ env->spr[SPR_POWER_SIER] = load->sier;
+ ppc_store_vscr(env, load->vscr);
+ ppc_store_fpscr(env, load->fpscr);
+ }
+
env->tb_env->tb_offset = load->tb_offset;
/*
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API
2024-02-20 8:36 ` [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API Harsh Prateek Bora
@ 2024-02-27 9:59 ` Nicholas Piggin
2024-02-29 9:42 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 9:59 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> Currently, nested_ppc_state stores a certain set of registers and works
> with nested_[load|save]_state() for state transfer as reqd for nested-hv API.
> Extending these with additional registers state as reqd for nested PAPR API.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> Suggested-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> include/hw/ppc/spapr_nested.h | 49 ++++++++++++++++
> target/ppc/cpu.h | 2 +
> hw/ppc/spapr_nested.c | 106 ++++++++++++++++++++++++++++++++++
> 3 files changed, 157 insertions(+)
>
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index 24e87bca08..a3b61eb79a 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -7,6 +7,7 @@ typedef struct SpaprMachineStateNested {
> uint64_t ptcr;
> uint8_t api;
> #define NESTED_API_KVM_HV 1
> +#define NESTED_API_PAPR 2
> bool capabilities_set;
> uint32_t pvr_base;
> GHashTable *guests;
> @@ -123,6 +124,54 @@ struct nested_ppc_state {
> int64_t tb_offset;
> /* Nested PAPR API */
> uint64_t pvr;
> + uint64_t amor;
> + uint64_t dawr0;
> + uint64_t dawrx0;
> + uint64_t ciabr;
> + uint64_t purr;
> + uint64_t spurr;
> + uint64_t ic;
> + uint64_t vtb;
> + uint64_t hdar;
> + uint64_t hdsisr;
> + uint64_t heir;
> + uint64_t asdr;
> + uint64_t dawr1;
> + uint64_t dawrx1;
> + uint64_t dexcr;
> + uint64_t hdexcr;
> + uint64_t hashkeyr;
> + uint64_t hashpkeyr;
> + ppc_vsr_t vsr[64] QEMU_ALIGNED(16);
> + uint64_t ebbhr;
> + uint64_t tar;
> + uint64_t ebbrr;
> + uint64_t bescr;
> + uint64_t iamr;
> + uint64_t amr;
> + uint64_t uamor;
> + uint64_t dscr;
> + uint64_t fscr;
> + uint64_t pspb;
> + uint64_t ctrl;
> + uint64_t vrsave;
> + uint64_t dar;
> + uint64_t dsisr;
> + uint64_t pmc1;
> + uint64_t pmc2;
> + uint64_t pmc3;
> + uint64_t pmc4;
> + uint64_t pmc5;
> + uint64_t pmc6;
> + uint64_t mmcr0;
> + uint64_t mmcr1;
> + uint64_t mmcr2;
> + uint64_t mmcra;
> + uint64_t sdar;
> + uint64_t siar;
> + uint64_t sier;
> + uint32_t vscr;
> + uint64_t fpscr;
> };
>
> typedef struct SpaprMachineStateNestedGuestVcpu {
> diff --git a/target/ppc/cpu.h b/target/ppc/cpu.h
> index a44de22ca4..11205bb9e3 100644
> --- a/target/ppc/cpu.h
> +++ b/target/ppc/cpu.h
> @@ -1737,9 +1737,11 @@ void ppc_compat_add_property(Object *obj, const char *name,
> #define SPR_PSPB (0x09F)
> #define SPR_DPDES (0x0B0)
> #define SPR_DAWR0 (0x0B4)
> +#define SPR_DAWR1 (0x0B5)
> #define SPR_RPR (0x0BA)
> #define SPR_CIABR (0x0BB)
> #define SPR_DAWRX0 (0x0BC)
> +#define SPR_DAWRX1 (0x0BD)
> #define SPR_HFSCR (0x0BE)
> #define SPR_VRSAVE (0x100)
> #define SPR_USPRG0 (0x100)
Might try to put the DAWR1 enable ahead of this, but if not we'll have
to drop these until that is done. Leave it in for now I'll sort it out
if necessary.
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index 3cc704adda..39d0c087f1 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -101,6 +101,7 @@ static target_ulong h_copy_tofrom_guest(PowerPCCPU *cpu,
> static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
> {
> CPUPPCState *env = &cpu->env;
> + SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
I hope that won't be a big overhead... nested entry/exit performance probably
isn't top priority at the moment though, so for now okay. Should be
something to look at though.
> memcpy(save->gpr, env->gpr, sizeof(save->gpr));
>
> @@ -127,6 +128,58 @@ static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
> save->pidr = env->spr[SPR_BOOKS_PID];
> save->ppr = env->spr[SPR_PPR];
>
> + if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
> + save->pvr = env->spr[SPR_PVR];
> + save->amor = env->spr[SPR_AMOR];
> + save->dawr0 = env->spr[SPR_DAWR0];
> + save->dawrx0 = env->spr[SPR_DAWRX0];
> + save->ciabr = env->spr[SPR_CIABR];
> + save->purr = env->spr[SPR_PURR];
> + save->spurr = env->spr[SPR_SPURR];
> + save->ic = env->spr[SPR_IC];
> + save->vtb = env->spr[SPR_VTB];
> + save->hdar = env->spr[SPR_HDAR];
> + save->hdsisr = env->spr[SPR_HDSISR];
> + save->heir = env->spr[SPR_HEIR];
> + save->asdr = env->spr[SPR_ASDR];
> + save->dawr1 = env->spr[SPR_DAWR1];
> + save->dawrx1 = env->spr[SPR_DAWRX1];
> + save->dexcr = env->spr[SPR_DEXCR];
> + save->hdexcr = env->spr[SPR_HDEXCR];
> + save->hashkeyr = env->spr[SPR_HASHKEYR];
> + save->hashpkeyr = env->spr[SPR_HASHPKEYR];
> + memcpy(save->vsr, env->vsr, sizeof(save->vsr));
> + save->ebbhr = env->spr[SPR_EBBHR];
> + save->tar = env->spr[SPR_TAR];
> + save->ebbrr = env->spr[SPR_EBBRR];
> + save->bescr = env->spr[SPR_BESCR];
> + save->iamr = env->spr[SPR_IAMR];
> + save->amr = env->spr[SPR_AMR];
> + save->uamor = env->spr[SPR_UAMOR];
> + save->dscr = env->spr[SPR_DSCR];
> + save->fscr = env->spr[SPR_FSCR];
> + save->pspb = env->spr[SPR_PSPB];
> + save->ctrl = env->spr[SPR_CTRL];
> + save->vrsave = env->spr[SPR_VRSAVE];
> + save->dar = env->spr[SPR_DAR];
> + save->dsisr = env->spr[SPR_DSISR];
> + save->pmc1 = env->spr[SPR_POWER_PMC1];
> + save->pmc2 = env->spr[SPR_POWER_PMC2];
> + save->pmc3 = env->spr[SPR_POWER_PMC3];
> + save->pmc4 = env->spr[SPR_POWER_PMC4];
> + save->pmc5 = env->spr[SPR_POWER_PMC5];
> + save->pmc6 = env->spr[SPR_POWER_PMC6];
> + save->mmcr0 = env->spr[SPR_POWER_MMCR0];
> + save->mmcr1 = env->spr[SPR_POWER_MMCR1];
> + save->mmcr2 = env->spr[SPR_POWER_MMCR2];
> + save->mmcra = env->spr[SPR_POWER_MMCRA];
> + save->sdar = env->spr[SPR_POWER_SDAR];
> + save->siar = env->spr[SPR_POWER_SIAR];
> + save->sier = env->spr[SPR_POWER_SIER];
> + save->vscr = ppc_get_vscr(env);
> + save->fpscr = env->fpscr;
> + }
> +
> save->tb_offset = env->tb_env->tb_offset;
> }
>
> @@ -134,6 +187,7 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
> {
> CPUState *cs = CPU(cpu);
> CPUPPCState *env = &cpu->env;
> + SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
>
> memcpy(env->gpr, load->gpr, sizeof(env->gpr));
>
> @@ -160,6 +214,58 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
> env->spr[SPR_BOOKS_PID] = load->pidr;
> env->spr[SPR_PPR] = load->ppr;
>
> + if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
> + env->spr[SPR_PVR] = load->pvr;
> + env->spr[SPR_AMOR] = load->amor;
> + env->spr[SPR_DAWR0] = load->dawr0;
> + env->spr[SPR_DAWRX0] = load->dawrx0;
> + env->spr[SPR_CIABR] = load->ciabr;
> + env->spr[SPR_PURR] = load->purr;
> + env->spr[SPR_SPURR] = load->purr;
> + env->spr[SPR_IC] = load->ic;
> + env->spr[SPR_VTB] = load->vtb;
> + env->spr[SPR_HDAR] = load->hdar;
> + env->spr[SPR_HDSISR] = load->hdsisr;
> + env->spr[SPR_HEIR] = load->heir;
> + env->spr[SPR_ASDR] = load->asdr;
> + env->spr[SPR_DAWR1] = load->dawr1;
> + env->spr[SPR_DAWRX1] = load->dawrx1;
> + env->spr[SPR_DEXCR] = load->dexcr;
> + env->spr[SPR_HDEXCR] = load->hdexcr;
> + env->spr[SPR_HASHKEYR] = load->hashkeyr;
> + env->spr[SPR_HASHPKEYR] = load->hashpkeyr;
> + memcpy(env->vsr, load->vsr, sizeof(env->vsr));
> + env->spr[SPR_EBBHR] = load->ebbhr;
> + env->spr[SPR_TAR] = load->tar;
> + env->spr[SPR_EBBRR] = load->ebbrr;
> + env->spr[SPR_BESCR] = load->bescr;
> + env->spr[SPR_IAMR] = load->iamr;
> + env->spr[SPR_AMR] = load->amr;
> + env->spr[SPR_UAMOR] = load->uamor;
> + env->spr[SPR_DSCR] = load->dscr;
> + env->spr[SPR_FSCR] = load->fscr;
> + env->spr[SPR_PSPB] = load->pspb;
> + env->spr[SPR_CTRL] = load->ctrl;
> + env->spr[SPR_VRSAVE] = load->vrsave;
> + env->spr[SPR_DAR] = load->dar;
> + env->spr[SPR_DSISR] = load->dsisr;
> + env->spr[SPR_POWER_PMC1] = load->pmc1;
> + env->spr[SPR_POWER_PMC2] = load->pmc2;
> + env->spr[SPR_POWER_PMC3] = load->pmc3;
> + env->spr[SPR_POWER_PMC4] = load->pmc4;
> + env->spr[SPR_POWER_PMC5] = load->pmc5;
> + env->spr[SPR_POWER_PMC6] = load->pmc6;
> + env->spr[SPR_POWER_MMCR0] = load->mmcr0;
> + env->spr[SPR_POWER_MMCR1] = load->mmcr1;
> + env->spr[SPR_POWER_MMCR2] = load->mmcr2;
> + env->spr[SPR_POWER_MMCRA] = load->mmcra;
I worry that some other SPRs have "behaviour" we need
to handle. DAWR and MMCR? for example set breakpoints
and PMU beahviour. I don't know how well that is handled
here.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API
2024-02-27 9:59 ` Nicholas Piggin
@ 2024-02-29 9:42 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-29 9:42 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 15:29, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> Currently, nested_ppc_state stores a certain set of registers and works
>> with nested_[load|save]_state() for state transfer as reqd for nested-hv API.
>> Extending these with additional registers state as reqd for nested PAPR API.
>>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> Suggested-by: Nicholas Piggin <npiggin@gmail.com>
>> ---
>> include/hw/ppc/spapr_nested.h | 49 ++++++++++++++++
>> target/ppc/cpu.h | 2 +
>> hw/ppc/spapr_nested.c | 106 ++++++++++++++++++++++++++++++++++
>> 3 files changed, 157 insertions(+)
>>
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index 24e87bca08..a3b61eb79a 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -7,6 +7,7 @@ typedef struct SpaprMachineStateNested {
>> uint64_t ptcr;
>> uint8_t api;
>> #define NESTED_API_KVM_HV 1
>> +#define NESTED_API_PAPR 2
>> bool capabilities_set;
>> uint32_t pvr_base;
>> GHashTable *guests;
>> @@ -123,6 +124,54 @@ struct nested_ppc_state {
>> int64_t tb_offset;
>> /* Nested PAPR API */
>> uint64_t pvr;
>> + uint64_t amor;
>> + uint64_t dawr0;
>> + uint64_t dawrx0;
>> + uint64_t ciabr;
>> + uint64_t purr;
>> + uint64_t spurr;
>> + uint64_t ic;
>> + uint64_t vtb;
>> + uint64_t hdar;
>> + uint64_t hdsisr;
>> + uint64_t heir;
>> + uint64_t asdr;
>> + uint64_t dawr1;
>> + uint64_t dawrx1;
>> + uint64_t dexcr;
>> + uint64_t hdexcr;
>> + uint64_t hashkeyr;
>> + uint64_t hashpkeyr;
>> + ppc_vsr_t vsr[64] QEMU_ALIGNED(16);
>> + uint64_t ebbhr;
>> + uint64_t tar;
>> + uint64_t ebbrr;
>> + uint64_t bescr;
>> + uint64_t iamr;
>> + uint64_t amr;
>> + uint64_t uamor;
>> + uint64_t dscr;
>> + uint64_t fscr;
>> + uint64_t pspb;
>> + uint64_t ctrl;
>> + uint64_t vrsave;
>> + uint64_t dar;
>> + uint64_t dsisr;
>> + uint64_t pmc1;
>> + uint64_t pmc2;
>> + uint64_t pmc3;
>> + uint64_t pmc4;
>> + uint64_t pmc5;
>> + uint64_t pmc6;
>> + uint64_t mmcr0;
>> + uint64_t mmcr1;
>> + uint64_t mmcr2;
>> + uint64_t mmcra;
>> + uint64_t sdar;
>> + uint64_t siar;
>> + uint64_t sier;
>> + uint32_t vscr;
>> + uint64_t fpscr;
>> };
>>
>> typedef struct SpaprMachineStateNestedGuestVcpu {
>> diff --git a/target/ppc/cpu.h b/target/ppc/cpu.h
>> index a44de22ca4..11205bb9e3 100644
>> --- a/target/ppc/cpu.h
>> +++ b/target/ppc/cpu.h
>> @@ -1737,9 +1737,11 @@ void ppc_compat_add_property(Object *obj, const char *name,
>> #define SPR_PSPB (0x09F)
>> #define SPR_DPDES (0x0B0)
>> #define SPR_DAWR0 (0x0B4)
>> +#define SPR_DAWR1 (0x0B5)
>> #define SPR_RPR (0x0BA)
>> #define SPR_CIABR (0x0BB)
>> #define SPR_DAWRX0 (0x0BC)
>> +#define SPR_DAWRX1 (0x0BD)
>> #define SPR_HFSCR (0x0BE)
>> #define SPR_VRSAVE (0x100)
>> #define SPR_USPRG0 (0x100)
>
> Might try to put the DAWR1 enable ahead of this, but if not we'll have
> to drop these until that is done. Leave it in for now I'll sort it out
> if necessary.
Ok
>
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index 3cc704adda..39d0c087f1 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -101,6 +101,7 @@ static target_ulong h_copy_tofrom_guest(PowerPCCPU *cpu,
>> static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
>> {
>> CPUPPCState *env = &cpu->env;
>> + SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
>
> I hope that won't be a big overhead... nested entry/exit performance probably
> isn't top priority at the moment though, so for now okay. Should be
> something to look at though.
Hmm.. Ok
>
>
>> memcpy(save->gpr, env->gpr, sizeof(save->gpr));
>>
>> @@ -127,6 +128,58 @@ static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
>> save->pidr = env->spr[SPR_BOOKS_PID];
>> save->ppr = env->spr[SPR_PPR];
>>
>> + if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
>> + save->pvr = env->spr[SPR_PVR];
>> + save->amor = env->spr[SPR_AMOR];
>> + save->dawr0 = env->spr[SPR_DAWR0];
>> + save->dawrx0 = env->spr[SPR_DAWRX0];
>> + save->ciabr = env->spr[SPR_CIABR];
>> + save->purr = env->spr[SPR_PURR];
>> + save->spurr = env->spr[SPR_SPURR];
>> + save->ic = env->spr[SPR_IC];
>> + save->vtb = env->spr[SPR_VTB];
>> + save->hdar = env->spr[SPR_HDAR];
>> + save->hdsisr = env->spr[SPR_HDSISR];
>> + save->heir = env->spr[SPR_HEIR];
>> + save->asdr = env->spr[SPR_ASDR];
>> + save->dawr1 = env->spr[SPR_DAWR1];
>> + save->dawrx1 = env->spr[SPR_DAWRX1];
>> + save->dexcr = env->spr[SPR_DEXCR];
>> + save->hdexcr = env->spr[SPR_HDEXCR];
>> + save->hashkeyr = env->spr[SPR_HASHKEYR];
>> + save->hashpkeyr = env->spr[SPR_HASHPKEYR];
>> + memcpy(save->vsr, env->vsr, sizeof(save->vsr));
>> + save->ebbhr = env->spr[SPR_EBBHR];
>> + save->tar = env->spr[SPR_TAR];
>> + save->ebbrr = env->spr[SPR_EBBRR];
>> + save->bescr = env->spr[SPR_BESCR];
>> + save->iamr = env->spr[SPR_IAMR];
>> + save->amr = env->spr[SPR_AMR];
>> + save->uamor = env->spr[SPR_UAMOR];
>> + save->dscr = env->spr[SPR_DSCR];
>> + save->fscr = env->spr[SPR_FSCR];
>> + save->pspb = env->spr[SPR_PSPB];
>> + save->ctrl = env->spr[SPR_CTRL];
>> + save->vrsave = env->spr[SPR_VRSAVE];
>> + save->dar = env->spr[SPR_DAR];
>> + save->dsisr = env->spr[SPR_DSISR];
>> + save->pmc1 = env->spr[SPR_POWER_PMC1];
>> + save->pmc2 = env->spr[SPR_POWER_PMC2];
>> + save->pmc3 = env->spr[SPR_POWER_PMC3];
>> + save->pmc4 = env->spr[SPR_POWER_PMC4];
>> + save->pmc5 = env->spr[SPR_POWER_PMC5];
>> + save->pmc6 = env->spr[SPR_POWER_PMC6];
>> + save->mmcr0 = env->spr[SPR_POWER_MMCR0];
>> + save->mmcr1 = env->spr[SPR_POWER_MMCR1];
>> + save->mmcr2 = env->spr[SPR_POWER_MMCR2];
>> + save->mmcra = env->spr[SPR_POWER_MMCRA];
>> + save->sdar = env->spr[SPR_POWER_SDAR];
>> + save->siar = env->spr[SPR_POWER_SIAR];
>> + save->sier = env->spr[SPR_POWER_SIER];
>> + save->vscr = ppc_get_vscr(env);
>> + save->fpscr = env->fpscr;
>> + }
>> +
>> save->tb_offset = env->tb_env->tb_offset;
>> }
>>
>> @@ -134,6 +187,7 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
>> {
>> CPUState *cs = CPU(cpu);
>> CPUPPCState *env = &cpu->env;
>> + SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
>>
>> memcpy(env->gpr, load->gpr, sizeof(env->gpr));
>>
>> @@ -160,6 +214,58 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
>> env->spr[SPR_BOOKS_PID] = load->pidr;
>> env->spr[SPR_PPR] = load->ppr;
>>
>> + if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
>> + env->spr[SPR_PVR] = load->pvr;
>> + env->spr[SPR_AMOR] = load->amor;
>> + env->spr[SPR_DAWR0] = load->dawr0;
>> + env->spr[SPR_DAWRX0] = load->dawrx0;
>> + env->spr[SPR_CIABR] = load->ciabr;
>> + env->spr[SPR_PURR] = load->purr;
>> + env->spr[SPR_SPURR] = load->purr;
>> + env->spr[SPR_IC] = load->ic;
>> + env->spr[SPR_VTB] = load->vtb;
>> + env->spr[SPR_HDAR] = load->hdar;
>> + env->spr[SPR_HDSISR] = load->hdsisr;
>> + env->spr[SPR_HEIR] = load->heir;
>> + env->spr[SPR_ASDR] = load->asdr;
>> + env->spr[SPR_DAWR1] = load->dawr1;
>> + env->spr[SPR_DAWRX1] = load->dawrx1;
>> + env->spr[SPR_DEXCR] = load->dexcr;
>> + env->spr[SPR_HDEXCR] = load->hdexcr;
>> + env->spr[SPR_HASHKEYR] = load->hashkeyr;
>> + env->spr[SPR_HASHPKEYR] = load->hashpkeyr;
>> + memcpy(env->vsr, load->vsr, sizeof(env->vsr));
>> + env->spr[SPR_EBBHR] = load->ebbhr;
>> + env->spr[SPR_TAR] = load->tar;
>> + env->spr[SPR_EBBRR] = load->ebbrr;
>> + env->spr[SPR_BESCR] = load->bescr;
>> + env->spr[SPR_IAMR] = load->iamr;
>> + env->spr[SPR_AMR] = load->amr;
>> + env->spr[SPR_UAMOR] = load->uamor;
>> + env->spr[SPR_DSCR] = load->dscr;
>> + env->spr[SPR_FSCR] = load->fscr;
>> + env->spr[SPR_PSPB] = load->pspb;
>> + env->spr[SPR_CTRL] = load->ctrl;
>> + env->spr[SPR_VRSAVE] = load->vrsave;
>> + env->spr[SPR_DAR] = load->dar;
>> + env->spr[SPR_DSISR] = load->dsisr;
>> + env->spr[SPR_POWER_PMC1] = load->pmc1;
>> + env->spr[SPR_POWER_PMC2] = load->pmc2;
>> + env->spr[SPR_POWER_PMC3] = load->pmc3;
>> + env->spr[SPR_POWER_PMC4] = load->pmc4;
>> + env->spr[SPR_POWER_PMC5] = load->pmc5;
>> + env->spr[SPR_POWER_PMC6] = load->pmc6;
>> + env->spr[SPR_POWER_MMCR0] = load->mmcr0;
>> + env->spr[SPR_POWER_MMCR1] = load->mmcr1;
>> + env->spr[SPR_POWER_MMCR2] = load->mmcr2;
>> + env->spr[SPR_POWER_MMCRA] = load->mmcra;
>
> I worry that some other SPRs have "behaviour" we need
> to handle. DAWR and MMCR? for example set breakpoints
> and PMU beahviour. I don't know how well that is handled
> here.
I think for now we can keep it as-is. Any additional handling can be
taken care as separate patches in future?
regards,
Harsh
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (8 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 09/15] spapr: nested: Extend nested_ppc_state for nested PAPR API Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 10:02 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls Harsh Prateek Bora
` (4 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Nested PAPR API provides a standard Guest State Buffer (GSB) format
with unique IDs for each guest state element for which get/set state is
supported by the API. Some of the elements are read-only and/or guest-wide.
Introducing helper routines for state exchange of each of the nested guest
state elements for which get/set state should be supported by the API.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Shivaprasad G Bhat <sbhat@linux.ibm.com>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr_nested.h | 303 +++++++++++++++++++++++
hw/ppc/spapr_nested.c | 442 +++++++++++++++++++++++++++++++++-
2 files changed, 742 insertions(+), 3 deletions(-)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index a3b61eb79a..492302a21d 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -3,6 +3,191 @@
#include "target/ppc/cpu.h"
+/* Guest State Buffer Element IDs */
+#define GSB_HV_VCPU_IGNORED_ID 0x0000 /* An element whose value is ignored */
+#define GSB_HV_VCPU_STATE_SIZE 0x0001 /* HV internal format VCPU state size */
+#define GSB_VCPU_OUT_BUF_MIN_SZ 0x0002 /* Min size of the Run VCPU o/p buffer */
+#define GSB_VCPU_LPVR 0x0003 /* Logical PVR */
+#define GSB_TB_OFFSET 0x0004 /* Timebase Offset */
+#define GSB_PART_SCOPED_PAGETBL 0x0005 /* Partition Scoped Page Table */
+#define GSB_PROCESS_TBL 0x0006 /* Process Table */
+ /* RESERVED 0x0007 - 0x0BFF */
+#define GSB_VCPU_IN_BUFFER 0x0C00 /* Run VCPU Input Buffer */
+#define GSB_VCPU_OUT_BUFFER 0x0C01 /* Run VCPU Out Buffer */
+#define GSB_VCPU_VPA 0x0C02 /* HRA to Guest VCPU VPA */
+ /* RESERVED 0x0C03 - 0x0FFF */
+#define GSB_VCPU_GPR0 0x1000
+#define GSB_VCPU_GPR1 0x1001
+#define GSB_VCPU_GPR2 0x1002
+#define GSB_VCPU_GPR3 0x1003
+#define GSB_VCPU_GPR4 0x1004
+#define GSB_VCPU_GPR5 0x1005
+#define GSB_VCPU_GPR6 0x1006
+#define GSB_VCPU_GPR7 0x1007
+#define GSB_VCPU_GPR8 0x1008
+#define GSB_VCPU_GPR9 0x1009
+#define GSB_VCPU_GPR10 0x100A
+#define GSB_VCPU_GPR11 0x100B
+#define GSB_VCPU_GPR12 0x100C
+#define GSB_VCPU_GPR13 0x100D
+#define GSB_VCPU_GPR14 0x100E
+#define GSB_VCPU_GPR15 0x100F
+#define GSB_VCPU_GPR16 0x1010
+#define GSB_VCPU_GPR17 0x1011
+#define GSB_VCPU_GPR18 0x1012
+#define GSB_VCPU_GPR19 0x1013
+#define GSB_VCPU_GPR20 0x1014
+#define GSB_VCPU_GPR21 0x1015
+#define GSB_VCPU_GPR22 0x1016
+#define GSB_VCPU_GPR23 0x1017
+#define GSB_VCPU_GPR24 0x1018
+#define GSB_VCPU_GPR25 0x1019
+#define GSB_VCPU_GPR26 0x101A
+#define GSB_VCPU_GPR27 0x101B
+#define GSB_VCPU_GPR28 0x101C
+#define GSB_VCPU_GPR29 0x101D
+#define GSB_VCPU_GPR30 0x101E
+#define GSB_VCPU_GPR31 0x101F
+#define GSB_VCPU_HDEC_EXPIRY_TB 0x1020
+#define GSB_VCPU_SPR_NIA 0x1021
+#define GSB_VCPU_SPR_MSR 0x1022
+#define GSB_VCPU_SPR_LR 0x1023
+#define GSB_VCPU_SPR_XER 0x1024
+#define GSB_VCPU_SPR_CTR 0x1025
+#define GSB_VCPU_SPR_CFAR 0x1026
+#define GSB_VCPU_SPR_SRR0 0x1027
+#define GSB_VCPU_SPR_SRR1 0x1028
+#define GSB_VCPU_SPR_DAR 0x1029
+#define GSB_VCPU_DEC_EXPIRE_TB 0x102A
+#define GSB_VCPU_SPR_VTB 0x102B
+#define GSB_VCPU_SPR_LPCR 0x102C
+#define GSB_VCPU_SPR_HFSCR 0x102D
+#define GSB_VCPU_SPR_FSCR 0x102E
+#define GSB_VCPU_SPR_FPSCR 0x102F
+#define GSB_VCPU_SPR_DAWR0 0x1030
+#define GSB_VCPU_SPR_DAWR1 0x1031
+#define GSB_VCPU_SPR_CIABR 0x1032
+#define GSB_VCPU_SPR_PURR 0x1033
+#define GSB_VCPU_SPR_SPURR 0x1034
+#define GSB_VCPU_SPR_IC 0x1035
+#define GSB_VCPU_SPR_SPRG0 0x1036
+#define GSB_VCPU_SPR_SPRG1 0x1037
+#define GSB_VCPU_SPR_SPRG2 0x1038
+#define GSB_VCPU_SPR_SPRG3 0x1039
+#define GSB_VCPU_SPR_PPR 0x103A
+#define GSB_VCPU_SPR_MMCR0 0x103B
+#define GSB_VCPU_SPR_MMCR1 0x103C
+#define GSB_VCPU_SPR_MMCR2 0x103D
+#define GSB_VCPU_SPR_MMCR3 0x103E
+#define GSB_VCPU_SPR_MMCRA 0x103F
+#define GSB_VCPU_SPR_SIER 0x1040
+#define GSB_VCPU_SPR_SIER2 0x1041
+#define GSB_VCPU_SPR_SIER3 0x1042
+#define GSB_VCPU_SPR_BESCR 0x1043
+#define GSB_VCPU_SPR_EBBHR 0x1044
+#define GSB_VCPU_SPR_EBBRR 0x1045
+#define GSB_VCPU_SPR_AMR 0x1046
+#define GSB_VCPU_SPR_IAMR 0x1047
+#define GSB_VCPU_SPR_AMOR 0x1048
+#define GSB_VCPU_SPR_UAMOR 0x1049
+#define GSB_VCPU_SPR_SDAR 0x104A
+#define GSB_VCPU_SPR_SIAR 0x104B
+#define GSB_VCPU_SPR_DSCR 0x104C
+#define GSB_VCPU_SPR_TAR 0x104D
+#define GSB_VCPU_SPR_DEXCR 0x104E
+#define GSB_VCPU_SPR_HDEXCR 0x104F
+#define GSB_VCPU_SPR_HASHKEYR 0x1050
+#define GSB_VCPU_SPR_HASHPKEYR 0x1051
+#define GSB_VCPU_SPR_CTRL 0x1052
+ /* RESERVED 0x1053 - 0x1FFF */
+#define GSB_VCPU_SPR_CR 0x2000
+#define GSB_VCPU_SPR_PIDR 0x2001
+#define GSB_VCPU_SPR_DSISR 0x2002
+#define GSB_VCPU_SPR_VSCR 0x2003
+#define GSB_VCPU_SPR_VRSAVE 0x2004
+#define GSB_VCPU_SPR_DAWRX0 0x2005
+#define GSB_VCPU_SPR_DAWRX1 0x2006
+#define GSB_VCPU_SPR_PMC1 0x2007
+#define GSB_VCPU_SPR_PMC2 0x2008
+#define GSB_VCPU_SPR_PMC3 0x2009
+#define GSB_VCPU_SPR_PMC4 0x200A
+#define GSB_VCPU_SPR_PMC5 0x200B
+#define GSB_VCPU_SPR_PMC6 0x200C
+#define GSB_VCPU_SPR_WORT 0x200D
+#define GSB_VCPU_SPR_PSPB 0x200E
+ /* RESERVED 0x200F - 0x2FFF */
+#define GSB_VCPU_SPR_VSR0 0x3000
+#define GSB_VCPU_SPR_VSR1 0x3001
+#define GSB_VCPU_SPR_VSR2 0x3002
+#define GSB_VCPU_SPR_VSR3 0x3003
+#define GSB_VCPU_SPR_VSR4 0x3004
+#define GSB_VCPU_SPR_VSR5 0x3005
+#define GSB_VCPU_SPR_VSR6 0x3006
+#define GSB_VCPU_SPR_VSR7 0x3007
+#define GSB_VCPU_SPR_VSR8 0x3008
+#define GSB_VCPU_SPR_VSR9 0x3009
+#define GSB_VCPU_SPR_VSR10 0x300A
+#define GSB_VCPU_SPR_VSR11 0x300B
+#define GSB_VCPU_SPR_VSR12 0x300C
+#define GSB_VCPU_SPR_VSR13 0x300D
+#define GSB_VCPU_SPR_VSR14 0x300E
+#define GSB_VCPU_SPR_VSR15 0x300F
+#define GSB_VCPU_SPR_VSR16 0x3010
+#define GSB_VCPU_SPR_VSR17 0x3011
+#define GSB_VCPU_SPR_VSR18 0x3012
+#define GSB_VCPU_SPR_VSR19 0x3013
+#define GSB_VCPU_SPR_VSR20 0x3014
+#define GSB_VCPU_SPR_VSR21 0x3015
+#define GSB_VCPU_SPR_VSR22 0x3016
+#define GSB_VCPU_SPR_VSR23 0x3017
+#define GSB_VCPU_SPR_VSR24 0x3018
+#define GSB_VCPU_SPR_VSR25 0x3019
+#define GSB_VCPU_SPR_VSR26 0x301A
+#define GSB_VCPU_SPR_VSR27 0x301B
+#define GSB_VCPU_SPR_VSR28 0x301C
+#define GSB_VCPU_SPR_VSR29 0x301D
+#define GSB_VCPU_SPR_VSR30 0x301E
+#define GSB_VCPU_SPR_VSR31 0x301F
+#define GSB_VCPU_SPR_VSR32 0x3020
+#define GSB_VCPU_SPR_VSR33 0x3021
+#define GSB_VCPU_SPR_VSR34 0x3022
+#define GSB_VCPU_SPR_VSR35 0x3023
+#define GSB_VCPU_SPR_VSR36 0x3024
+#define GSB_VCPU_SPR_VSR37 0x3025
+#define GSB_VCPU_SPR_VSR38 0x3026
+#define GSB_VCPU_SPR_VSR39 0x3027
+#define GSB_VCPU_SPR_VSR40 0x3028
+#define GSB_VCPU_SPR_VSR41 0x3029
+#define GSB_VCPU_SPR_VSR42 0x302A
+#define GSB_VCPU_SPR_VSR43 0x302B
+#define GSB_VCPU_SPR_VSR44 0x302C
+#define GSB_VCPU_SPR_VSR45 0x302D
+#define GSB_VCPU_SPR_VSR46 0x302E
+#define GSB_VCPU_SPR_VSR47 0x302F
+#define GSB_VCPU_SPR_VSR48 0x3030
+#define GSB_VCPU_SPR_VSR49 0x3031
+#define GSB_VCPU_SPR_VSR50 0x3032
+#define GSB_VCPU_SPR_VSR51 0x3033
+#define GSB_VCPU_SPR_VSR52 0x3034
+#define GSB_VCPU_SPR_VSR53 0x3035
+#define GSB_VCPU_SPR_VSR54 0x3036
+#define GSB_VCPU_SPR_VSR55 0x3037
+#define GSB_VCPU_SPR_VSR56 0x3038
+#define GSB_VCPU_SPR_VSR57 0x3039
+#define GSB_VCPU_SPR_VSR58 0x303A
+#define GSB_VCPU_SPR_VSR59 0x303B
+#define GSB_VCPU_SPR_VSR60 0x303C
+#define GSB_VCPU_SPR_VSR61 0x303D
+#define GSB_VCPU_SPR_VSR62 0x303E
+#define GSB_VCPU_SPR_VSR63 0x303F
+ /* RESERVED 0x3040 - 0xEFFF */
+#define GSB_VCPU_SPR_HDAR 0xF000
+#define GSB_VCPU_SPR_HDSISR 0xF001
+#define GSB_VCPU_SPR_HEIR 0xF002
+#define GSB_VCPU_SPR_ASDR 0xF003
+/* End of list of Guest State Buffer Element IDs */
+#define GSB_LAST GSB_VCPU_SPR_ASDR
+
typedef struct SpaprMachineStateNested {
uint64_t ptcr;
uint8_t api;
@@ -16,6 +201,8 @@ typedef struct SpaprMachineStateNested {
typedef struct SpaprMachineStateNestedGuest {
uint32_t pvr_logical;
unsigned long vcpus;
+ uint64_t parttbl[2];
+ uint64_t tb_offset;
struct SpaprMachineStateNestedGuestVcpu *vcpu;
} SpaprMachineStateNestedGuest;
@@ -31,6 +218,99 @@ typedef struct SpaprMachineStateNestedGuest {
#define PAPR_NESTED_GUEST_MAX 4096
#define H_GUEST_DELETE_ALL_FLAG 0x8000000000000000ULL
#define PAPR_NESTED_GUEST_VCPU_MAX 2048
+#define VCPU_OUT_BUF_MIN_SZ 0x80ULL
+#define HVMASK_DEFAULT 0xffffffffffffffff
+#define HVMASK_LPCR 0x0070000003820800
+#define HVMASK_MSR 0xEBFFFFFFFFBFEFFF
+#define HVMASK_HDEXCR 0x00000000FFFFFFFF
+#define HVMASK_TB_OFFSET 0x000000FFFFFFFFFF
+
+#define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
+ .id = (i), \
+ .size = (sz), \
+ .location = ptr, \
+ .offset = offsetof(struct s, f), \
+ .copy = (c) \
+}
+
+#define GSBE_NESTED(i, sz, f, c) { \
+ .id = (i), \
+ .size = (sz), \
+ .location = get_guest_ptr, \
+ .offset = offsetof(struct SpaprMachineStateNestedGuest, f),\
+ .copy = (c), \
+ .mask = HVMASK_DEFAULT \
+}
+
+#define GSBE_NESTED_MSK(i, sz, f, c, m) { \
+ .id = (i), \
+ .size = (sz), \
+ .location = get_guest_ptr, \
+ .offset = offsetof(struct SpaprMachineStateNestedGuest, f),\
+ .copy = (c), \
+ .mask = (m) \
+}
+
+#define GSBE_NESTED_VCPU(i, sz, f, c) { \
+ .id = (i), \
+ .size = (sz), \
+ .location = get_vcpu_ptr, \
+ .offset = offsetof(struct SpaprMachineStateNestedGuestVcpu, f),\
+ .copy = (c), \
+ .mask = HVMASK_DEFAULT \
+}
+
+#define GUEST_STATE_ELEMENT_NOP(i, sz) { \
+ .id = (i), \
+ .size = (sz), \
+ .location = NULL, \
+ .offset = 0, \
+ .copy = NULL, \
+ .mask = HVMASK_DEFAULT \
+}
+
+#define GUEST_STATE_ELEMENT_NOP_DW(i) \
+ GUEST_STATE_ELEMENT_NOP(i, 8)
+#define GUEST_STATE_ELEMENT_NOP_W(i) \
+ GUEST_STATE_ELEMENT_NOP(i, 4)
+
+#define GUEST_STATE_ELEMENT_BASE(i, s, c) { \
+ .id = (i), \
+ .size = (s), \
+ .location = get_vcpu_state_ptr, \
+ .offset = 0, \
+ .copy = (c), \
+ .mask = HVMASK_DEFAULT \
+ }
+
+#define GUEST_STATE_ELEMENT_OFF(i, s, f, c) { \
+ .id = (i), \
+ .size = (s), \
+ .location = get_vcpu_state_ptr, \
+ .offset = offsetof(struct nested_ppc_state, f), \
+ .copy = (c), \
+ .mask = HVMASK_DEFAULT \
+ }
+
+#define GUEST_STATE_ELEMENT_MSK(i, s, f, c, m) { \
+ .id = (i), \
+ .size = (s), \
+ .location = get_vcpu_state_ptr, \
+ .offset = offsetof(struct nested_ppc_state, f), \
+ .copy = (c), \
+ .mask = (m) \
+ }
+
+#define GUEST_STATE_ELEMENT_ENV_QW(i, f) \
+ GUEST_STATE_ELEMENT_OFF(i, 16, f, copy_state_16to16)
+#define GUEST_STATE_ELEMENT_ENV_DW(i, f) \
+ GUEST_STATE_ELEMENT_OFF(i, 8, f, copy_state_8to8)
+#define GUEST_STATE_ELEMENT_ENV_W(i, f) \
+ GUEST_STATE_ELEMENT_OFF(i, 4, f, copy_state_4to8)
+#define GUEST_STATE_ELEMENT_ENV_WW(i, f) \
+ GUEST_STATE_ELEMENT_OFF(i, 4, f, copy_state_4to4)
+#define GSE_ENV_DWM(i, f, m) \
+ GUEST_STATE_ELEMENT_MSK(i, 8, f, copy_state_8to8, m)
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
@@ -172,17 +452,40 @@ struct nested_ppc_state {
uint64_t sier;
uint32_t vscr;
uint64_t fpscr;
+ int64_t dec_expiry_tb;
+};
+
+struct SpaprMachineStateNestedGuestVcpuRunBuf {
+ uint64_t addr;
+ uint64_t size;
};
typedef struct SpaprMachineStateNestedGuestVcpu {
bool enabled;
struct nested_ppc_state state;
+ struct SpaprMachineStateNestedGuestVcpuRunBuf runbufin;
+ struct SpaprMachineStateNestedGuestVcpuRunBuf runbufout;
+ int64_t tb_offset;
+ uint64_t hdecr_expiry_tb;
} SpaprMachineStateNestedGuestVcpu;
+struct guest_state_element_type {
+ uint16_t id;
+ int size;
+#define GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE 0x1
+#define GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY 0x2
+ uint16_t flags;
+ void *(*location)(SpaprMachineStateNestedGuest *, target_ulong);
+ size_t offset;
+ void (*copy)(void *, void *, bool);
+ uint64_t mask;
+};
+
void spapr_exit_nested(PowerPCCPU *cpu, int excp);
typedef struct SpaprMachineState SpaprMachineState;
bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
target_ulong lpid, ppc_v3_pate_t *entry);
void spapr_nested_init(SpaprMachineState *spapr);
uint8_t spapr_nested_api(SpaprMachineState *spapr);
+void spapr_nested_gsb_init(void);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 39d0c087f1..faba27dd50 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -13,6 +13,7 @@ void spapr_nested_init(SpaprMachineState *spapr)
{
spapr->nested.api = 0;
spapr->nested.capabilities_set = false;
+ spapr_nested_gsb_init();
}
uint8_t spapr_nested_api(SpaprMachineState *spapr)
@@ -545,7 +546,7 @@ SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
}
static bool spapr_nested_vcpu_check(SpaprMachineStateNestedGuest *guest,
- target_ulong vcpuid)
+ target_ulong vcpuid, bool inoutbuf)
{
struct SpaprMachineStateNestedGuestVcpu *vcpu;
/*
@@ -566,7 +567,436 @@ static bool spapr_nested_vcpu_check(SpaprMachineStateNestedGuest *guest,
return false;
}
- return true;
+ if (!inoutbuf) {
+ return true;
+ }
+
+ /* Check to see if the in/out buffers are registered */
+ if (vcpu->runbufin.addr && vcpu->runbufout.addr) {
+ return true;
+ }
+
+ return false;
+}
+
+static void *get_vcpu_state_ptr(SpaprMachineStateNestedGuest *guest,
+ target_ulong vcpuid)
+{
+ assert(spapr_nested_vcpu_check(guest, vcpuid, false));
+ return &guest->vcpu[vcpuid].state;
+}
+
+static void *get_vcpu_ptr(SpaprMachineStateNestedGuest *guest,
+ target_ulong vcpuid)
+{
+ assert(spapr_nested_vcpu_check(guest, vcpuid, false));
+ return &guest->vcpu[vcpuid];
+}
+
+static void *get_guest_ptr(SpaprMachineStateNestedGuest *guest,
+ target_ulong vcpuid)
+{
+ return guest; /* for GSBE_NESTED */
+}
+
+/*
+ * set=1 means the L1 is trying to set some state
+ * set=0 means the L1 is trying to get some state
+ */
+static void copy_state_8to8(void *a, void *b, bool set)
+{
+ /* set takes from the Big endian element_buf and sets internal buffer */
+
+ if (set) {
+ *(uint64_t *)a = be64_to_cpu(*(uint64_t *)b);
+ } else {
+ *(uint64_t *)b = cpu_to_be64(*(uint64_t *)a);
+ }
+}
+
+static void copy_state_4to4(void *a, void *b, bool set)
+{
+ if (set) {
+ *(uint32_t *)a = be32_to_cpu(*(uint32_t *)b);
+ } else {
+ *(uint32_t *)b = cpu_to_be32(*((uint32_t *)a));
+ }
+}
+
+static void copy_state_16to16(void *a, void *b, bool set)
+{
+ uint64_t *src, *dst;
+
+ if (set) {
+ src = b;
+ dst = a;
+
+ dst[1] = be64_to_cpu(src[0]);
+ dst[0] = be64_to_cpu(src[1]);
+ } else {
+ src = a;
+ dst = b;
+
+ dst[1] = cpu_to_be64(src[0]);
+ dst[0] = cpu_to_be64(src[1]);
+ }
+}
+
+static void copy_state_4to8(void *a, void *b, bool set)
+{
+ if (set) {
+ *(uint64_t *)a = (uint64_t) be32_to_cpu(*(uint32_t *)b);
+ } else {
+ *(uint32_t *)b = cpu_to_be32((uint32_t) (*((uint64_t *)a)));
+ }
+}
+
+static void copy_state_pagetbl(void *a, void *b, bool set)
+{
+ uint64_t *pagetbl;
+ uint64_t *buf; /* 3 double words */
+ uint64_t rts;
+
+ assert(set);
+
+ pagetbl = a;
+ buf = b;
+
+ *pagetbl = be64_to_cpu(buf[0]);
+ /* as per ISA section 6.7.6.1 */
+ *pagetbl |= PATE0_HR; /* Host Radix bit is 1 */
+
+ /* RTS */
+ rts = be64_to_cpu(buf[1]);
+ assert(rts == 52);
+ rts = rts - 31; /* since radix tree size = 2^(RTS+31) */
+ *pagetbl |= ((rts & 0x7) << 5); /* RTS2 is bit 56:58 */
+ *pagetbl |= (((rts >> 3) & 0x3) << 61); /* RTS1 is bit 1:2 */
+
+ /* RPDS {Size = 2^(RPDS+3) , RPDS >=5} */
+ *pagetbl |= 63 - clz64(be64_to_cpu(buf[2])) - 3;
+}
+
+static void copy_state_proctbl(void *a, void *b, bool set)
+{
+ uint64_t *proctbl;
+ uint64_t *buf; /* 2 double words */
+
+ assert(set);
+
+ proctbl = a;
+ buf = b;
+ /* PRTB: Process Table Base */
+ *proctbl = be64_to_cpu(buf[0]);
+ /* PRTS: Process Table Size = 2^(12+PRTS) */
+ if (be64_to_cpu(buf[1]) == (1ULL << 12)) {
+ *proctbl |= 0;
+ } else if (be64_to_cpu(buf[1]) == (1ULL << 24)) {
+ *proctbl |= 12;
+ } else {
+ g_assert_not_reached();
+ }
+}
+
+static void copy_state_runbuf(void *a, void *b, bool set)
+{
+ uint64_t *buf; /* 2 double words */
+ struct SpaprMachineStateNestedGuestVcpuRunBuf *runbuf;
+
+ assert(set);
+
+ runbuf = a;
+ buf = b;
+
+ runbuf->addr = be64_to_cpu(buf[0]);
+ assert(runbuf->addr);
+
+ /* per spec */
+ assert(be64_to_cpu(buf[1]) <= 16384);
+
+ /*
+ * This will also hit in the input buffer but should be fine for
+ * now. If not we can split this function.
+ */
+ assert(be64_to_cpu(buf[1]) >= VCPU_OUT_BUF_MIN_SZ);
+
+ runbuf->size = be64_to_cpu(buf[1]);
+}
+
+/* tell the L1 how big we want the output vcpu run buffer */
+static void out_buf_min_size(void *a, void *b, bool set)
+{
+ uint64_t *buf; /* 1 double word */
+
+ assert(!set);
+
+ buf = b;
+
+ buf[0] = cpu_to_be64(VCPU_OUT_BUF_MIN_SZ);
+}
+
+static void copy_logical_pvr(void *a, void *b, bool set)
+{
+ uint32_t *buf; /* 1 word */
+ uint32_t *pvr_logical_ptr;
+ uint32_t pvr_logical;
+
+ pvr_logical_ptr = a;
+ buf = b;
+
+ if (!set) {
+ buf[0] = cpu_to_be32(*pvr_logical_ptr);
+ return;
+ }
+
+ pvr_logical = be32_to_cpu(buf[0]);
+
+ *pvr_logical_ptr = pvr_logical;
+}
+
+static void copy_tb_offset(void *a, void *b, bool set)
+{
+ SpaprMachineStateNestedGuest *guest;
+ uint64_t *buf; /* 1 double word */
+ uint64_t *tb_offset_ptr;
+ uint64_t tb_offset;
+
+ tb_offset_ptr = a;
+ buf = b;
+
+ if (!set) {
+ buf[0] = cpu_to_be64(*tb_offset_ptr);
+ return;
+ }
+
+ tb_offset = be64_to_cpu(buf[0]);
+ /* need to copy this to the individual tb_offset for each vcpu */
+ guest = container_of(tb_offset_ptr,
+ struct SpaprMachineStateNestedGuest,
+ tb_offset);
+ for (int i = 0; i < guest->vcpus; i++) {
+ guest->vcpu[i].tb_offset = tb_offset;
+ }
+}
+
+static void copy_state_hdecr(void *a, void *b, bool set)
+{
+ uint64_t *buf; /* 1 double word */
+ uint64_t *hdecr_expiry_tb;
+
+ hdecr_expiry_tb = a;
+ buf = b;
+
+ if (!set) {
+ buf[0] = cpu_to_be64(*hdecr_expiry_tb);
+ return;
+ }
+
+ *hdecr_expiry_tb = be64_to_cpu(buf[0]);
+}
+
+struct guest_state_element_type guest_state_element_types[] = {
+ GUEST_STATE_ELEMENT_NOP(GSB_HV_VCPU_IGNORED_ID, 0),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR0, gpr[0]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR1, gpr[1]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR2, gpr[2]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR3, gpr[3]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR4, gpr[4]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR5, gpr[5]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR6, gpr[6]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR7, gpr[7]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR8, gpr[8]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR9, gpr[9]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR10, gpr[10]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR11, gpr[11]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR12, gpr[12]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR13, gpr[13]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR14, gpr[14]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR15, gpr[15]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR16, gpr[16]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR17, gpr[17]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR18, gpr[18]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR19, gpr[19]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR20, gpr[20]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR21, gpr[21]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR22, gpr[22]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR23, gpr[23]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR24, gpr[24]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR25, gpr[25]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR26, gpr[26]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR27, gpr[27]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR28, gpr[28]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR29, gpr[29]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR30, gpr[30]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_GPR31, gpr[31]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_NIA, nip),
+ GSE_ENV_DWM(GSB_VCPU_SPR_MSR, msr, HVMASK_MSR),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_CTR, ctr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_LR, lr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_XER, xer),
+ GUEST_STATE_ELEMENT_ENV_WW(GSB_VCPU_SPR_CR, cr),
+ GUEST_STATE_ELEMENT_NOP_DW(GSB_VCPU_SPR_MMCR3),
+ GUEST_STATE_ELEMENT_NOP_DW(GSB_VCPU_SPR_SIER2),
+ GUEST_STATE_ELEMENT_NOP_DW(GSB_VCPU_SPR_SIER3),
+ GUEST_STATE_ELEMENT_NOP_W(GSB_VCPU_SPR_WORT),
+ GSE_ENV_DWM(GSB_VCPU_SPR_LPCR, lpcr, HVMASK_LPCR),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_AMOR, amor),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_HFSCR, hfscr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_DAWR0, dawr0),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_DAWRX0, dawrx0),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_CIABR, ciabr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_PURR, purr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SPURR, spurr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_IC, ic),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_VTB, vtb),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_HDAR, hdar),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_HDSISR, hdsisr),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_HEIR, heir),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_ASDR, asdr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SRR0, srr0),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SRR1, srr1),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SPRG0, sprg0),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SPRG1, sprg1),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SPRG2, sprg2),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SPRG3, sprg3),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PIDR, pidr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_CFAR, cfar),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_PPR, ppr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_DAWR1, dawr1),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_DAWRX1, dawrx1),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_DEXCR, dexcr),
+ GSE_ENV_DWM(GSB_VCPU_SPR_HDEXCR, hdexcr, HVMASK_HDEXCR),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_HASHKEYR, hashkeyr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_HASHPKEYR, hashpkeyr),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR0, vsr[0]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR1, vsr[1]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR2, vsr[2]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR3, vsr[3]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR4, vsr[4]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR5, vsr[5]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR6, vsr[6]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR7, vsr[7]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR8, vsr[8]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR9, vsr[9]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR10, vsr[10]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR11, vsr[11]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR12, vsr[12]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR13, vsr[13]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR14, vsr[14]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR15, vsr[15]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR16, vsr[16]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR17, vsr[17]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR18, vsr[18]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR19, vsr[19]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR20, vsr[20]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR21, vsr[21]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR22, vsr[22]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR23, vsr[23]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR24, vsr[24]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR25, vsr[25]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR26, vsr[26]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR27, vsr[27]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR28, vsr[28]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR29, vsr[29]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR30, vsr[30]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR31, vsr[31]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR32, vsr[32]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR33, vsr[33]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR34, vsr[34]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR35, vsr[35]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR36, vsr[36]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR37, vsr[37]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR38, vsr[38]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR39, vsr[39]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR40, vsr[40]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR41, vsr[41]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR42, vsr[42]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR43, vsr[43]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR44, vsr[44]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR45, vsr[45]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR46, vsr[46]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR47, vsr[47]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR48, vsr[48]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR49, vsr[49]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR50, vsr[50]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR51, vsr[51]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR52, vsr[52]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR53, vsr[53]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR54, vsr[54]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR55, vsr[55]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR56, vsr[56]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR57, vsr[57]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR58, vsr[58]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR59, vsr[59]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR60, vsr[60]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR61, vsr[61]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR62, vsr[62]),
+ GUEST_STATE_ELEMENT_ENV_QW(GSB_VCPU_SPR_VSR63, vsr[63]),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_EBBHR, ebbhr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_TAR, tar),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_EBBRR, ebbrr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_BESCR, bescr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_IAMR, iamr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_AMR, amr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_UAMOR, uamor),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_DSCR, dscr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_FSCR, fscr),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PSPB, pspb),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_CTRL, ctrl),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_VRSAVE, vrsave),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_DAR, dar),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_DSISR, dsisr),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC1, pmc1),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC2, pmc2),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC3, pmc3),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC4, pmc4),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC5, pmc5),
+ GUEST_STATE_ELEMENT_ENV_W(GSB_VCPU_SPR_PMC6, pmc6),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_MMCR0, mmcr0),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_MMCR1, mmcr1),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_MMCR2, mmcr2),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_MMCRA, mmcra),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SDAR , sdar),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SIAR , siar),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_SIER , sier),
+ GUEST_STATE_ELEMENT_ENV_WW(GSB_VCPU_SPR_VSCR, vscr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_SPR_FPSCR, fpscr),
+ GUEST_STATE_ELEMENT_ENV_DW(GSB_VCPU_DEC_EXPIRE_TB, dec_expiry_tb),
+ GSBE_NESTED(GSB_PART_SCOPED_PAGETBL, 0x18, parttbl[0], copy_state_pagetbl),
+ GSBE_NESTED(GSB_PROCESS_TBL, 0x10, parttbl[1], copy_state_proctbl),
+ GSBE_NESTED(GSB_VCPU_LPVR, 0x4, pvr_logical, copy_logical_pvr),
+ GSBE_NESTED_MSK(GSB_TB_OFFSET, 0x8, tb_offset, copy_tb_offset,
+ HVMASK_TB_OFFSET),
+ GSBE_NESTED_VCPU(GSB_VCPU_IN_BUFFER, 0x10, runbufin, copy_state_runbuf),
+ GSBE_NESTED_VCPU(GSB_VCPU_OUT_BUFFER, 0x10, runbufout, copy_state_runbuf),
+ GSBE_NESTED_VCPU(GSB_VCPU_OUT_BUF_MIN_SZ, 0x8, runbufout, out_buf_min_size),
+ GSBE_NESTED_VCPU(GSB_VCPU_HDEC_EXPIRY_TB, 0x8, hdecr_expiry_tb,
+ copy_state_hdecr)
+};
+
+void spapr_nested_gsb_init(void)
+{
+ struct guest_state_element_type *type;
+
+ /* Init the guest state elements lookup table, flags for now */
+ for (int i = 0; i < ARRAY_SIZE(guest_state_element_types); i++) {
+ type = &guest_state_element_types[i];
+
+ assert(type->id <= GSB_LAST);
+ if (type->id >= GSB_VCPU_SPR_HDAR)
+ /* 0xf000 - 0xf005 Thread + RO */
+ type->flags = GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY;
+ else if (type->id >= GSB_VCPU_IN_BUFFER)
+ /* 0x0c00 - 0xf000 Thread + RW */
+ type->flags = 0;
+ else if (type->id >= GSB_VCPU_LPVR)
+ /* 0x0003 - 0x0bff Guest + RW */
+ type->flags = GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE;
+ else if (type->id >= GSB_HV_VCPU_STATE_SIZE)
+ /* 0x0001 - 0x0002 Guest + RO */
+ type->flags = GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY |
+ GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE;
+ }
}
static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
@@ -808,7 +1238,7 @@ static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
l2_state->pvr = env->spr[SPR_PVR];
guest->vcpu[vcpuid].enabled = true;
- if (!spapr_nested_vcpu_check(guest, vcpuid)) {
+ if (!spapr_nested_vcpu_check(guest, vcpuid, false)) {
return H_PARAMETER;
}
return H_SUCCESS;
@@ -865,4 +1295,10 @@ void spapr_register_nested_papr(void)
{
/* DO NOTHING */
}
+
+void spapr_nested_gsb_init(void)
+{
+ /* DO NOTHING */
+}
+
#endif
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table.
2024-02-20 8:36 ` [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table Harsh Prateek Bora
@ 2024-02-27 10:02 ` Nicholas Piggin
2024-02-29 10:29 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:02 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> Nested PAPR API provides a standard Guest State Buffer (GSB) format
> with unique IDs for each guest state element for which get/set state is
> supported by the API. Some of the elements are read-only and/or guest-wide.
> Introducing helper routines for state exchange of each of the nested guest
> state elements for which get/set state should be supported by the API.
>
This is doing more than just adding helper routines for the GSB access.
[snip]
> +
> typedef struct SpaprMachineStateNested {
> uint64_t ptcr;
> uint8_t api;
> @@ -16,6 +201,8 @@ typedef struct SpaprMachineStateNested {
> typedef struct SpaprMachineStateNestedGuest {
> uint32_t pvr_logical;
> unsigned long vcpus;
> + uint64_t parttbl[2];
> + uint64_t tb_offset;
> struct SpaprMachineStateNestedGuestVcpu *vcpu;
> } SpaprMachineStateNestedGuest;
>
[snip]
>
> /*
> * Register state for entering a nested guest with H_ENTER_NESTED.
> @@ -172,17 +452,40 @@ struct nested_ppc_state {
> uint64_t sier;
> uint32_t vscr;
> uint64_t fpscr;
> + int64_t dec_expiry_tb;
> +};
> +
> +struct SpaprMachineStateNestedGuestVcpuRunBuf {
> + uint64_t addr;
> + uint64_t size;
> };
>
> typedef struct SpaprMachineStateNestedGuestVcpu {
> bool enabled;
> struct nested_ppc_state state;
> + struct SpaprMachineStateNestedGuestVcpuRunBuf runbufin;
> + struct SpaprMachineStateNestedGuestVcpuRunBuf runbufout;
> + int64_t tb_offset;
> + uint64_t hdecr_expiry_tb;
> } SpaprMachineStateNestedGuestVcpu;
It's adding new fields in existing nested guest state
structures. This should be explained a bit more, split into
another patch, or moved to patches where they get used.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table.
2024-02-27 10:02 ` Nicholas Piggin
@ 2024-02-29 10:29 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-29 10:29 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 15:32, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> Nested PAPR API provides a standard Guest State Buffer (GSB) format
>> with unique IDs for each guest state element for which get/set state is
>> supported by the API. Some of the elements are read-only and/or guest-wide.
>> Introducing helper routines for state exchange of each of the nested guest
>> state elements for which get/set state should be supported by the API.
>>
>
> This is doing more than just adding helper routines for the GSB access.
Yes, some of the GSB elements are also introduced along with respective
helpers.
>
> [snip]
>
>> +
>> typedef struct SpaprMachineStateNested {
>> uint64_t ptcr;
>> uint8_t api;
>> @@ -16,6 +201,8 @@ typedef struct SpaprMachineStateNested {
>> typedef struct SpaprMachineStateNestedGuest {
>> uint32_t pvr_logical;
>> unsigned long vcpus;
>> + uint64_t parttbl[2];
>> + uint64_t tb_offset;
>> struct SpaprMachineStateNestedGuestVcpu *vcpu;
>> } SpaprMachineStateNestedGuest;
>>
> [snip]
>
>>
>> /*
>> * Register state for entering a nested guest with H_ENTER_NESTED.
>> @@ -172,17 +452,40 @@ struct nested_ppc_state {
>> uint64_t sier;
>> uint32_t vscr;
>> uint64_t fpscr;
>> + int64_t dec_expiry_tb;
>> +};
>> +
>> +struct SpaprMachineStateNestedGuestVcpuRunBuf {
>> + uint64_t addr;
>> + uint64_t size;
>> };
>>
>> typedef struct SpaprMachineStateNestedGuestVcpu {
>> bool enabled;
>> struct nested_ppc_state state;
>> + struct SpaprMachineStateNestedGuestVcpuRunBuf runbufin;
>> + struct SpaprMachineStateNestedGuestVcpuRunBuf runbufout;
>> + int64_t tb_offset;
>> + uint64_t hdecr_expiry_tb;
>> } SpaprMachineStateNestedGuestVcpu;
>
> It's adding new fields in existing nested guest state
> structures. This should be explained a bit more, split into
> another patch, or moved to patches where they get used.
Yes, these new fields are actually representing GSB elements.
These elements were explained in the documentation patch which shall now
point to the documentation in the kernel docs as suggested earlier.
Let me know if we need to document additionally in this patch commit log
also.
regards,
Harsh
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (9 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 10/15] spapr: nested: Initialize the GSB elements lookup table Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 10:10 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API Harsh Prateek Bora
` (3 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Introduce the nested PAPR hcalls:
- H_GUEST_GET_STATE which is used to get state of a nested guest or
a guest VCPU. The value field for each element in the request is
ignored and on success, will be updated to reflect current state.
- H_GUEST_SET_STATE which is used to modify the state of a guest or
a guest VCPU. On success, guest (or its VCPU) state shall be
updated as per the value field for the requested element(s).
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 3 +
include/hw/ppc/spapr_nested.h | 23 +++
hw/ppc/spapr_nested.c | 267 ++++++++++++++++++++++++++++++++++
3 files changed, 293 insertions(+)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index 82b077bdd2..aabc32f268 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -366,6 +366,7 @@ struct SpaprMachineState {
#define H_OVERLAP -68
#define H_STATE -75
#define H_IN_USE -77
+#define H_INVALID_ELEMENT_VALUE -81
#define H_UNSUPPORTED_FLAG -256
#define H_MULTI_THREADS_ACTIVE -9005
@@ -589,6 +590,8 @@ struct SpaprMachineState {
#define H_GUEST_SET_CAPABILITIES 0x464
#define H_GUEST_CREATE 0x470
#define H_GUEST_CREATE_VCPU 0x474
+#define H_GUEST_GET_STATE 0x478
+#define H_GUEST_SET_STATE 0x47C
#define H_GUEST_DELETE 0x488
#define MAX_HCALL_OPCODE H_GUEST_DELETE
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 492302a21d..1b7e55f12a 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -224,6 +224,10 @@ typedef struct SpaprMachineStateNestedGuest {
#define HVMASK_MSR 0xEBFFFFFFFFBFEFFF
#define HVMASK_HDEXCR 0x00000000FFFFFFFF
#define HVMASK_TB_OFFSET 0x000000FFFFFFFFFF
+#define GSB_MAX_BUF_SIZE (1024 * 1024)
+#define H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE 0x8000000000000000
+#define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
+#define GUEST_STATE_REQUEST_SET 0x2
#define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
.id = (i), \
@@ -312,6 +316,25 @@ typedef struct SpaprMachineStateNestedGuest {
#define GSE_ENV_DWM(i, f, m) \
GUEST_STATE_ELEMENT_MSK(i, 8, f, copy_state_8to8, m)
+struct guest_state_element {
+ uint16_t id;
+ uint16_t size;
+ uint8_t value[];
+} QEMU_PACKED;
+
+struct guest_state_buffer {
+ uint32_t num_elements;
+ struct guest_state_element elements[];
+} QEMU_PACKED;
+
+/* Actual buffer plus some metadata about the request */
+struct guest_state_request {
+ struct guest_state_buffer *gsb;
+ int64_t buf;
+ int64_t len;
+ uint16_t flags;
+};
+
/*
* Register state for entering a nested guest with H_ENTER_NESTED.
* New member must be added at the end.
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index faba27dd50..aba4b25da6 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -8,6 +8,7 @@
#include "hw/ppc/spapr_nested.h"
#include "mmu-book3s-v3.h"
#include "cpu-models.h"
+#include "qemu/log.h"
void spapr_nested_init(SpaprMachineState *spapr)
{
@@ -999,6 +1000,140 @@ void spapr_nested_gsb_init(void)
}
}
+static struct guest_state_element *guest_state_element_next(
+ struct guest_state_element *element,
+ int64_t *len,
+ int64_t *num_elements)
+{
+ uint16_t size;
+
+ /* size is of element->value[] only. Not whole guest_state_element */
+ size = be16_to_cpu(element->size);
+
+ if (len) {
+ *len -= size + offsetof(struct guest_state_element, value);
+ }
+
+ if (num_elements) {
+ *num_elements -= 1;
+ }
+
+ return (struct guest_state_element *)(element->value + size);
+}
+
+static
+struct guest_state_element_type *guest_state_element_type_find(uint16_t id)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(guest_state_element_types); i++)
+ if (id == guest_state_element_types[i].id) {
+ return &guest_state_element_types[i];
+ }
+
+ return NULL;
+}
+
+static void log_element(struct guest_state_element *element,
+ struct guest_state_request *gsr)
+{
+ qemu_log_mask(LOG_GUEST_ERROR, "h_guest_%s_state id:0x%04x size:0x%04x",
+ gsr->flags & GUEST_STATE_REQUEST_SET ? "set" : "get",
+ be16_to_cpu(element->id), be16_to_cpu(element->size));
+ qemu_log_mask(LOG_GUEST_ERROR, "buf:0x%016lx ...\n",
+ be64_to_cpu(*(uint64_t *)element->value));
+}
+
+static bool guest_state_request_check(struct guest_state_request *gsr)
+{
+ int64_t num_elements, len = gsr->len;
+ struct guest_state_buffer *gsb = gsr->gsb;
+ struct guest_state_element *element;
+ struct guest_state_element_type *type;
+ uint16_t id, size;
+
+ /* gsb->num_elements = 0 == 32 bits long */
+ assert(len >= 4);
+
+ num_elements = be32_to_cpu(gsb->num_elements);
+ element = gsb->elements;
+ len -= sizeof(gsb->num_elements);
+
+ /* Walk the buffer to validate the length */
+ while (num_elements) {
+
+ id = be16_to_cpu(element->id);
+ size = be16_to_cpu(element->size);
+
+ if (false) {
+ log_element(element, gsr);
+ }
+ /* buffer size too small */
+ if (len < 0) {
+ return false;
+ }
+
+ type = guest_state_element_type_find(id);
+ if (!type) {
+ qemu_log_mask(LOG_GUEST_ERROR,"Element ID %04x unknown\n", id);
+ log_element(element, gsr);
+ return false;
+ }
+
+ if (id == GSB_HV_VCPU_IGNORED_ID) {
+ goto next_element;
+ }
+
+ if (size != type->size) {
+ qemu_log_mask(LOG_GUEST_ERROR,"Size mismatch. Element ID:%04x."
+ "Size Exp:%i Got:%i\n", id, type->size, size);
+ log_element(element, gsr);
+ return false;
+ }
+
+ if ((type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY) &&
+ (gsr->flags & GUEST_STATE_REQUEST_SET)) {
+ qemu_log_mask(LOG_GUEST_ERROR,"trying to set a read-only Element "
+ "ID:%04x.\n", id);
+ return false;
+ }
+
+ if (type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE) {
+ /* guest wide element type */
+ if (!(gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE)) {
+ qemu_log_mask(LOG_GUEST_ERROR, "trying to set a guest wide "
+ "Element ID:%04x.\n", id);
+ return false;
+ }
+ } else {
+ /* thread wide element type */
+ if (gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE) {
+ qemu_log_mask(LOG_GUEST_ERROR, "trying to set a thread wide "
+ "Element ID:%04x.\n", id);
+ return false;
+ }
+ }
+next_element:
+ element = guest_state_element_next(element, &len, &num_elements);
+
+ }
+ return true;
+}
+
+static bool is_gsr_invalid(struct guest_state_request *gsr,
+ struct guest_state_element *element,
+ struct guest_state_element_type *type)
+{
+ if ((gsr->flags & GUEST_STATE_REQUEST_SET) &&
+ (*(uint64_t *)(element->value) & ~(type->mask))) {
+ log_element(element, gsr);
+ qemu_log_mask(LOG_GUEST_ERROR, "L1 can't set reserved bits i"
+ "(allowed mask: 0x%08lx)\n", type->mask);
+ return true;
+ }
+ return false;
+}
+
static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
SpaprMachineState *spapr,
target_ulong opcode,
@@ -1244,6 +1379,136 @@ static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
return H_SUCCESS;
}
+static target_ulong getset_state(SpaprMachineStateNestedGuest *guest,
+ uint64_t vcpuid,
+ struct guest_state_request *gsr)
+{
+ void *ptr;
+ uint16_t id;
+ struct guest_state_element *element;
+ struct guest_state_element_type *type;
+ int64_t lenleft, num_elements;
+
+ lenleft = gsr->len;
+
+ if (!guest_state_request_check(gsr)) {
+ return H_P3;
+ }
+
+ num_elements = be32_to_cpu(gsr->gsb->num_elements);
+ element = gsr->gsb->elements;
+ /* Process the elements */
+ while (num_elements) {
+ type = NULL;
+ /* log_element(element, gsr); */
+
+ id = be16_to_cpu(element->id);
+ if (id == GSB_HV_VCPU_IGNORED_ID) {
+ goto next_element;
+ }
+
+ type = guest_state_element_type_find(id);
+ assert(type);
+
+ /* Get pointer to guest data to get/set */
+ if (type->location && type->copy) {
+ ptr = type->location(guest, vcpuid);
+ assert(ptr);
+ if (!~(type->mask) && is_gsr_invalid(gsr, element, type)) {
+ return H_INVALID_ELEMENT_VALUE;
+ }
+ type->copy(ptr + type->offset, element->value,
+ gsr->flags & GUEST_STATE_REQUEST_SET ? true : false);
+ }
+
+next_element:
+ element = guest_state_element_next(element, &lenleft, &num_elements);
+ }
+
+ return H_SUCCESS;
+}
+
+static target_ulong map_and_getset_state(PowerPCCPU *cpu,
+ SpaprMachineStateNestedGuest *guest,
+ uint64_t vcpuid,
+ struct guest_state_request *gsr)
+{
+ target_ulong rc;
+ int64_t len;
+ bool is_write;
+
+ len = gsr->len;
+ /* only get_state would require write access to the provided buffer */
+ is_write = (gsr->flags & GUEST_STATE_REQUEST_SET) ? false : true;
+ gsr->gsb = address_space_map(CPU(cpu)->as, gsr->buf, (uint64_t *)&len,
+ is_write, MEMTXATTRS_UNSPECIFIED);
+ if (!gsr->gsb) {
+ rc = H_P3;
+ goto out1;
+ }
+
+ if (len != gsr->len) {
+ rc = H_P3;
+ goto out1;
+ }
+
+ rc = getset_state(guest, vcpuid, gsr);
+
+out1:
+ address_space_unmap(CPU(cpu)->as, gsr->gsb, len, is_write, len);
+ return rc;
+}
+
+static target_ulong h_guest_getset_state(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong *args,
+ bool set)
+{
+ target_ulong flags = args[0];
+ target_ulong lpid = args[1];
+ target_ulong vcpuid = args[2];
+ target_ulong buf = args[3];
+ target_ulong buflen = args[4];
+ struct guest_state_request gsr;
+ SpaprMachineStateNestedGuest *guest;
+
+ guest = spapr_get_nested_guest(spapr, lpid);
+ if (!guest) {
+ return H_P2;
+ }
+ gsr.buf = buf;
+ assert(buflen <= GSB_MAX_BUF_SIZE);
+ gsr.len = buflen;
+ gsr.flags = 0;
+ if (flags & H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
+ gsr.flags |= GUEST_STATE_REQUEST_GUEST_WIDE;
+ }
+ if (flags & !H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
+ return H_PARAMETER; /* flag not supported yet */
+ }
+
+ if (set) {
+ gsr.flags |= GUEST_STATE_REQUEST_SET;
+ }
+ return map_and_getset_state(cpu, guest, vcpuid, &gsr);
+}
+
+static target_ulong h_guest_set_state(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ return h_guest_getset_state(cpu, spapr, args, true);
+}
+
+static target_ulong h_guest_get_state(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ return h_guest_getset_state(cpu, spapr, args, false);
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
@@ -1267,6 +1532,8 @@ void spapr_register_nested_papr(void)
spapr_register_hypercall(H_GUEST_CREATE , h_guest_create);
spapr_register_hypercall(H_GUEST_DELETE , h_guest_delete);
spapr_register_hypercall(H_GUEST_CREATE_VCPU , h_guest_create_vcpu);
+ spapr_register_hypercall(H_GUEST_SET_STATE , h_guest_set_state);
+ spapr_register_hypercall(H_GUEST_GET_STATE , h_guest_get_state);
}
#else
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls.
2024-02-20 8:36 ` [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls Harsh Prateek Bora
@ 2024-02-27 10:10 ` Nicholas Piggin
2024-03-05 8:19 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:10 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> Introduce the nested PAPR hcalls:
> - H_GUEST_GET_STATE which is used to get state of a nested guest or
> a guest VCPU. The value field for each element in the request is
> ignored and on success, will be updated to reflect current state.
This is a bit hard to parse. The value fields are destinations for
values to be stored (from the point of view of the caller), which is
familiar to most get or read type APIs.
I don't think you need to say it's ignored. The value it contains is
ignored and overwritten, but the field itself is not actually ignored :)
Patch looks okay though.
> - H_GUEST_SET_STATE which is used to modify the state of a guest or
> a guest VCPU. On success, guest (or its VCPU) state shall be
> updated as per the value field for the requested element(s).
>
> Signed-off-by: Michael Neuling <mikey@neuling.org>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> include/hw/ppc/spapr.h | 3 +
> include/hw/ppc/spapr_nested.h | 23 +++
> hw/ppc/spapr_nested.c | 267 ++++++++++++++++++++++++++++++++++
> 3 files changed, 293 insertions(+)
>
> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> index 82b077bdd2..aabc32f268 100644
> --- a/include/hw/ppc/spapr.h
> +++ b/include/hw/ppc/spapr.h
> @@ -366,6 +366,7 @@ struct SpaprMachineState {
> #define H_OVERLAP -68
> #define H_STATE -75
> #define H_IN_USE -77
> +#define H_INVALID_ELEMENT_VALUE -81
> #define H_UNSUPPORTED_FLAG -256
> #define H_MULTI_THREADS_ACTIVE -9005
>
> @@ -589,6 +590,8 @@ struct SpaprMachineState {
> #define H_GUEST_SET_CAPABILITIES 0x464
> #define H_GUEST_CREATE 0x470
> #define H_GUEST_CREATE_VCPU 0x474
> +#define H_GUEST_GET_STATE 0x478
> +#define H_GUEST_SET_STATE 0x47C
> #define H_GUEST_DELETE 0x488
>
> #define MAX_HCALL_OPCODE H_GUEST_DELETE
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index 492302a21d..1b7e55f12a 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -224,6 +224,10 @@ typedef struct SpaprMachineStateNestedGuest {
> #define HVMASK_MSR 0xEBFFFFFFFFBFEFFF
> #define HVMASK_HDEXCR 0x00000000FFFFFFFF
> #define HVMASK_TB_OFFSET 0x000000FFFFFFFFFF
> +#define GSB_MAX_BUF_SIZE (1024 * 1024)
> +#define H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE 0x8000000000000000
> +#define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
> +#define GUEST_STATE_REQUEST_SET 0x2
>
> #define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
> .id = (i), \
> @@ -312,6 +316,25 @@ typedef struct SpaprMachineStateNestedGuest {
> #define GSE_ENV_DWM(i, f, m) \
> GUEST_STATE_ELEMENT_MSK(i, 8, f, copy_state_8to8, m)
>
> +struct guest_state_element {
> + uint16_t id;
> + uint16_t size;
> + uint8_t value[];
> +} QEMU_PACKED;
> +
> +struct guest_state_buffer {
> + uint32_t num_elements;
> + struct guest_state_element elements[];
> +} QEMU_PACKED;
> +
> +/* Actual buffer plus some metadata about the request */
> +struct guest_state_request {
> + struct guest_state_buffer *gsb;
> + int64_t buf;
> + int64_t len;
> + uint16_t flags;
> +};
> +
> /*
> * Register state for entering a nested guest with H_ENTER_NESTED.
> * New member must be added at the end.
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index faba27dd50..aba4b25da6 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -8,6 +8,7 @@
> #include "hw/ppc/spapr_nested.h"
> #include "mmu-book3s-v3.h"
> #include "cpu-models.h"
> +#include "qemu/log.h"
>
> void spapr_nested_init(SpaprMachineState *spapr)
> {
> @@ -999,6 +1000,140 @@ void spapr_nested_gsb_init(void)
> }
> }
>
> +static struct guest_state_element *guest_state_element_next(
> + struct guest_state_element *element,
> + int64_t *len,
> + int64_t *num_elements)
> +{
> + uint16_t size;
> +
> + /* size is of element->value[] only. Not whole guest_state_element */
> + size = be16_to_cpu(element->size);
> +
> + if (len) {
> + *len -= size + offsetof(struct guest_state_element, value);
> + }
> +
> + if (num_elements) {
> + *num_elements -= 1;
> + }
> +
> + return (struct guest_state_element *)(element->value + size);
> +}
> +
> +static
> +struct guest_state_element_type *guest_state_element_type_find(uint16_t id)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(guest_state_element_types); i++)
> + if (id == guest_state_element_types[i].id) {
> + return &guest_state_element_types[i];
> + }
> +
> + return NULL;
> +}
> +
> +static void log_element(struct guest_state_element *element,
> + struct guest_state_request *gsr)
> +{
> + qemu_log_mask(LOG_GUEST_ERROR, "h_guest_%s_state id:0x%04x size:0x%04x",
> + gsr->flags & GUEST_STATE_REQUEST_SET ? "set" : "get",
> + be16_to_cpu(element->id), be16_to_cpu(element->size));
> + qemu_log_mask(LOG_GUEST_ERROR, "buf:0x%016lx ...\n",
> + be64_to_cpu(*(uint64_t *)element->value));
> +}
> +
> +static bool guest_state_request_check(struct guest_state_request *gsr)
> +{
> + int64_t num_elements, len = gsr->len;
> + struct guest_state_buffer *gsb = gsr->gsb;
> + struct guest_state_element *element;
> + struct guest_state_element_type *type;
> + uint16_t id, size;
> +
> + /* gsb->num_elements = 0 == 32 bits long */
> + assert(len >= 4);
> +
> + num_elements = be32_to_cpu(gsb->num_elements);
> + element = gsb->elements;
> + len -= sizeof(gsb->num_elements);
> +
> + /* Walk the buffer to validate the length */
> + while (num_elements) {
> +
> + id = be16_to_cpu(element->id);
> + size = be16_to_cpu(element->size);
> +
> + if (false) {
> + log_element(element, gsr);
> + }
> + /* buffer size too small */
> + if (len < 0) {
> + return false;
> + }
> +
> + type = guest_state_element_type_find(id);
> + if (!type) {
> + qemu_log_mask(LOG_GUEST_ERROR,"Element ID %04x unknown\n", id);
> + log_element(element, gsr);
> + return false;
> + }
> +
> + if (id == GSB_HV_VCPU_IGNORED_ID) {
> + goto next_element;
> + }
> +
> + if (size != type->size) {
> + qemu_log_mask(LOG_GUEST_ERROR,"Size mismatch. Element ID:%04x."
> + "Size Exp:%i Got:%i\n", id, type->size, size);
> + log_element(element, gsr);
> + return false;
> + }
> +
> + if ((type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY) &&
> + (gsr->flags & GUEST_STATE_REQUEST_SET)) {
> + qemu_log_mask(LOG_GUEST_ERROR,"trying to set a read-only Element "
> + "ID:%04x.\n", id);
> + return false;
> + }
> +
> + if (type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE) {
> + /* guest wide element type */
> + if (!(gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE)) {
> + qemu_log_mask(LOG_GUEST_ERROR, "trying to set a guest wide "
> + "Element ID:%04x.\n", id);
> + return false;
> + }
> + } else {
> + /* thread wide element type */
> + if (gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE) {
> + qemu_log_mask(LOG_GUEST_ERROR, "trying to set a thread wide "
> + "Element ID:%04x.\n", id);
> + return false;
> + }
> + }
> +next_element:
> + element = guest_state_element_next(element, &len, &num_elements);
> +
> + }
> + return true;
> +}
> +
> +static bool is_gsr_invalid(struct guest_state_request *gsr,
> + struct guest_state_element *element,
> + struct guest_state_element_type *type)
> +{
> + if ((gsr->flags & GUEST_STATE_REQUEST_SET) &&
> + (*(uint64_t *)(element->value) & ~(type->mask))) {
> + log_element(element, gsr);
> + qemu_log_mask(LOG_GUEST_ERROR, "L1 can't set reserved bits i"
> + "(allowed mask: 0x%08lx)\n", type->mask);
> + return true;
> + }
> + return false;
> +}
> +
> static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
> SpaprMachineState *spapr,
> target_ulong opcode,
> @@ -1244,6 +1379,136 @@ static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
> return H_SUCCESS;
> }
>
> +static target_ulong getset_state(SpaprMachineStateNestedGuest *guest,
> + uint64_t vcpuid,
> + struct guest_state_request *gsr)
> +{
> + void *ptr;
> + uint16_t id;
> + struct guest_state_element *element;
> + struct guest_state_element_type *type;
> + int64_t lenleft, num_elements;
> +
> + lenleft = gsr->len;
> +
> + if (!guest_state_request_check(gsr)) {
> + return H_P3;
> + }
> +
> + num_elements = be32_to_cpu(gsr->gsb->num_elements);
> + element = gsr->gsb->elements;
> + /* Process the elements */
> + while (num_elements) {
> + type = NULL;
> + /* log_element(element, gsr); */
> +
> + id = be16_to_cpu(element->id);
> + if (id == GSB_HV_VCPU_IGNORED_ID) {
> + goto next_element;
> + }
> +
> + type = guest_state_element_type_find(id);
> + assert(type);
> +
> + /* Get pointer to guest data to get/set */
> + if (type->location && type->copy) {
> + ptr = type->location(guest, vcpuid);
> + assert(ptr);
> + if (!~(type->mask) && is_gsr_invalid(gsr, element, type)) {
> + return H_INVALID_ELEMENT_VALUE;
> + }
> + type->copy(ptr + type->offset, element->value,
> + gsr->flags & GUEST_STATE_REQUEST_SET ? true : false);
> + }
> +
> +next_element:
> + element = guest_state_element_next(element, &lenleft, &num_elements);
> + }
> +
> + return H_SUCCESS;
> +}
> +
> +static target_ulong map_and_getset_state(PowerPCCPU *cpu,
> + SpaprMachineStateNestedGuest *guest,
> + uint64_t vcpuid,
> + struct guest_state_request *gsr)
> +{
> + target_ulong rc;
> + int64_t len;
> + bool is_write;
> +
> + len = gsr->len;
> + /* only get_state would require write access to the provided buffer */
> + is_write = (gsr->flags & GUEST_STATE_REQUEST_SET) ? false : true;
> + gsr->gsb = address_space_map(CPU(cpu)->as, gsr->buf, (uint64_t *)&len,
> + is_write, MEMTXATTRS_UNSPECIFIED);
> + if (!gsr->gsb) {
> + rc = H_P3;
> + goto out1;
> + }
> +
> + if (len != gsr->len) {
> + rc = H_P3;
> + goto out1;
> + }
> +
> + rc = getset_state(guest, vcpuid, gsr);
> +
> +out1:
> + address_space_unmap(CPU(cpu)->as, gsr->gsb, len, is_write, len);
> + return rc;
> +}
> +
> +static target_ulong h_guest_getset_state(PowerPCCPU *cpu,
> + SpaprMachineState *spapr,
> + target_ulong *args,
> + bool set)
> +{
> + target_ulong flags = args[0];
> + target_ulong lpid = args[1];
> + target_ulong vcpuid = args[2];
> + target_ulong buf = args[3];
> + target_ulong buflen = args[4];
> + struct guest_state_request gsr;
> + SpaprMachineStateNestedGuest *guest;
> +
> + guest = spapr_get_nested_guest(spapr, lpid);
> + if (!guest) {
> + return H_P2;
> + }
> + gsr.buf = buf;
> + assert(buflen <= GSB_MAX_BUF_SIZE);
> + gsr.len = buflen;
> + gsr.flags = 0;
> + if (flags & H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
> + gsr.flags |= GUEST_STATE_REQUEST_GUEST_WIDE;
> + }
> + if (flags & !H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
> + return H_PARAMETER; /* flag not supported yet */
> + }
> +
> + if (set) {
> + gsr.flags |= GUEST_STATE_REQUEST_SET;
> + }
> + return map_and_getset_state(cpu, guest, vcpuid, &gsr);
> +}
> +
> +static target_ulong h_guest_set_state(PowerPCCPU *cpu,
> + SpaprMachineState *spapr,
> + target_ulong opcode,
> + target_ulong *args)
> +{
> + return h_guest_getset_state(cpu, spapr, args, true);
> +}
> +
> +static target_ulong h_guest_get_state(PowerPCCPU *cpu,
> + SpaprMachineState *spapr,
> + target_ulong opcode,
> + target_ulong *args)
> +{
> + return h_guest_getset_state(cpu, spapr, args, false);
> +}
> +
> void spapr_register_nested_hv(void)
> {
> spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
> @@ -1267,6 +1532,8 @@ void spapr_register_nested_papr(void)
> spapr_register_hypercall(H_GUEST_CREATE , h_guest_create);
> spapr_register_hypercall(H_GUEST_DELETE , h_guest_delete);
> spapr_register_hypercall(H_GUEST_CREATE_VCPU , h_guest_create_vcpu);
> + spapr_register_hypercall(H_GUEST_SET_STATE , h_guest_set_state);
> + spapr_register_hypercall(H_GUEST_GET_STATE , h_guest_get_state);
Are these also supposed to to add unregister calls?
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls.
2024-02-27 10:10 ` Nicholas Piggin
@ 2024-03-05 8:19 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-03-05 8:19 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Hi Nick,
On 2/27/24 15:40, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> Introduce the nested PAPR hcalls:
>> - H_GUEST_GET_STATE which is used to get state of a nested guest or
>> a guest VCPU. The value field for each element in the request is
>> ignored and on success, will be updated to reflect current state.
>
> This is a bit hard to parse. The value fields are destinations for
> values to be stored (from the point of view of the caller), which is
> familiar to most get or read type APIs.
>
> I don't think you need to say it's ignored. The value it contains is
> ignored and overwritten, but the field itself is not actually ignored :)
>
> Patch looks okay though.
Sure, updating the commit log to make it more clear.
>
>> - H_GUEST_SET_STATE which is used to modify the state of a guest or
>> a guest VCPU. On success, guest (or its VCPU) state shall be
>> updated as per the value field for the requested element(s).
>>
>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> include/hw/ppc/spapr.h | 3 +
>> include/hw/ppc/spapr_nested.h | 23 +++
>> hw/ppc/spapr_nested.c | 267 ++++++++++++++++++++++++++++++++++
>> 3 files changed, 293 insertions(+)
>>
>> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
>> index 82b077bdd2..aabc32f268 100644
>> --- a/include/hw/ppc/spapr.h
>> +++ b/include/hw/ppc/spapr.h
>> @@ -366,6 +366,7 @@ struct SpaprMachineState {
>> #define H_OVERLAP -68
>> #define H_STATE -75
>> #define H_IN_USE -77
>> +#define H_INVALID_ELEMENT_VALUE -81
>> #define H_UNSUPPORTED_FLAG -256
>> #define H_MULTI_THREADS_ACTIVE -9005
>>
>> @@ -589,6 +590,8 @@ struct SpaprMachineState {
>> #define H_GUEST_SET_CAPABILITIES 0x464
>> #define H_GUEST_CREATE 0x470
>> #define H_GUEST_CREATE_VCPU 0x474
>> +#define H_GUEST_GET_STATE 0x478
>> +#define H_GUEST_SET_STATE 0x47C
>> #define H_GUEST_DELETE 0x488
>>
>> #define MAX_HCALL_OPCODE H_GUEST_DELETE
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index 492302a21d..1b7e55f12a 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -224,6 +224,10 @@ typedef struct SpaprMachineStateNestedGuest {
>> #define HVMASK_MSR 0xEBFFFFFFFFBFEFFF
>> #define HVMASK_HDEXCR 0x00000000FFFFFFFF
>> #define HVMASK_TB_OFFSET 0x000000FFFFFFFFFF
>> +#define GSB_MAX_BUF_SIZE (1024 * 1024)
>> +#define H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE 0x8000000000000000
>> +#define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
>> +#define GUEST_STATE_REQUEST_SET 0x2
>>
>> #define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
>> .id = (i), \
>> @@ -312,6 +316,25 @@ typedef struct SpaprMachineStateNestedGuest {
>> #define GSE_ENV_DWM(i, f, m) \
>> GUEST_STATE_ELEMENT_MSK(i, 8, f, copy_state_8to8, m)
>>
>> +struct guest_state_element {
>> + uint16_t id;
>> + uint16_t size;
>> + uint8_t value[];
>> +} QEMU_PACKED;
>> +
>> +struct guest_state_buffer {
>> + uint32_t num_elements;
>> + struct guest_state_element elements[];
>> +} QEMU_PACKED;
>> +
>> +/* Actual buffer plus some metadata about the request */
>> +struct guest_state_request {
>> + struct guest_state_buffer *gsb;
>> + int64_t buf;
>> + int64_t len;
>> + uint16_t flags;
>> +};
>> +
>> /*
>> * Register state for entering a nested guest with H_ENTER_NESTED.
>> * New member must be added at the end.
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index faba27dd50..aba4b25da6 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -8,6 +8,7 @@
>> #include "hw/ppc/spapr_nested.h"
>> #include "mmu-book3s-v3.h"
>> #include "cpu-models.h"
>> +#include "qemu/log.h"
>>
>> void spapr_nested_init(SpaprMachineState *spapr)
>> {
>> @@ -999,6 +1000,140 @@ void spapr_nested_gsb_init(void)
>> }
>> }
>>
>> +static struct guest_state_element *guest_state_element_next(
>> + struct guest_state_element *element,
>> + int64_t *len,
>> + int64_t *num_elements)
>> +{
>> + uint16_t size;
>> +
>> + /* size is of element->value[] only. Not whole guest_state_element */
>> + size = be16_to_cpu(element->size);
>> +
>> + if (len) {
>> + *len -= size + offsetof(struct guest_state_element, value);
>> + }
>> +
>> + if (num_elements) {
>> + *num_elements -= 1;
>> + }
>> +
>> + return (struct guest_state_element *)(element->value + size);
>> +}
>> +
>> +static
>> +struct guest_state_element_type *guest_state_element_type_find(uint16_t id)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < ARRAY_SIZE(guest_state_element_types); i++)
>> + if (id == guest_state_element_types[i].id) {
>> + return &guest_state_element_types[i];
>> + }
>> +
>> + return NULL;
>> +}
>> +
>> +static void log_element(struct guest_state_element *element,
>> + struct guest_state_request *gsr)
>> +{
>> + qemu_log_mask(LOG_GUEST_ERROR, "h_guest_%s_state id:0x%04x size:0x%04x",
>> + gsr->flags & GUEST_STATE_REQUEST_SET ? "set" : "get",
>> + be16_to_cpu(element->id), be16_to_cpu(element->size));
>> + qemu_log_mask(LOG_GUEST_ERROR, "buf:0x%016lx ...\n",
>> + be64_to_cpu(*(uint64_t *)element->value));
>> +}
>> +
>> +static bool guest_state_request_check(struct guest_state_request *gsr)
>> +{
>> + int64_t num_elements, len = gsr->len;
>> + struct guest_state_buffer *gsb = gsr->gsb;
>> + struct guest_state_element *element;
>> + struct guest_state_element_type *type;
>> + uint16_t id, size;
>> +
>> + /* gsb->num_elements = 0 == 32 bits long */
>> + assert(len >= 4);
>> +
>> + num_elements = be32_to_cpu(gsb->num_elements);
>> + element = gsb->elements;
>> + len -= sizeof(gsb->num_elements);
>> +
>> + /* Walk the buffer to validate the length */
>> + while (num_elements) {
>> +
>> + id = be16_to_cpu(element->id);
>> + size = be16_to_cpu(element->size);
>> +
>> + if (false) {
>> + log_element(element, gsr);
>> + }
>> + /* buffer size too small */
>> + if (len < 0) {
>> + return false;
>> + }
>> +
>> + type = guest_state_element_type_find(id);
>> + if (!type) {
>> + qemu_log_mask(LOG_GUEST_ERROR,"Element ID %04x unknown\n", id);
>> + log_element(element, gsr);
>> + return false;
>> + }
>> +
>> + if (id == GSB_HV_VCPU_IGNORED_ID) {
>> + goto next_element;
>> + }
>> +
>> + if (size != type->size) {
>> + qemu_log_mask(LOG_GUEST_ERROR,"Size mismatch. Element ID:%04x."
>> + "Size Exp:%i Got:%i\n", id, type->size, size);
>> + log_element(element, gsr);
>> + return false;
>> + }
>> +
>> + if ((type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_READ_ONLY) &&
>> + (gsr->flags & GUEST_STATE_REQUEST_SET)) {
>> + qemu_log_mask(LOG_GUEST_ERROR,"trying to set a read-only Element "
>> + "ID:%04x.\n", id);
>> + return false;
>> + }
>> +
>> + if (type->flags & GUEST_STATE_ELEMENT_TYPE_FLAG_GUEST_WIDE) {
>> + /* guest wide element type */
>> + if (!(gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE)) {
>> + qemu_log_mask(LOG_GUEST_ERROR, "trying to set a guest wide "
>> + "Element ID:%04x.\n", id);
>> + return false;
>> + }
>> + } else {
>> + /* thread wide element type */
>> + if (gsr->flags & GUEST_STATE_REQUEST_GUEST_WIDE) {
>> + qemu_log_mask(LOG_GUEST_ERROR, "trying to set a thread wide "
>> + "Element ID:%04x.\n", id);
>> + return false;
>> + }
>> + }
>> +next_element:
>> + element = guest_state_element_next(element, &len, &num_elements);
>> +
>> + }
>> + return true;
>> +}
>> +
>> +static bool is_gsr_invalid(struct guest_state_request *gsr,
>> + struct guest_state_element *element,
>> + struct guest_state_element_type *type)
>> +{
>> + if ((gsr->flags & GUEST_STATE_REQUEST_SET) &&
>> + (*(uint64_t *)(element->value) & ~(type->mask))) {
>> + log_element(element, gsr);
>> + qemu_log_mask(LOG_GUEST_ERROR, "L1 can't set reserved bits i"
>> + "(allowed mask: 0x%08lx)\n", type->mask);
>> + return true;
>> + }
>> + return false;
>> +}
>> +
>> static target_ulong h_guest_get_capabilities(PowerPCCPU *cpu,
>> SpaprMachineState *spapr,
>> target_ulong opcode,
>> @@ -1244,6 +1379,136 @@ static target_ulong h_guest_create_vcpu(PowerPCCPU *cpu,
>> return H_SUCCESS;
>> }
>>
>> +static target_ulong getset_state(SpaprMachineStateNestedGuest *guest,
>> + uint64_t vcpuid,
>> + struct guest_state_request *gsr)
>> +{
>> + void *ptr;
>> + uint16_t id;
>> + struct guest_state_element *element;
>> + struct guest_state_element_type *type;
>> + int64_t lenleft, num_elements;
>> +
>> + lenleft = gsr->len;
>> +
>> + if (!guest_state_request_check(gsr)) {
>> + return H_P3;
>> + }
>> +
>> + num_elements = be32_to_cpu(gsr->gsb->num_elements);
>> + element = gsr->gsb->elements;
>> + /* Process the elements */
>> + while (num_elements) {
>> + type = NULL;
>> + /* log_element(element, gsr); */
>> +
>> + id = be16_to_cpu(element->id);
>> + if (id == GSB_HV_VCPU_IGNORED_ID) {
>> + goto next_element;
>> + }
>> +
>> + type = guest_state_element_type_find(id);
>> + assert(type);
>> +
>> + /* Get pointer to guest data to get/set */
>> + if (type->location && type->copy) {
>> + ptr = type->location(guest, vcpuid);
>> + assert(ptr);
>> + if (!~(type->mask) && is_gsr_invalid(gsr, element, type)) {
>> + return H_INVALID_ELEMENT_VALUE;
>> + }
>> + type->copy(ptr + type->offset, element->value,
>> + gsr->flags & GUEST_STATE_REQUEST_SET ? true : false);
>> + }
>> +
>> +next_element:
>> + element = guest_state_element_next(element, &lenleft, &num_elements);
>> + }
>> +
>> + return H_SUCCESS;
>> +}
>> +
>> +static target_ulong map_and_getset_state(PowerPCCPU *cpu,
>> + SpaprMachineStateNestedGuest *guest,
>> + uint64_t vcpuid,
>> + struct guest_state_request *gsr)
>> +{
>> + target_ulong rc;
>> + int64_t len;
>> + bool is_write;
>> +
>> + len = gsr->len;
>> + /* only get_state would require write access to the provided buffer */
>> + is_write = (gsr->flags & GUEST_STATE_REQUEST_SET) ? false : true;
>> + gsr->gsb = address_space_map(CPU(cpu)->as, gsr->buf, (uint64_t *)&len,
>> + is_write, MEMTXATTRS_UNSPECIFIED);
>> + if (!gsr->gsb) {
>> + rc = H_P3;
>> + goto out1;
>> + }
>> +
>> + if (len != gsr->len) {
>> + rc = H_P3;
>> + goto out1;
>> + }
>> +
>> + rc = getset_state(guest, vcpuid, gsr);
>> +
>> +out1:
>> + address_space_unmap(CPU(cpu)->as, gsr->gsb, len, is_write, len);
>> + return rc;
>> +}
>> +
>> +static target_ulong h_guest_getset_state(PowerPCCPU *cpu,
>> + SpaprMachineState *spapr,
>> + target_ulong *args,
>> + bool set)
>> +{
>> + target_ulong flags = args[0];
>> + target_ulong lpid = args[1];
>> + target_ulong vcpuid = args[2];
>> + target_ulong buf = args[3];
>> + target_ulong buflen = args[4];
>> + struct guest_state_request gsr;
>> + SpaprMachineStateNestedGuest *guest;
>> +
>> + guest = spapr_get_nested_guest(spapr, lpid);
>> + if (!guest) {
>> + return H_P2;
>> + }
>> + gsr.buf = buf;
>> + assert(buflen <= GSB_MAX_BUF_SIZE);
>> + gsr.len = buflen;
>> + gsr.flags = 0;
>> + if (flags & H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
>> + gsr.flags |= GUEST_STATE_REQUEST_GUEST_WIDE;
>> + }
>> + if (flags & !H_GUEST_GETSET_STATE_FLAG_GUEST_WIDE) {
>> + return H_PARAMETER; /* flag not supported yet */
>> + }
>> +
>> + if (set) {
>> + gsr.flags |= GUEST_STATE_REQUEST_SET;
>> + }
>> + return map_and_getset_state(cpu, guest, vcpuid, &gsr);
>> +}
>> +
>> +static target_ulong h_guest_set_state(PowerPCCPU *cpu,
>> + SpaprMachineState *spapr,
>> + target_ulong opcode,
>> + target_ulong *args)
>> +{
>> + return h_guest_getset_state(cpu, spapr, args, true);
>> +}
>> +
>> +static target_ulong h_guest_get_state(PowerPCCPU *cpu,
>> + SpaprMachineState *spapr,
>> + target_ulong opcode,
>> + target_ulong *args)
>> +{
>> + return h_guest_getset_state(cpu, spapr, args, false);
>> +}
>> +
>> void spapr_register_nested_hv(void)
>> {
>> spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
>> @@ -1267,6 +1532,8 @@ void spapr_register_nested_papr(void)
>> spapr_register_hypercall(H_GUEST_CREATE , h_guest_create);
>> spapr_register_hypercall(H_GUEST_DELETE , h_guest_delete);
>> spapr_register_hypercall(H_GUEST_CREATE_VCPU , h_guest_create_vcpu);
>> + spapr_register_hypercall(H_GUEST_SET_STATE , h_guest_set_state);
>> + spapr_register_hypercall(H_GUEST_GET_STATE , h_guest_get_state);
>
> Are these also supposed to to add unregister calls?
Yes, all unregistrations shall be added with registrations in v5.
regards,
Harsh
>
> Thanks,
> Nick
>
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (10 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 11/15] spapr: nested: Introduce H_GUEST_[GET|SET]_STATE hcalls Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 10:16 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 13/15] spapr: nested: Introduce H_GUEST_RUN_VCPU hcall Harsh Prateek Bora
` (2 subsequent siblings)
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
For nested PAPR API, we use SpaprMachineStateNestedGuest struct to store
partition table info, use the same in spapr_get_pate_nested() via
helper.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr_nested.h | 4 ++++
hw/ppc/spapr.c | 2 ++
hw/ppc/spapr_nested.c | 20 +++++++++++++++++++-
3 files changed, 25 insertions(+), 1 deletion(-)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index 1b7e55f12a..da918d2dd0 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -511,4 +511,8 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
void spapr_nested_init(SpaprMachineState *spapr);
uint8_t spapr_nested_api(SpaprMachineState *spapr);
void spapr_nested_gsb_init(void);
+bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry);
+SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
+ target_ulong lpid);
#endif /* HW_SPAPR_NESTED_H */
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 51a1be027a..3453b30a57 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -1379,6 +1379,8 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
assert(spapr_nested_api(spapr));
if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
+ } else if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
+ return spapr_get_pate_nested_papr(spapr, cpu, lpid, entry);
}
return false;
}
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index aba4b25da6..0edb362709 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -52,6 +52,19 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
return true;
}
+bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry)
+{
+ SpaprMachineStateNestedGuest *guest;
+ assert(lpid != 0);
+ guest = spapr_get_nested_guest(spapr, lpid);
+ assert(guest != NULL);
+
+ entry->dw0 = guest->parttbl[0];
+ entry->dw1 = guest->parttbl[1];
+ return true;
+}
+
#define PRTS_MASK 0x1f
static target_ulong h_set_ptbl(PowerPCCPU *cpu,
@@ -536,7 +549,6 @@ void spapr_exit_nested(PowerPCCPU *cpu, int excp)
}
}
-static
SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
target_ulong guestid)
{
@@ -1558,6 +1570,12 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
return false;
}
+bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
+ target_ulong lpid, ppc_v3_pate_t *entry)
+{
+ return false;
+}
+
void spapr_register_nested_papr(void)
{
/* DO NOTHING */
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API.
2024-02-20 8:36 ` [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API Harsh Prateek Bora
@ 2024-02-27 10:16 ` Nicholas Piggin
2024-03-05 8:21 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:16 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> For nested PAPR API, we use SpaprMachineStateNestedGuest struct to store
> partition table info, use the same in spapr_get_pate_nested() via
> helper.
>
> Signed-off-by: Michael Neuling <mikey@neuling.org>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> include/hw/ppc/spapr_nested.h | 4 ++++
> hw/ppc/spapr.c | 2 ++
> hw/ppc/spapr_nested.c | 20 +++++++++++++++++++-
> 3 files changed, 25 insertions(+), 1 deletion(-)
>
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index 1b7e55f12a..da918d2dd0 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -511,4 +511,8 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
> void spapr_nested_init(SpaprMachineState *spapr);
> uint8_t spapr_nested_api(SpaprMachineState *spapr);
> void spapr_nested_gsb_init(void);
> +bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
> + target_ulong lpid, ppc_v3_pate_t *entry);
> +SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
> + target_ulong lpid);
> #endif /* HW_SPAPR_NESTED_H */
> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> index 51a1be027a..3453b30a57 100644
> --- a/hw/ppc/spapr.c
> +++ b/hw/ppc/spapr.c
> @@ -1379,6 +1379,8 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
> assert(spapr_nested_api(spapr));
> if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
> return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
> + } else if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
> + return spapr_get_pate_nested_papr(spapr, cpu, lpid, entry);
> }
> return false;
> }
BTW. I would change these asserts to } else { g_assert_not_reached(); }
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index aba4b25da6..0edb362709 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -52,6 +52,19 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
> return true;
> }
>
> +bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
> + target_ulong lpid, ppc_v3_pate_t *entry)
> +{
> + SpaprMachineStateNestedGuest *guest;
> + assert(lpid != 0);
> + guest = spapr_get_nested_guest(spapr, lpid);
> + assert(guest != NULL);
> +
> + entry->dw0 = guest->parttbl[0];
> + entry->dw1 = guest->parttbl[1];
> + return true;
> +}
Asserts should not need to be changed to proper error handling, right?
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API.
2024-02-27 10:16 ` Nicholas Piggin
@ 2024-03-05 8:21 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-03-05 8:21 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Hi Nick,
On 2/27/24 15:46, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> For nested PAPR API, we use SpaprMachineStateNestedGuest struct to store
>> partition table info, use the same in spapr_get_pate_nested() via
>> helper.
>>
>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> include/hw/ppc/spapr_nested.h | 4 ++++
>> hw/ppc/spapr.c | 2 ++
>> hw/ppc/spapr_nested.c | 20 +++++++++++++++++++-
>> 3 files changed, 25 insertions(+), 1 deletion(-)
>>
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index 1b7e55f12a..da918d2dd0 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -511,4 +511,8 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> void spapr_nested_init(SpaprMachineState *spapr);
>> uint8_t spapr_nested_api(SpaprMachineState *spapr);
>> void spapr_nested_gsb_init(void);
>> +bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> + target_ulong lpid, ppc_v3_pate_t *entry);
>> +SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
>> + target_ulong lpid);
>> #endif /* HW_SPAPR_NESTED_H */
>> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
>> index 51a1be027a..3453b30a57 100644
>> --- a/hw/ppc/spapr.c
>> +++ b/hw/ppc/spapr.c
>> @@ -1379,6 +1379,8 @@ static bool spapr_get_pate(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu,
>> assert(spapr_nested_api(spapr));
>> if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
>> return spapr_get_pate_nested_hv(spapr, cpu, lpid, entry);
>> + } else if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
>> + return spapr_get_pate_nested_papr(spapr, cpu, lpid, entry);
>> }
>> return false;
>> }
>
> BTW. I would change these asserts to } else { g_assert_not_reached(); }
Sure, updating as suggested.
>
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index aba4b25da6..0edb362709 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -52,6 +52,19 @@ bool spapr_get_pate_nested_hv(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> return true;
>> }
>>
>> +bool spapr_get_pate_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu,
>> + target_ulong lpid, ppc_v3_pate_t *entry)
>> +{
>> + SpaprMachineStateNestedGuest *guest;
>> + assert(lpid != 0);
>> + guest = spapr_get_nested_guest(spapr, lpid);
>> + assert(guest != NULL);
>> +
>> + entry->dw0 = guest->parttbl[0];
>> + entry->dw1 = guest->parttbl[1];
>> + return true;
>> +}
>
> Asserts should not need to be changed to proper error handling, right?
Hmm, changing !guest check to return false as more appropriate.
lpid check shall remain an assert.
regards,
Harsh
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 13/15] spapr: nested: Introduce H_GUEST_RUN_VCPU hcall.
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (11 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 12/15] spapr: nested: Use correct source for parttbl info for nested PAPR API Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-20 8:36 ` [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API Harsh Prateek Bora
2024-02-20 8:36 ` [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set Harsh Prateek Bora
14 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
The H_GUEST_RUN_VCPU hcall is used to start execution of a Guest VCPU.
The Hypervisor will update the state of the Guest VCPU based on the
input buffer, restore the saved Guest VCPU state, and start its
execution.
The Guest VCPU can stop running for numerous reasons including HCALLs,
hypervisor exceptions, or an outstanding Host Partition Interrupt.
The reason that the Guest VCPU stopped running is communicated through
R4 and the output buffer will be filled in with any relevant state.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 1 +
target/ppc/cpu.h | 2 +
hw/ppc/ppc.c | 10 ++
hw/ppc/spapr_nested.c | 333 +++++++++++++++++++++++++++++++++++++----
4 files changed, 316 insertions(+), 30 deletions(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index aabc32f268..036a7db2bc 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -592,6 +592,7 @@ struct SpaprMachineState {
#define H_GUEST_CREATE_VCPU 0x474
#define H_GUEST_GET_STATE 0x478
#define H_GUEST_SET_STATE 0x47C
+#define H_GUEST_RUN_VCPU 0x480
#define H_GUEST_DELETE 0x488
#define MAX_HCALL_OPCODE H_GUEST_DELETE
diff --git a/target/ppc/cpu.h b/target/ppc/cpu.h
index 11205bb9e3..d2978326e7 100644
--- a/target/ppc/cpu.h
+++ b/target/ppc/cpu.h
@@ -1566,6 +1566,8 @@ uint64_t cpu_ppc_load_atbl(CPUPPCState *env);
uint32_t cpu_ppc_load_atbu(CPUPPCState *env);
void cpu_ppc_store_atbl(CPUPPCState *env, uint32_t value);
void cpu_ppc_store_atbu(CPUPPCState *env, uint32_t value);
+void cpu_ppc_increase_tb_by_offset (CPUPPCState *env, int64_t offset);
+void cpu_ppc_decrease_tb_by_offset (CPUPPCState *env, int64_t offset);
uint64_t cpu_ppc_load_vtb(CPUPPCState *env);
void cpu_ppc_store_vtb(CPUPPCState *env, uint64_t value);
bool ppc_decr_clear_on_delivery(CPUPPCState *env);
diff --git a/hw/ppc/ppc.c b/hw/ppc/ppc.c
index fadb8f5239..55860b9a83 100644
--- a/hw/ppc/ppc.c
+++ b/hw/ppc/ppc.c
@@ -633,6 +633,16 @@ void cpu_ppc_store_atbu (CPUPPCState *env, uint32_t value)
((uint64_t)value << 32) | tb);
}
+void cpu_ppc_increase_tb_by_offset (CPUPPCState *env, int64_t offset)
+{
+ env->tb_env->tb_offset += offset;
+}
+
+void cpu_ppc_decrease_tb_by_offset (CPUPPCState *env, int64_t offset)
+{
+ env->tb_env->tb_offset -= offset;
+}
+
uint64_t cpu_ppc_load_vtb(CPUPPCState *env)
{
ppc_tb_t *tb_env = env->tb_env;
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 0edb362709..db1c59a8f5 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -193,14 +193,28 @@ static void nested_save_state(struct nested_ppc_state *save, PowerPCCPU *cpu)
save->sier = env->spr[SPR_POWER_SIER];
save->vscr = ppc_get_vscr(env);
save->fpscr = env->fpscr;
+ } else if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
+ save->tb_offset = env->tb_env->tb_offset;
}
+}
- save->tb_offset = env->tb_env->tb_offset;
+static void nested_post_load_state(CPUPPCState *env, CPUState *cs)
+{
+ /*
+ * compute hflags and possible interrupts.
+ */
+ hreg_compute_hflags(env);
+ ppc_maybe_interrupt(env);
+ /*
+ * Nested HV does not tag TLB entries between L1 and L2, so must
+ * flush on transition.
+ */
+ tlb_flush(cs);
+ env->reserve_addr = -1; /* Reset the reservation */
}
static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
{
- CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
@@ -279,22 +293,9 @@ static void nested_load_state(PowerPCCPU *cpu, struct nested_ppc_state *load)
env->spr[SPR_POWER_SIER] = load->sier;
ppc_store_vscr(env, load->vscr);
ppc_store_fpscr(env, load->fpscr);
+ } else if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
+ env->tb_env->tb_offset = load->tb_offset;
}
-
- env->tb_env->tb_offset = load->tb_offset;
-
- /*
- * MSR updated, compute hflags and possible interrupts.
- */
- hreg_compute_hflags(env);
- ppc_maybe_interrupt(env);
-
- /*
- * Nested HV does not tag TLB entries between L1 and L2, so must
- * flush on transition.
- */
- tlb_flush(cs);
- env->reserve_addr = -1; /* Reset the reservation */
}
/*
@@ -309,6 +310,7 @@ static target_ulong h_enter_nested(PowerPCCPU *cpu,
{
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
CPUPPCState *env = &cpu->env;
+ CPUState *cs = CPU(cpu);
SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
struct nested_ppc_state l2_state;
target_ulong hv_ptr = args[0];
@@ -407,6 +409,7 @@ static target_ulong h_enter_nested(PowerPCCPU *cpu,
* Switch to the nested guest environment and start the "hdec" timer.
*/
nested_load_state(cpu, &l2_state);
+ nested_post_load_state(env, cs);
hdec = hv_state.hdec_expiry - now;
cpu_ppc_hdecr_init(env);
@@ -438,6 +441,7 @@ static target_ulong h_enter_nested(PowerPCCPU *cpu,
static void spapr_exit_nested_hv(PowerPCCPU *cpu, int excp)
{
CPUPPCState *env = &cpu->env;
+ CPUState *cs = CPU(cpu);
SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
struct nested_ppc_state l2_state;
target_ulong hv_ptr = spapr_cpu->nested_host_state->gpr[4];
@@ -459,6 +463,7 @@ static void spapr_exit_nested_hv(PowerPCCPU *cpu, int excp)
*/
assert(env->spr[SPR_LPIDR] != 0);
nested_load_state(cpu, spapr_cpu->nested_host_state);
+ nested_post_load_state(env, cs);
env->gpr[3] = env->excp_vectors[excp]; /* hcall return value */
cpu_ppc_hdecr_exit(env);
@@ -536,19 +541,6 @@ static void spapr_exit_nested_hv(PowerPCCPU *cpu, int excp)
address_space_unmap(CPU(cpu)->as, regs, len, len, true);
}
-void spapr_exit_nested(PowerPCCPU *cpu, int excp)
-{
- SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
- SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
-
- assert(spapr_cpu->in_nested);
- if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
- spapr_exit_nested_hv(cpu, excp);
- } else {
- g_assert_not_reached();
- }
-}
-
SpaprMachineStateNestedGuest *spapr_get_nested_guest(SpaprMachineState *spapr,
target_ulong guestid)
{
@@ -1521,6 +1513,286 @@ static target_ulong h_guest_get_state(PowerPCCPU *cpu,
return h_guest_getset_state(cpu, spapr, args, false);
}
+static void exit_nested_store_l2(PowerPCCPU *cpu, int excp,
+ SpaprMachineStateNestedGuestVcpu *vcpu)
+{
+ CPUPPCState *env = &cpu->env;
+ SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+ target_ulong now, hdar, hdsisr, asdr;
+
+ assert(sizeof(env->gpr) == sizeof(vcpu->state.gpr)); /* sanity check */
+
+ now = cpu_ppc_load_tbl(env); /* L2 timebase */
+ now -= vcpu->tb_offset; /* L1 timebase */
+ vcpu->state.dec_expiry_tb = now - cpu_ppc_load_decr(env);
+ cpu_ppc_store_decr(env, spapr_cpu->nested_host_state->dec_expiry_tb - now);
+ /* backup hdar, hdsisr, asdr if reqd later below */
+ hdar = vcpu->state.hdar;
+ hdsisr = vcpu->state.hdsisr;
+ asdr = vcpu->state.asdr;
+
+ nested_save_state(&vcpu->state, cpu);
+
+ if (excp == POWERPC_EXCP_MCHECK ||
+ excp == POWERPC_EXCP_RESET ||
+ excp == POWERPC_EXCP_SYSCALL) {
+ vcpu->state.nip = env->spr[SPR_SRR0];
+ vcpu->state.msr = env->spr[SPR_SRR1] & env->msr_mask;
+ } else {
+ vcpu->state.nip = env->spr[SPR_HSRR0];
+ vcpu->state.msr = env->spr[SPR_HSRR1] & env->msr_mask;
+ }
+
+ /* hdar, hdsisr, asdr should be retained unless certain exceptions */
+ if ((excp != POWERPC_EXCP_HDSI) && (excp != POWERPC_EXCP_HISI)) {
+ vcpu->state.asdr = asdr;
+ } else if (excp != POWERPC_EXCP_HDSI) {
+ vcpu->state.hdar = hdar;
+ vcpu->state.hdsisr = hdsisr;
+ }
+}
+
+static int get_exit_ids(uint64_t srr0, uint16_t ids[16])
+{
+ int nr;
+
+ switch (srr0) {
+ case 0xc00:
+ nr = 10;
+ ids[0] = GSB_VCPU_GPR3;
+ ids[1] = GSB_VCPU_GPR4;
+ ids[2] = GSB_VCPU_GPR5;
+ ids[3] = GSB_VCPU_GPR6;
+ ids[4] = GSB_VCPU_GPR7;
+ ids[5] = GSB_VCPU_GPR8;
+ ids[6] = GSB_VCPU_GPR9;
+ ids[7] = GSB_VCPU_GPR10;
+ ids[8] = GSB_VCPU_GPR11;
+ ids[9] = GSB_VCPU_GPR12;
+ break;
+ case 0xe00:
+ nr = 5;
+ ids[0] = GSB_VCPU_SPR_HDAR;
+ ids[1] = GSB_VCPU_SPR_HDSISR;
+ ids[2] = GSB_VCPU_SPR_ASDR;
+ ids[3] = GSB_VCPU_SPR_NIA;
+ ids[4] = GSB_VCPU_SPR_MSR;
+ break;
+ case 0xe20:
+ nr = 4;
+ ids[0] = GSB_VCPU_SPR_HDAR;
+ ids[1] = GSB_VCPU_SPR_ASDR;
+ ids[2] = GSB_VCPU_SPR_NIA;
+ ids[3] = GSB_VCPU_SPR_MSR;
+ break;
+ case 0xe40:
+ nr = 3;
+ ids[0] = GSB_VCPU_SPR_HEIR;
+ ids[1] = GSB_VCPU_SPR_NIA;
+ ids[2] = GSB_VCPU_SPR_MSR;
+ break;
+ case 0xf80:
+ nr = 3;
+ ids[0] = GSB_VCPU_SPR_HFSCR;
+ ids[1] = GSB_VCPU_SPR_NIA;
+ ids[2] = GSB_VCPU_SPR_MSR;
+ break;
+ default:
+ nr = 0;
+ break;
+ }
+
+ return nr;
+}
+
+static void exit_process_output_buffer(PowerPCCPU *cpu,
+ SpaprMachineStateNestedGuest *guest,
+ target_ulong vcpuid,
+ target_ulong *r3)
+{
+ SpaprMachineStateNestedGuestVcpu *vcpu = &guest->vcpu[vcpuid];
+ struct guest_state_request gsr;
+ struct guest_state_buffer *gsb;
+ struct guest_state_element *element;
+ struct guest_state_element_type *type;
+ int exit_id_count = 0;
+ uint16_t exit_cause_ids[16];
+ hwaddr len;
+
+ len = vcpu->runbufout.size;
+ gsb = address_space_map(CPU(cpu)->as, vcpu->runbufout.addr, &len, true,
+ MEMTXATTRS_UNSPECIFIED);
+ if (!gsb || len != vcpu->runbufout.size) {
+ address_space_unmap(CPU(cpu)->as, gsb, len, true, len);
+ *r3 = H_P2;
+ return;
+ }
+
+ exit_id_count = get_exit_ids(*r3, exit_cause_ids);
+
+ /* Create a buffer of elements to send back */
+ gsb->num_elements = cpu_to_be32(exit_id_count);
+ element = gsb->elements;
+ for (int i = 0; i < exit_id_count; i++) {
+ type = guest_state_element_type_find(exit_cause_ids[i]);
+ assert(type);
+ element->id = cpu_to_be16(exit_cause_ids[i]);
+ element->size = cpu_to_be16(type->size);
+ element = guest_state_element_next(element, NULL, NULL);
+ }
+ gsr.gsb = gsb;
+ gsr.len = VCPU_OUT_BUF_MIN_SZ;
+ gsr.flags = 0; /* get + never guest wide */
+ getset_state(guest, vcpuid, &gsr);
+
+ address_space_unmap(CPU(cpu)->as, gsb, len, true, len);
+ return;
+}
+
+static
+void spapr_exit_nested_papr(SpaprMachineState *spapr, PowerPCCPU *cpu, int excp)
+{
+ CPUPPCState *env = &cpu->env;
+ CPUState *cs = CPU(cpu);
+ SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+ target_ulong r3_return = env->excp_vectors[excp]; /* hcall return value */
+ target_ulong lpid = 0, vcpuid = 0;
+ struct SpaprMachineStateNestedGuestVcpu *vcpu = NULL;
+ struct SpaprMachineStateNestedGuest *guest = NULL;
+
+ lpid = spapr_cpu->nested_host_state->gpr[5];
+ vcpuid = spapr_cpu->nested_host_state->gpr[6];
+ guest = spapr_get_nested_guest(spapr, lpid);
+ assert(guest);
+ spapr_nested_vcpu_check(guest, vcpuid, false);
+ vcpu = &guest->vcpu[vcpuid];
+
+ exit_nested_store_l2(cpu, excp, vcpu);
+ /* do the output buffer for run_vcpu*/
+ exit_process_output_buffer(cpu, guest, vcpuid, &r3_return);
+
+ assert(env->spr[SPR_LPIDR] != 0);
+ nested_load_state(cpu, spapr_cpu->nested_host_state);
+ cpu_ppc_decrease_tb_by_offset(env, vcpu->tb_offset);
+ env->gpr[3] = H_SUCCESS;
+ env->gpr[4] = r3_return;
+ nested_post_load_state(env, cs);
+ cpu_ppc_hdecr_exit(env);
+
+ spapr_cpu->in_nested = false;
+ g_free(spapr_cpu->nested_host_state);
+ spapr_cpu->nested_host_state = NULL;
+}
+
+void spapr_exit_nested(PowerPCCPU *cpu, int excp)
+{
+ SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
+ SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+
+ assert(spapr_cpu->in_nested);
+ if (spapr_nested_api(spapr) == NESTED_API_KVM_HV) {
+ spapr_exit_nested_hv(cpu, excp);
+ } else if (spapr_nested_api(spapr) == NESTED_API_PAPR) {
+ spapr_exit_nested_papr(spapr, cpu, excp);
+ } else {
+ g_assert_not_reached();
+ }
+}
+
+static void nested_papr_load_l2(PowerPCCPU *cpu,
+ CPUPPCState *env,
+ SpaprMachineStateNestedGuestVcpu *vcpu,
+ target_ulong now)
+{
+ PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
+ target_ulong lpcr, lpcr_mask, hdec;
+ lpcr_mask = LPCR_DPFD | LPCR_ILE | LPCR_AIL | LPCR_LD | LPCR_MER;
+
+ assert(vcpu);
+ assert(sizeof(env->gpr) == sizeof(vcpu->state.gpr));
+ nested_load_state(cpu, &vcpu->state);
+ lpcr = (env->spr[SPR_LPCR] & ~lpcr_mask) |
+ (vcpu->state.lpcr & lpcr_mask);
+ lpcr |= LPCR_HR | LPCR_UPRT | LPCR_GTSE | LPCR_HVICE | LPCR_HDICE;
+ lpcr &= ~LPCR_LPES0;
+ env->spr[SPR_LPCR] = lpcr & pcc->lpcr_mask;
+
+ hdec = vcpu->hdecr_expiry_tb - now;
+ cpu_ppc_store_decr(env, vcpu->state.dec_expiry_tb - now);
+ cpu_ppc_hdecr_init(env);
+ cpu_ppc_store_hdecr(env, hdec);
+
+ cpu_ppc_increase_tb_by_offset(env, vcpu->tb_offset);
+}
+
+static void nested_papr_run_vcpu(PowerPCCPU *cpu,
+ uint64_t lpid,
+ SpaprMachineStateNestedGuestVcpu *vcpu)
+{
+ SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
+ CPUPPCState *env = &cpu->env;
+ CPUState *cs = CPU(cpu);
+ SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+ target_ulong now = cpu_ppc_load_tbl(env);
+
+ assert(env->spr[SPR_LPIDR] == 0);
+ assert(spapr->nested.api); /* ensure API version is initialized */
+ spapr_cpu->nested_host_state = g_try_new(struct nested_ppc_state, 1);
+ assert(spapr_cpu->nested_host_state);
+ nested_save_state(spapr_cpu->nested_host_state, cpu);
+ spapr_cpu->nested_host_state->dec_expiry_tb = now - cpu_ppc_load_decr(env);
+ nested_papr_load_l2(cpu, env, vcpu, now);
+ env->spr[SPR_LPIDR] = lpid; /* post load l2 */
+
+ spapr_cpu->in_nested = true;
+ nested_post_load_state(env, cs);
+}
+
+static target_ulong h_guest_run_vcpu(PowerPCCPU *cpu,
+ SpaprMachineState *spapr,
+ target_ulong opcode,
+ target_ulong *args)
+{
+ CPUPPCState *env = &cpu->env;
+ target_ulong flags = args[0];
+ target_ulong lpid = args[1];
+ target_ulong vcpuid = args[2];
+ struct SpaprMachineStateNestedGuestVcpu *vcpu;
+ struct guest_state_request gsr;
+ SpaprMachineStateNestedGuest *guest;
+ target_ulong rc;
+
+ if (flags) /* don't handle any flags for now */
+ return H_PARAMETER;
+
+ guest = spapr_get_nested_guest(spapr, lpid);
+ if (!guest) {
+ return H_P2;
+ }
+ if (!spapr_nested_vcpu_check(guest, vcpuid, true)) {
+ return H_P3;
+ }
+
+ if (guest->parttbl[0] == 0) {
+ /* At least need a partition scoped radix tree */
+ return H_NOT_AVAILABLE;
+ }
+
+ vcpu = &guest->vcpu[vcpuid];
+
+ /* Read run_vcpu input buffer to update state */
+ gsr.buf = vcpu->runbufin.addr;
+ gsr.len = vcpu->runbufin.size;
+ gsr.flags = GUEST_STATE_REQUEST_SET; /* Thread wide + writing */
+ rc = map_and_getset_state(cpu, guest, vcpuid, &gsr);
+ if (rc == H_SUCCESS) {
+ nested_papr_run_vcpu(cpu, lpid, vcpu);
+ } else {
+ env->gpr[3] = rc;
+ }
+ return env->gpr[3];
+}
+
void spapr_register_nested_hv(void)
{
spapr_register_hypercall(KVMPPC_H_SET_PARTITION_TABLE, h_set_ptbl);
@@ -1546,6 +1818,7 @@ void spapr_register_nested_papr(void)
spapr_register_hypercall(H_GUEST_CREATE_VCPU , h_guest_create_vcpu);
spapr_register_hypercall(H_GUEST_SET_STATE , h_guest_set_state);
spapr_register_hypercall(H_GUEST_GET_STATE , h_guest_get_state);
+ spapr_register_hypercall(H_GUEST_RUN_VCPU , h_guest_run_vcpu);
}
#else
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (12 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 13/15] spapr: nested: Introduce H_GUEST_RUN_VCPU hcall Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 10:22 ` Nicholas Piggin
2024-02-20 8:36 ` [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set Harsh Prateek Bora
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
Introduce a SPAPR capability cap-nested-papr which enables nested PAPR
API for nested guests. This new API is to enable support for KVM on PowerVM
and the support in Linux kernel has already merged upstream.
Signed-off-by: Michael Neuling <mikey@neuling.org>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr.h | 6 ++++-
hw/ppc/spapr.c | 2 ++
hw/ppc/spapr_caps.c | 56 ++++++++++++++++++++++++++++++++++++++++++
hw/ppc/spapr_nested.c | 19 ++++++++++++--
4 files changed, 80 insertions(+), 3 deletions(-)
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index 036a7db2bc..1b1d37123a 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -81,8 +81,10 @@ typedef enum {
#define SPAPR_CAP_RPT_INVALIDATE 0x0B
/* Support for AIL modes */
#define SPAPR_CAP_AIL_MODE_3 0x0C
+/* Nested PAPR */
+#define SPAPR_CAP_NESTED_PAPR 0x0D
/* Num Caps */
-#define SPAPR_CAP_NUM (SPAPR_CAP_AIL_MODE_3 + 1)
+#define SPAPR_CAP_NUM (SPAPR_CAP_NESTED_PAPR + 1)
/*
* Capability Values
@@ -994,6 +996,7 @@ extern const VMStateDescription vmstate_spapr_cap_sbbc;
extern const VMStateDescription vmstate_spapr_cap_ibs;
extern const VMStateDescription vmstate_spapr_cap_hpt_maxpagesize;
extern const VMStateDescription vmstate_spapr_cap_nested_kvm_hv;
+extern const VMStateDescription vmstate_spapr_cap_nested_papr;
extern const VMStateDescription vmstate_spapr_cap_large_decr;
extern const VMStateDescription vmstate_spapr_cap_ccf_assist;
extern const VMStateDescription vmstate_spapr_cap_fwnmi;
@@ -1041,5 +1044,6 @@ void spapr_watchdog_init(SpaprMachineState *spapr);
void spapr_register_nested_hv(void);
void spapr_unregister_nested_hv(void);
void spapr_register_nested_papr(void);
+void spapr_unregister_nested_papr(void);
#endif /* HW_SPAPR_H */
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 3453b30a57..cb556ae6a8 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -2120,6 +2120,7 @@ static const VMStateDescription vmstate_spapr = {
&vmstate_spapr_cap_fwnmi,
&vmstate_spapr_fwnmi,
&vmstate_spapr_cap_rpt_invalidate,
+ &vmstate_spapr_cap_nested_papr,
NULL
}
};
@@ -4688,6 +4689,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_WORKAROUND;
smc->default_caps.caps[SPAPR_CAP_HPT_MAXPAGESIZE] = 16; /* 64kiB */
smc->default_caps.caps[SPAPR_CAP_NESTED_KVM_HV] = SPAPR_CAP_OFF;
+ smc->default_caps.caps[SPAPR_CAP_NESTED_PAPR] = SPAPR_CAP_OFF;
smc->default_caps.caps[SPAPR_CAP_LARGE_DECREMENTER] = SPAPR_CAP_ON;
smc->default_caps.caps[SPAPR_CAP_CCF_ASSIST] = SPAPR_CAP_ON;
smc->default_caps.caps[SPAPR_CAP_FWNMI] = SPAPR_CAP_ON;
diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
index 721ddad23b..9a29ce1872 100644
--- a/hw/ppc/spapr_caps.c
+++ b/hw/ppc/spapr_caps.c
@@ -487,12 +487,58 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
"or use threads=1 with -smp\n");
}
+ if (spapr->nested.api) {
+ warn_report("nested.api already set as %d, re-init to kvm-hv",
+ spapr->nested.api);
+ }
spapr->nested.api = NESTED_API_KVM_HV;
spapr_unregister_nested_hv(); /* reset across reboots */
spapr_register_nested_hv();
}
}
+static void cap_nested_papr_apply(SpaprMachineState *spapr,
+ uint8_t val, Error **errp)
+{
+ ERRP_GUARD();
+ PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
+ CPUPPCState *env = &cpu->env;
+
+ if (!val) {
+ /* capability disabled by default */
+ return;
+ }
+
+ if (tcg_enabled()) {
+ if (!(env->insns_flags2 & PPC2_ISA300)) {
+ error_setg(errp, "Nested-PAPR only supported on POWER9 and later");
+ error_append_hint(errp,
+ "Try appending -machine cap-nested-papr=off\n");
+ return;
+ }
+ } else if (kvm_enabled()) {
+ /*
+ * this gets executed in L1 qemu when L2 is launched,
+ * needs kvm-hv support in L1 kernel.
+ */
+ if (!kvmppc_has_cap_nested_kvm_hv()) {
+ error_setg(errp,
+ "KVM implementation does not support Nested-HV");
+ } else if (kvmppc_set_cap_nested_kvm_hv(val) < 0) {
+ error_setg(errp, "Error enabling Nested-HV with KVM");
+ }
+ }
+ if (spapr->nested.api) {
+ warn_report("nested.api already set as %d, re-init to nested-papr",
+ spapr->nested.api);
+ }
+ spapr->nested.api = NESTED_API_PAPR;
+ spapr->nested.capabilities_set = false;
+ spapr_unregister_nested_papr(); /* reset across reboots */
+ spapr_register_nested_papr();
+ spapr_nested_gsb_init();
+}
+
static void cap_large_decr_apply(SpaprMachineState *spapr,
uint8_t val, Error **errp)
{
@@ -738,6 +784,15 @@ SpaprCapabilityInfo capability_table[SPAPR_CAP_NUM] = {
.type = "bool",
.apply = cap_nested_kvm_hv_apply,
},
+ [SPAPR_CAP_NESTED_PAPR] = {
+ .name = "nested-papr",
+ .description = "Allow Nested HV (PAPR API)",
+ .index = SPAPR_CAP_NESTED_PAPR,
+ .get = spapr_cap_get_bool,
+ .set = spapr_cap_set_bool,
+ .type = "bool",
+ .apply = cap_nested_papr_apply,
+ },
[SPAPR_CAP_LARGE_DECREMENTER] = {
.name = "large-decr",
.description = "Allow Large Decrementer",
@@ -922,6 +977,7 @@ SPAPR_CAP_MIG_STATE(sbbc, SPAPR_CAP_SBBC);
SPAPR_CAP_MIG_STATE(ibs, SPAPR_CAP_IBS);
SPAPR_CAP_MIG_STATE(hpt_maxpagesize, SPAPR_CAP_HPT_MAXPAGESIZE);
SPAPR_CAP_MIG_STATE(nested_kvm_hv, SPAPR_CAP_NESTED_KVM_HV);
+SPAPR_CAP_MIG_STATE(nested_papr, SPAPR_CAP_NESTED_PAPR);
SPAPR_CAP_MIG_STATE(large_decr, SPAPR_CAP_LARGE_DECREMENTER);
SPAPR_CAP_MIG_STATE(ccf_assist, SPAPR_CAP_CCF_ASSIST);
SPAPR_CAP_MIG_STATE(fwnmi, SPAPR_CAP_FWNMI);
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index db1c59a8f5..6e6a90616e 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -13,8 +13,6 @@
void spapr_nested_init(SpaprMachineState *spapr)
{
spapr->nested.api = 0;
- spapr->nested.capabilities_set = false;
- spapr_nested_gsb_init();
}
uint8_t spapr_nested_api(SpaprMachineState *spapr)
@@ -1821,6 +1819,18 @@ void spapr_register_nested_papr(void)
spapr_register_hypercall(H_GUEST_RUN_VCPU , h_guest_run_vcpu);
}
+void spapr_unregister_nested_papr(void)
+{
+ spapr_unregister_hypercall(H_GUEST_GET_CAPABILITIES);
+ spapr_unregister_hypercall(H_GUEST_SET_CAPABILITIES);
+ spapr_unregister_hypercall(H_GUEST_CREATE);
+ spapr_unregister_hypercall(H_GUEST_DELETE);
+ spapr_unregister_hypercall(H_GUEST_CREATE_VCPU);
+ spapr_unregister_hypercall(H_GUEST_SET_STATE);
+ spapr_unregister_hypercall(H_GUEST_GET_STATE);
+ spapr_unregister_hypercall(H_GUEST_RUN_VCPU);
+}
+
#else
void spapr_exit_nested(PowerPCCPU *cpu, int excp)
{
@@ -1854,6 +1864,11 @@ void spapr_register_nested_papr(void)
/* DO NOTHING */
}
+void spapr_unregister_nested_papr(void)
+{
+ /* DO NOTHING */
+}
+
void spapr_nested_gsb_init(void)
{
/* DO NOTHING */
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API
2024-02-20 8:36 ` [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API Harsh Prateek Bora
@ 2024-02-27 10:22 ` Nicholas Piggin
2024-03-05 8:24 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:22 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> Introduce a SPAPR capability cap-nested-papr which enables nested PAPR
> API for nested guests. This new API is to enable support for KVM on PowerVM
> and the support in Linux kernel has already merged upstream.
>
> Signed-off-by: Michael Neuling <mikey@neuling.org>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> include/hw/ppc/spapr.h | 6 ++++-
> hw/ppc/spapr.c | 2 ++
> hw/ppc/spapr_caps.c | 56 ++++++++++++++++++++++++++++++++++++++++++
> hw/ppc/spapr_nested.c | 19 ++++++++++++--
> 4 files changed, 80 insertions(+), 3 deletions(-)
>
> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> index 036a7db2bc..1b1d37123a 100644
> --- a/include/hw/ppc/spapr.h
> +++ b/include/hw/ppc/spapr.h
> @@ -81,8 +81,10 @@ typedef enum {
> #define SPAPR_CAP_RPT_INVALIDATE 0x0B
> /* Support for AIL modes */
> #define SPAPR_CAP_AIL_MODE_3 0x0C
> +/* Nested PAPR */
> +#define SPAPR_CAP_NESTED_PAPR 0x0D
> /* Num Caps */
> -#define SPAPR_CAP_NUM (SPAPR_CAP_AIL_MODE_3 + 1)
> +#define SPAPR_CAP_NUM (SPAPR_CAP_NESTED_PAPR + 1)
>
> /*
> * Capability Values
> @@ -994,6 +996,7 @@ extern const VMStateDescription vmstate_spapr_cap_sbbc;
> extern const VMStateDescription vmstate_spapr_cap_ibs;
> extern const VMStateDescription vmstate_spapr_cap_hpt_maxpagesize;
> extern const VMStateDescription vmstate_spapr_cap_nested_kvm_hv;
> +extern const VMStateDescription vmstate_spapr_cap_nested_papr;
> extern const VMStateDescription vmstate_spapr_cap_large_decr;
> extern const VMStateDescription vmstate_spapr_cap_ccf_assist;
> extern const VMStateDescription vmstate_spapr_cap_fwnmi;
> @@ -1041,5 +1044,6 @@ void spapr_watchdog_init(SpaprMachineState *spapr);
> void spapr_register_nested_hv(void);
> void spapr_unregister_nested_hv(void);
> void spapr_register_nested_papr(void);
> +void spapr_unregister_nested_papr(void);
>
> #endif /* HW_SPAPR_H */
> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> index 3453b30a57..cb556ae6a8 100644
> --- a/hw/ppc/spapr.c
> +++ b/hw/ppc/spapr.c
> @@ -2120,6 +2120,7 @@ static const VMStateDescription vmstate_spapr = {
> &vmstate_spapr_cap_fwnmi,
> &vmstate_spapr_fwnmi,
> &vmstate_spapr_cap_rpt_invalidate,
> + &vmstate_spapr_cap_nested_papr,
> NULL
> }
> };
> @@ -4688,6 +4689,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
> smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_WORKAROUND;
> smc->default_caps.caps[SPAPR_CAP_HPT_MAXPAGESIZE] = 16; /* 64kiB */
> smc->default_caps.caps[SPAPR_CAP_NESTED_KVM_HV] = SPAPR_CAP_OFF;
> + smc->default_caps.caps[SPAPR_CAP_NESTED_PAPR] = SPAPR_CAP_OFF;
> smc->default_caps.caps[SPAPR_CAP_LARGE_DECREMENTER] = SPAPR_CAP_ON;
> smc->default_caps.caps[SPAPR_CAP_CCF_ASSIST] = SPAPR_CAP_ON;
> smc->default_caps.caps[SPAPR_CAP_FWNMI] = SPAPR_CAP_ON;
> diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
> index 721ddad23b..9a29ce1872 100644
> --- a/hw/ppc/spapr_caps.c
> +++ b/hw/ppc/spapr_caps.c
> @@ -487,12 +487,58 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
> error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
> "or use threads=1 with -smp\n");
> }
> + if (spapr->nested.api) {
> + warn_report("nested.api already set as %d, re-init to kvm-hv",
> + spapr->nested.api);
> + }
Does this warning trigger when you reset the machine?
It's trying to catch both caps enabled? I would make that an error and
fail and tell user to enable only one or the other.
(In a future patch I think we should try permit both to be enabled at
the same time, but for now restricting it is fine)
> spapr->nested.api = NESTED_API_KVM_HV;
> spapr_unregister_nested_hv(); /* reset across reboots */
> spapr_register_nested_hv();
> }
> }
>
> +static void cap_nested_papr_apply(SpaprMachineState *spapr,
> + uint8_t val, Error **errp)
> +{
> + ERRP_GUARD();
> + PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
> + CPUPPCState *env = &cpu->env;
> +
> + if (!val) {
> + /* capability disabled by default */
> + return;
> + }
> +
> + if (tcg_enabled()) {
> + if (!(env->insns_flags2 & PPC2_ISA300)) {
> + error_setg(errp, "Nested-PAPR only supported on POWER9 and later");
> + error_append_hint(errp,
> + "Try appending -machine cap-nested-papr=off\n");
> + return;
> + }
> + } else if (kvm_enabled()) {
> + /*
> + * this gets executed in L1 qemu when L2 is launched,
> + * needs kvm-hv support in L1 kernel.
> + */
> + if (!kvmppc_has_cap_nested_kvm_hv()) {
> + error_setg(errp,
> + "KVM implementation does not support Nested-HV");
> + } else if (kvmppc_set_cap_nested_kvm_hv(val) < 0) {
> + error_setg(errp, "Error enabling Nested-HV with KVM");
> + }
> + }
> + if (spapr->nested.api) {
> + warn_report("nested.api already set as %d, re-init to nested-papr",
> + spapr->nested.api);
> + }
> + spapr->nested.api = NESTED_API_PAPR;
> + spapr->nested.capabilities_set = false;
> + spapr_unregister_nested_papr(); /* reset across reboots */
> + spapr_register_nested_papr();
> + spapr_nested_gsb_init();
> +}
> +
> static void cap_large_decr_apply(SpaprMachineState *spapr,
> uint8_t val, Error **errp)
> {
> @@ -738,6 +784,15 @@ SpaprCapabilityInfo capability_table[SPAPR_CAP_NUM] = {
> .type = "bool",
> .apply = cap_nested_kvm_hv_apply,
> },
> + [SPAPR_CAP_NESTED_PAPR] = {
> + .name = "nested-papr",
> + .description = "Allow Nested HV (PAPR API)",
> + .index = SPAPR_CAP_NESTED_PAPR,
> + .get = spapr_cap_get_bool,
> + .set = spapr_cap_set_bool,
> + .type = "bool",
> + .apply = cap_nested_papr_apply,
> + },
> [SPAPR_CAP_LARGE_DECREMENTER] = {
> .name = "large-decr",
> .description = "Allow Large Decrementer",
> @@ -922,6 +977,7 @@ SPAPR_CAP_MIG_STATE(sbbc, SPAPR_CAP_SBBC);
> SPAPR_CAP_MIG_STATE(ibs, SPAPR_CAP_IBS);
> SPAPR_CAP_MIG_STATE(hpt_maxpagesize, SPAPR_CAP_HPT_MAXPAGESIZE);
> SPAPR_CAP_MIG_STATE(nested_kvm_hv, SPAPR_CAP_NESTED_KVM_HV);
> +SPAPR_CAP_MIG_STATE(nested_papr, SPAPR_CAP_NESTED_PAPR);
> SPAPR_CAP_MIG_STATE(large_decr, SPAPR_CAP_LARGE_DECREMENTER);
> SPAPR_CAP_MIG_STATE(ccf_assist, SPAPR_CAP_CCF_ASSIST);
> SPAPR_CAP_MIG_STATE(fwnmi, SPAPR_CAP_FWNMI);
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index db1c59a8f5..6e6a90616e 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -13,8 +13,6 @@
> void spapr_nested_init(SpaprMachineState *spapr)
> {
> spapr->nested.api = 0;
> - spapr->nested.capabilities_set = false;
> - spapr_nested_gsb_init();
> }
>
> uint8_t spapr_nested_api(SpaprMachineState *spapr)
> @@ -1821,6 +1819,18 @@ void spapr_register_nested_papr(void)
> spapr_register_hypercall(H_GUEST_RUN_VCPU , h_guest_run_vcpu);
> }
>
> +void spapr_unregister_nested_papr(void)
> +{
> + spapr_unregister_hypercall(H_GUEST_GET_CAPABILITIES);
> + spapr_unregister_hypercall(H_GUEST_SET_CAPABILITIES);
> + spapr_unregister_hypercall(H_GUEST_CREATE);
> + spapr_unregister_hypercall(H_GUEST_DELETE);
> + spapr_unregister_hypercall(H_GUEST_CREATE_VCPU);
> + spapr_unregister_hypercall(H_GUEST_SET_STATE);
> + spapr_unregister_hypercall(H_GUEST_GET_STATE);
> + spapr_unregister_hypercall(H_GUEST_RUN_VCPU);
> +}
Oh they all came at once here.
And... you're not doing the same thing with the register_hypercall I
guess because then you have function defined but not used warnings?
I would just add the unregister in the same patches that add the
register.
Thanks,
Nick
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API
2024-02-27 10:22 ` Nicholas Piggin
@ 2024-03-05 8:24 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-03-05 8:24 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 15:52, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> Introduce a SPAPR capability cap-nested-papr which enables nested PAPR
>> API for nested guests. This new API is to enable support for KVM on PowerVM
>> and the support in Linux kernel has already merged upstream.
>>
>> Signed-off-by: Michael Neuling <mikey@neuling.org>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> include/hw/ppc/spapr.h | 6 ++++-
>> hw/ppc/spapr.c | 2 ++
>> hw/ppc/spapr_caps.c | 56 ++++++++++++++++++++++++++++++++++++++++++
>> hw/ppc/spapr_nested.c | 19 ++++++++++++--
>> 4 files changed, 80 insertions(+), 3 deletions(-)
>>
>> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
>> index 036a7db2bc..1b1d37123a 100644
>> --- a/include/hw/ppc/spapr.h
>> +++ b/include/hw/ppc/spapr.h
>> @@ -81,8 +81,10 @@ typedef enum {
>> #define SPAPR_CAP_RPT_INVALIDATE 0x0B
>> /* Support for AIL modes */
>> #define SPAPR_CAP_AIL_MODE_3 0x0C
>> +/* Nested PAPR */
>> +#define SPAPR_CAP_NESTED_PAPR 0x0D
>> /* Num Caps */
>> -#define SPAPR_CAP_NUM (SPAPR_CAP_AIL_MODE_3 + 1)
>> +#define SPAPR_CAP_NUM (SPAPR_CAP_NESTED_PAPR + 1)
>>
>> /*
>> * Capability Values
>> @@ -994,6 +996,7 @@ extern const VMStateDescription vmstate_spapr_cap_sbbc;
>> extern const VMStateDescription vmstate_spapr_cap_ibs;
>> extern const VMStateDescription vmstate_spapr_cap_hpt_maxpagesize;
>> extern const VMStateDescription vmstate_spapr_cap_nested_kvm_hv;
>> +extern const VMStateDescription vmstate_spapr_cap_nested_papr;
>> extern const VMStateDescription vmstate_spapr_cap_large_decr;
>> extern const VMStateDescription vmstate_spapr_cap_ccf_assist;
>> extern const VMStateDescription vmstate_spapr_cap_fwnmi;
>> @@ -1041,5 +1044,6 @@ void spapr_watchdog_init(SpaprMachineState *spapr);
>> void spapr_register_nested_hv(void);
>> void spapr_unregister_nested_hv(void);
>> void spapr_register_nested_papr(void);
>> +void spapr_unregister_nested_papr(void);
>>
>> #endif /* HW_SPAPR_H */
>> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
>> index 3453b30a57..cb556ae6a8 100644
>> --- a/hw/ppc/spapr.c
>> +++ b/hw/ppc/spapr.c
>> @@ -2120,6 +2120,7 @@ static const VMStateDescription vmstate_spapr = {
>> &vmstate_spapr_cap_fwnmi,
>> &vmstate_spapr_fwnmi,
>> &vmstate_spapr_cap_rpt_invalidate,
>> + &vmstate_spapr_cap_nested_papr,
>> NULL
>> }
>> };
>> @@ -4688,6 +4689,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
>> smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_WORKAROUND;
>> smc->default_caps.caps[SPAPR_CAP_HPT_MAXPAGESIZE] = 16; /* 64kiB */
>> smc->default_caps.caps[SPAPR_CAP_NESTED_KVM_HV] = SPAPR_CAP_OFF;
>> + smc->default_caps.caps[SPAPR_CAP_NESTED_PAPR] = SPAPR_CAP_OFF;
>> smc->default_caps.caps[SPAPR_CAP_LARGE_DECREMENTER] = SPAPR_CAP_ON;
>> smc->default_caps.caps[SPAPR_CAP_CCF_ASSIST] = SPAPR_CAP_ON;
>> smc->default_caps.caps[SPAPR_CAP_FWNMI] = SPAPR_CAP_ON;
>> diff --git a/hw/ppc/spapr_caps.c b/hw/ppc/spapr_caps.c
>> index 721ddad23b..9a29ce1872 100644
>> --- a/hw/ppc/spapr_caps.c
>> +++ b/hw/ppc/spapr_caps.c
>> @@ -487,12 +487,58 @@ static void cap_nested_kvm_hv_apply(SpaprMachineState *spapr,
>> error_append_hint(errp, "Try appending -machine cap-nested-hv=off "
>> "or use threads=1 with -smp\n");
>> }
>> + if (spapr->nested.api) {
>> + warn_report("nested.api already set as %d, re-init to kvm-hv",
>> + spapr->nested.api);
>> + }
>
> Does this warning trigger when you reset the machine?
>
> It's trying to catch both caps enabled? I would make that an error and
> fail and tell user to enable only one or the other.
>
> (In a future patch I think we should try permit both to be enabled at
> the same time, but for now restricting it is fine)
Yeh, we had kept it mutually exclusive initially in v1, and looks like
we want it to be exclusive for now. Future possibilities can be explored
later as suggested.
>
>> spapr->nested.api = NESTED_API_KVM_HV;
>> spapr_unregister_nested_hv(); /* reset across reboots */
>> spapr_register_nested_hv();
>> }
>> }
>>
>> +static void cap_nested_papr_apply(SpaprMachineState *spapr,
>> + uint8_t val, Error **errp)
>> +{
>> + ERRP_GUARD();
>> + PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
>> + CPUPPCState *env = &cpu->env;
>> +
>> + if (!val) {
>> + /* capability disabled by default */
>> + return;
>> + }
>> +
>> + if (tcg_enabled()) {
>> + if (!(env->insns_flags2 & PPC2_ISA300)) {
>> + error_setg(errp, "Nested-PAPR only supported on POWER9 and later");
>> + error_append_hint(errp,
>> + "Try appending -machine cap-nested-papr=off\n");
>> + return;
>> + }
>> + } else if (kvm_enabled()) {
>> + /*
>> + * this gets executed in L1 qemu when L2 is launched,
>> + * needs kvm-hv support in L1 kernel.
>> + */
>> + if (!kvmppc_has_cap_nested_kvm_hv()) {
>> + error_setg(errp,
>> + "KVM implementation does not support Nested-HV");
>> + } else if (kvmppc_set_cap_nested_kvm_hv(val) < 0) {
>> + error_setg(errp, "Error enabling Nested-HV with KVM");
>> + }
>> + }
>> + if (spapr->nested.api) {
>> + warn_report("nested.api already set as %d, re-init to nested-papr",
>> + spapr->nested.api);
>> + }
>> + spapr->nested.api = NESTED_API_PAPR;
>> + spapr->nested.capabilities_set = false;
>> + spapr_unregister_nested_papr(); /* reset across reboots */
>> + spapr_register_nested_papr();
>> + spapr_nested_gsb_init();
>> +}
>> +
>> static void cap_large_decr_apply(SpaprMachineState *spapr,
>> uint8_t val, Error **errp)
>> {
>> @@ -738,6 +784,15 @@ SpaprCapabilityInfo capability_table[SPAPR_CAP_NUM] = {
>> .type = "bool",
>> .apply = cap_nested_kvm_hv_apply,
>> },
>> + [SPAPR_CAP_NESTED_PAPR] = {
>> + .name = "nested-papr",
>> + .description = "Allow Nested HV (PAPR API)",
>> + .index = SPAPR_CAP_NESTED_PAPR,
>> + .get = spapr_cap_get_bool,
>> + .set = spapr_cap_set_bool,
>> + .type = "bool",
>> + .apply = cap_nested_papr_apply,
>> + },
>> [SPAPR_CAP_LARGE_DECREMENTER] = {
>> .name = "large-decr",
>> .description = "Allow Large Decrementer",
>> @@ -922,6 +977,7 @@ SPAPR_CAP_MIG_STATE(sbbc, SPAPR_CAP_SBBC);
>> SPAPR_CAP_MIG_STATE(ibs, SPAPR_CAP_IBS);
>> SPAPR_CAP_MIG_STATE(hpt_maxpagesize, SPAPR_CAP_HPT_MAXPAGESIZE);
>> SPAPR_CAP_MIG_STATE(nested_kvm_hv, SPAPR_CAP_NESTED_KVM_HV);
>> +SPAPR_CAP_MIG_STATE(nested_papr, SPAPR_CAP_NESTED_PAPR);
>> SPAPR_CAP_MIG_STATE(large_decr, SPAPR_CAP_LARGE_DECREMENTER);
>> SPAPR_CAP_MIG_STATE(ccf_assist, SPAPR_CAP_CCF_ASSIST);
>> SPAPR_CAP_MIG_STATE(fwnmi, SPAPR_CAP_FWNMI);
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index db1c59a8f5..6e6a90616e 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -13,8 +13,6 @@
>> void spapr_nested_init(SpaprMachineState *spapr)
>> {
>> spapr->nested.api = 0;
>> - spapr->nested.capabilities_set = false;
>> - spapr_nested_gsb_init();
>> }
>>
>> uint8_t spapr_nested_api(SpaprMachineState *spapr)
>> @@ -1821,6 +1819,18 @@ void spapr_register_nested_papr(void)
>> spapr_register_hypercall(H_GUEST_RUN_VCPU , h_guest_run_vcpu);
>> }
>>
>> +void spapr_unregister_nested_papr(void)
>> +{
>> + spapr_unregister_hypercall(H_GUEST_GET_CAPABILITIES);
>> + spapr_unregister_hypercall(H_GUEST_SET_CAPABILITIES);
>> + spapr_unregister_hypercall(H_GUEST_CREATE);
>> + spapr_unregister_hypercall(H_GUEST_DELETE);
>> + spapr_unregister_hypercall(H_GUEST_CREATE_VCPU);
>> + spapr_unregister_hypercall(H_GUEST_SET_STATE);
>> + spapr_unregister_hypercall(H_GUEST_GET_STATE);
>> + spapr_unregister_hypercall(H_GUEST_RUN_VCPU);
>> +}
>
> Oh they all came at once here.
>
> And... you're not doing the same thing with the register_hypercall I
> guess because then you have function defined but not used warnings?
> I would just add the unregister in the same patches that add the
> register.
Yeh, v5 shall have unregistrations and registrations for each hcall
together.
regards,
Harsh
>
> Thanks,
> Nick
^ permalink raw reply [flat|nested] 38+ messages in thread
* [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set
2024-02-20 8:35 [PATCH v4 00/15] Nested PAPR API (KVM on PowerVM) Harsh Prateek Bora
` (13 preceding siblings ...)
2024-02-20 8:36 ` [PATCH v4 14/15] spapr: nested: Introduce cap-nested-papr for Nested PAPR API Harsh Prateek Bora
@ 2024-02-20 8:36 ` Harsh Prateek Bora
2024-02-27 10:23 ` Nicholas Piggin
14 siblings, 1 reply; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-02-20 8:36 UTC (permalink / raw)
To: npiggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
From: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
In APIv1, KVM L0 sets the PCR, while in the nested papr APIv2, this
doesn't work as the PCR can't be set via the guest state buffer; the
logical PVR is set via the GSB though.
This change sets the PCR whenever the logical PVR is set via the GSB.
Also, unlike the other registers, the value 1 in a defined bit in the
PCR makes the affected resources unavailable and the value 0 makes
them available. Hence, the PCR is set accordingly.
Signed-off-by: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
include/hw/ppc/spapr_nested.h | 9 +++++++++
hw/ppc/spapr_nested.c | 24 ++++++++++++++++++++++++
2 files changed, 33 insertions(+)
diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
index da918d2dd0..f67c721f53 100644
--- a/include/hw/ppc/spapr_nested.h
+++ b/include/hw/ppc/spapr_nested.h
@@ -229,6 +229,15 @@ typedef struct SpaprMachineStateNestedGuest {
#define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
#define GUEST_STATE_REQUEST_SET 0x2
+/* As per ISA v3.1B, following bits are reserved:
+ * 0:2
+ * 4:57 (ISA mentions bit 58 as well but it should be used for P10)
+ * 61:63 (hence, haven't included PCR bits for v2.06 and v2.05
+ * in LOW BITS)
+ */
+#define PCR_LOW_BITS (PCR_COMPAT_3_10 | PCR_COMPAT_3_00)
+#define HVMASK_PCR ~PCR_LOW_BITS
+
#define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
.id = (i), \
.size = (sz), \
diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
index 6e6a90616e..af8a482337 100644
--- a/hw/ppc/spapr_nested.c
+++ b/hw/ppc/spapr_nested.c
@@ -740,9 +740,11 @@ static void out_buf_min_size(void *a, void *b, bool set)
static void copy_logical_pvr(void *a, void *b, bool set)
{
+ SpaprMachineStateNestedGuest *guest;
uint32_t *buf; /* 1 word */
uint32_t *pvr_logical_ptr;
uint32_t pvr_logical;
+ target_ulong pcr = 0;
pvr_logical_ptr = a;
buf = b;
@@ -755,6 +757,28 @@ static void copy_logical_pvr(void *a, void *b, bool set)
pvr_logical = be32_to_cpu(buf[0]);
*pvr_logical_ptr = pvr_logical;
+
+ if (*pvr_logical_ptr) {
+ switch (*pvr_logical_ptr) {
+ case CPU_POWERPC_LOGICAL_3_10:
+ pcr = PCR_COMPAT_3_10 | PCR_COMPAT_3_00;
+ break;
+ case CPU_POWERPC_LOGICAL_3_00:
+ pcr = PCR_COMPAT_3_00;
+ break;
+ default:
+ qemu_log_mask(LOG_GUEST_ERROR,
+ "Could not set PCR for LPVR=0x%08x\n", *pvr_logical_ptr);
+ return;
+ }
+ }
+
+ guest = container_of(pvr_logical_ptr,
+ struct SpaprMachineStateNestedGuest,
+ pvr_logical);
+ for (int i = 0; i < guest->vcpus; i++) {
+ guest->vcpu[i].state.pcr = ~pcr | HVMASK_PCR;
+ }
}
static void copy_tb_offset(void *a, void *b, bool set)
--
2.39.3
^ permalink raw reply related [flat|nested] 38+ messages in thread* Re: [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set
2024-02-20 8:36 ` [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set Harsh Prateek Bora
@ 2024-02-27 10:23 ` Nicholas Piggin
2024-03-05 8:26 ` Harsh Prateek Bora
0 siblings, 1 reply; 38+ messages in thread
From: Nicholas Piggin @ 2024-02-27 10:23 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
> From: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
>
> In APIv1, KVM L0 sets the PCR, while in the nested papr APIv2, this
> doesn't work as the PCR can't be set via the guest state buffer; the
> logical PVR is set via the GSB though.
>
> This change sets the PCR whenever the logical PVR is set via the GSB.
> Also, unlike the other registers, the value 1 in a defined bit in the
> PCR makes the affected resources unavailable and the value 0 makes
> them available. Hence, the PCR is set accordingly.
Should this be squashed in as a fix?
Thanks,
Nick
>
> Signed-off-by: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> include/hw/ppc/spapr_nested.h | 9 +++++++++
> hw/ppc/spapr_nested.c | 24 ++++++++++++++++++++++++
> 2 files changed, 33 insertions(+)
>
> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
> index da918d2dd0..f67c721f53 100644
> --- a/include/hw/ppc/spapr_nested.h
> +++ b/include/hw/ppc/spapr_nested.h
> @@ -229,6 +229,15 @@ typedef struct SpaprMachineStateNestedGuest {
> #define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
> #define GUEST_STATE_REQUEST_SET 0x2
>
> +/* As per ISA v3.1B, following bits are reserved:
> + * 0:2
> + * 4:57 (ISA mentions bit 58 as well but it should be used for P10)
> + * 61:63 (hence, haven't included PCR bits for v2.06 and v2.05
> + * in LOW BITS)
> + */
> +#define PCR_LOW_BITS (PCR_COMPAT_3_10 | PCR_COMPAT_3_00)
> +#define HVMASK_PCR ~PCR_LOW_BITS
> +
> #define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
> .id = (i), \
> .size = (sz), \
> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
> index 6e6a90616e..af8a482337 100644
> --- a/hw/ppc/spapr_nested.c
> +++ b/hw/ppc/spapr_nested.c
> @@ -740,9 +740,11 @@ static void out_buf_min_size(void *a, void *b, bool set)
>
> static void copy_logical_pvr(void *a, void *b, bool set)
> {
> + SpaprMachineStateNestedGuest *guest;
> uint32_t *buf; /* 1 word */
> uint32_t *pvr_logical_ptr;
> uint32_t pvr_logical;
> + target_ulong pcr = 0;
>
> pvr_logical_ptr = a;
> buf = b;
> @@ -755,6 +757,28 @@ static void copy_logical_pvr(void *a, void *b, bool set)
> pvr_logical = be32_to_cpu(buf[0]);
>
> *pvr_logical_ptr = pvr_logical;
> +
> + if (*pvr_logical_ptr) {
> + switch (*pvr_logical_ptr) {
> + case CPU_POWERPC_LOGICAL_3_10:
> + pcr = PCR_COMPAT_3_10 | PCR_COMPAT_3_00;
> + break;
> + case CPU_POWERPC_LOGICAL_3_00:
> + pcr = PCR_COMPAT_3_00;
> + break;
> + default:
> + qemu_log_mask(LOG_GUEST_ERROR,
> + "Could not set PCR for LPVR=0x%08x\n", *pvr_logical_ptr);
> + return;
> + }
> + }
> +
> + guest = container_of(pvr_logical_ptr,
> + struct SpaprMachineStateNestedGuest,
> + pvr_logical);
> + for (int i = 0; i < guest->vcpus; i++) {
> + guest->vcpu[i].state.pcr = ~pcr | HVMASK_PCR;
> + }
> }
>
> static void copy_tb_offset(void *a, void *b, bool set)
^ permalink raw reply [flat|nested] 38+ messages in thread* Re: [PATCH v4 15/15] spapr: nested: Set the PCR when logical PVR is set
2024-02-27 10:23 ` Nicholas Piggin
@ 2024-03-05 8:26 ` Harsh Prateek Bora
0 siblings, 0 replies; 38+ messages in thread
From: Harsh Prateek Bora @ 2024-03-05 8:26 UTC (permalink / raw)
To: Nicholas Piggin, qemu-ppc
Cc: clegoate, mikey, amachhiw, vaibhav, sbhat, danielhb413,
qemu-devel
On 2/27/24 15:53, Nicholas Piggin wrote:
> On Tue Feb 20, 2024 at 6:36 PM AEST, Harsh Prateek Bora wrote:
>> From: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
>>
>> In APIv1, KVM L0 sets the PCR, while in the nested papr APIv2, this
>> doesn't work as the PCR can't be set via the guest state buffer; the
>> logical PVR is set via the GSB though.
>>
>> This change sets the PCR whenever the logical PVR is set via the GSB.
>> Also, unlike the other registers, the value 1 in a defined bit in the
>> PCR makes the affected resources unavailable and the value 0 makes
>> them available. Hence, the PCR is set accordingly.
>
> Should this be squashed in as a fix?
Yeh, it can be squashed with 10/15 GSB initialization patch, will update
as suggested in v5.
regards,
Harsh
>
> Thanks,
> Nick
>
>>
>> Signed-off-by: Amit Machhiwal <amachhiw@linux.vnet.ibm.com>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> include/hw/ppc/spapr_nested.h | 9 +++++++++
>> hw/ppc/spapr_nested.c | 24 ++++++++++++++++++++++++
>> 2 files changed, 33 insertions(+)
>>
>> diff --git a/include/hw/ppc/spapr_nested.h b/include/hw/ppc/spapr_nested.h
>> index da918d2dd0..f67c721f53 100644
>> --- a/include/hw/ppc/spapr_nested.h
>> +++ b/include/hw/ppc/spapr_nested.h
>> @@ -229,6 +229,15 @@ typedef struct SpaprMachineStateNestedGuest {
>> #define GUEST_STATE_REQUEST_GUEST_WIDE 0x1
>> #define GUEST_STATE_REQUEST_SET 0x2
>>
>> +/* As per ISA v3.1B, following bits are reserved:
>> + * 0:2
>> + * 4:57 (ISA mentions bit 58 as well but it should be used for P10)
>> + * 61:63 (hence, haven't included PCR bits for v2.06 and v2.05
>> + * in LOW BITS)
>> + */
>> +#define PCR_LOW_BITS (PCR_COMPAT_3_10 | PCR_COMPAT_3_00)
>> +#define HVMASK_PCR ~PCR_LOW_BITS
>> +
>> #define GUEST_STATE_ELEMENT(i, sz, s, f, ptr, c) { \
>> .id = (i), \
>> .size = (sz), \
>> diff --git a/hw/ppc/spapr_nested.c b/hw/ppc/spapr_nested.c
>> index 6e6a90616e..af8a482337 100644
>> --- a/hw/ppc/spapr_nested.c
>> +++ b/hw/ppc/spapr_nested.c
>> @@ -740,9 +740,11 @@ static void out_buf_min_size(void *a, void *b, bool set)
>>
>> static void copy_logical_pvr(void *a, void *b, bool set)
>> {
>> + SpaprMachineStateNestedGuest *guest;
>> uint32_t *buf; /* 1 word */
>> uint32_t *pvr_logical_ptr;
>> uint32_t pvr_logical;
>> + target_ulong pcr = 0;
>>
>> pvr_logical_ptr = a;
>> buf = b;
>> @@ -755,6 +757,28 @@ static void copy_logical_pvr(void *a, void *b, bool set)
>> pvr_logical = be32_to_cpu(buf[0]);
>>
>> *pvr_logical_ptr = pvr_logical;
>> +
>> + if (*pvr_logical_ptr) {
>> + switch (*pvr_logical_ptr) {
>> + case CPU_POWERPC_LOGICAL_3_10:
>> + pcr = PCR_COMPAT_3_10 | PCR_COMPAT_3_00;
>> + break;
>> + case CPU_POWERPC_LOGICAL_3_00:
>> + pcr = PCR_COMPAT_3_00;
>> + break;
>> + default:
>> + qemu_log_mask(LOG_GUEST_ERROR,
>> + "Could not set PCR for LPVR=0x%08x\n", *pvr_logical_ptr);
>> + return;
>> + }
>> + }
>> +
>> + guest = container_of(pvr_logical_ptr,
>> + struct SpaprMachineStateNestedGuest,
>> + pvr_logical);
>> + for (int i = 0; i < guest->vcpus; i++) {
>> + guest->vcpu[i].state.pcr = ~pcr | HVMASK_PCR;
>> + }
>> }
>>
>> static void copy_tb_offset(void *a, void *b, bool set)
>
^ permalink raw reply [flat|nested] 38+ messages in thread