Skip to contentSkip to conversation

ppc/kvm: Handle CPU compatibility mode correctly for nested guests

PATCH Superseded Amit Machhiwal 3 participants 8 messages May 2 – Jun 3 KVM

v2 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

v2 cover ppc/kvm: Handle CPU compatibility mode correctly for nested guests

On POWER systems, newer processor generations can operate in compatibility modes corresponding to earlier generations (e.g., a Power11 system running in Power10 compatibility mode). In such cases, the effective CPU level exposed to guests differs from the physical processor generation.

This creates issues for nested virtualization. When booting a nested KVM guest, QEMU may derive the CPU model from the raw hardware PVR and attempt to configure the guest accordingly. However, the host is constrained by the compatibility level negotiated with the hypervisor, and requests exceeding that level are rejected by KVM, leading to guest boot failures such as:

KVM-NESTEDv2: couldn't set guest wide elements

This series addresses the issue in two ways:

1. Do not silently fall back to raw mode when KVM rejects a requested compatibility level during CAS. Instead, propagate the error so invalid configurations are visible and fail early.

2. Query the effective CPU compatibility modes supported by the host via KVM and use this information to select an appropriate CPU model for nested guests.

With these changes, QEMU avoids masking KVM errors and ensures that nested guests are configured with CPU models consistent with the host compatibility mode, allowing them to boot correctly.

Patch summary:
[1/3] hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat [2/3] [DO_NOT_MERGE] linux-headers: Add uapi header changes [3/3] target/ppc/kvm: Use host compatibility mode for nested guests

Changes in v2:
- Patch 3: Guard compatibility mode code with #if defined(TARGET_PPC64) to fix compilation for ppc32 targets. The POWER9/10/11 PVR constants are only defined for 64-bit builds, and compatibility modes are only relevant for 64-bit systems.

Tested on:
- Power11 pSeries LPAR in Power10 compatibility mode
- Power10 PowerNV and QEMU PowerNV 11 TCG L0 host

CI test results: https://gitlab.com/amachhiw/qemu/-/pipelines/2494987253

Note: Patch 2 is marked DO_NOT_MERGE as it contains linux-headers updates that will be synced separately once the corresponding kernel patches are merged.

The corresponding Linux patches have been posted [1]

[1] https://lore.kernel.org/all/[email protected]/

Amit Machhiwal (3):
hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat [DO_NOT_MERGE] linux-headers: Add uapi header changes target/ppc/kvm: Use host compatibility mode for nested guests

 hw/ppc/spapr_hcall.c            |  9 ++++++
 linux-headers/asm-powerpc/kvm.h |  7 ++++
 linux-headers/linux/kvm.h       |  3 ++
 target/ppc/kvm.c                | 57 +++++++++++++++++++++++++++++++++
 4 files changed, 76 insertions(+)

base-commit: 3d626609ccae61a2e552bccd59c7a0931bab8261

Signature · 1 line
2.50.1 (Apple Git-155)
#1 lore raw

PATCH v2 1/3 hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat

During H_CLIENT_ARCHITECTURE_SUPPORT, QEMU attempts to set the requested CPU compatibility mode via ppc_set_compat_all(). If this fails, the existing code may fall back to raw mode when supported by the guest.

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

When running with KVM, such failures indicate that the requested compatibility level is not supported by the host. Do not fallback in this case; instead, report the error and fail the CAS negotiation.

This makes the failure visible to the user and ensures that invalid compatibility requests are rejected early rather than being hidden by fallback behavior. For example, the following error is now reported:

qemu-system-ppc64: Unable to set CPU compatibility mode in KVM: Invalid argument

Fixes cc7b35b169e9 ("spapr: fallback to raw mode if best compat mode cannot be set during CAS")
---
 hw/ppc/spapr_hcall.c | 9 +++++++++
 1 file changed, 9 insertions(+)
hw/ppc/spapr_hcall.c +9 -0
index 032805a8d0db..de2ea6f5e579 100644
@@ -1204,6 +1204,15 @@ target_ulong do_client_architecture_support(PowerPCCPU *cpu,
         Error *local_err = NULL;
 
         if (ppc_set_compat_all(cas_pvr, &local_err) < 0) {
+            /*
+             * If KVM rejected the compat mode, do not fallback. This indicates
+             * the host cannot support the requested level.
+             */
+            if (kvm_enabled()) {
+                error_report_err(local_err);
+                return H_HARDWARE;
+            }
+
             /* We fail to set compat mode (likely because running with KVM PR),
              * but maybe we can fallback to raw mode if the guest supports it.
              */
Signature · 1 line
2.50.1 (Apple Git-155)
#2 lore raw

Re: [PATCH v2 1/3] hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat

Hi Amit,

Thanks for the patch. My review comments inline below:

Quoted 34 lines · Amit Machhiwal

During H_CLIENT_ARCHITECTURE_SUPPORT, QEMU attempts to set the requested CPU compatibility mode via ppc_set_compat_all(). If this fails, the existing code may fall back to raw mode when supported by the guest.

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

When running with KVM, such failures indicate that the requested compatibility level is not supported by the host. Do not fallback in this case; instead, report the error and fail the CAS negotiation.

This makes the failure visible to the user and ensures that invalid compatibility requests are rejected early rather than being hidden by fallback behavior. For example, the following error is now reported:

qemu-system-ppc64: Unable to set CPU compatibility mode in KVM: Invalid argument

Fixes cc7b35b169e9 ("spapr: fallback to raw mode if best compat mode cannot be set during CAS")
---
 hw/ppc/spapr_hcall.c | 9 +++++++++
 1 file changed, 9 insertions(+)
hw/ppc/spapr_hcall.c +0 -0
index 032805a8d0db..de2ea6f5e579 100644
@@ -1204,6 +1204,15 @@ target_ulong do_client_architecture_support(PowerPCCPU *cpu,
         Error *local_err = NULL;
 

hw/ppc/spapr_hcall.c target_ulong do_client_architecture_support(PowerPCCPU *cpu, · line 1215

Quoted 10 lines
hw/ppc/spapr_hcall.c +9 -0
         if (ppc_set_compat_all(cas_pvr, &local_err) < 0) {
+            /*
+             * If KVM rejected the compat mode, do not fallback. This indicates
+             * the host cannot support the requested level.
+             */
+            if (kvm_enabled()) {
+                error_report_err(local_err);
+                return H_HARDWARE;
+            }
+

NAK on this change.

As per PAPR whether the guest can run in RAW mode needs to be negotiated between Guest and VMM. The existing code path via cas_check_pvr() and 'raw_mode_supported' already handles this case.

So I dont see a reason for this KVM specific changes needed. Can you please elaborate a bit more on the issue that gets fixed by this change.

If this change is related to your Linux kernel patch series titled "KVM: PPC: Handle CPU compatibility mode for nested guests" then the ideal place to put compat check would be in ppc_check_compat() and not in do_client_architecture_support()

Quoted 6 lines
hw/ppc/spapr_hcall.c +0 -0
             /* We fail to set compat mode (likely because running with KVM PR),
              * but maybe we can fallback to raw mode if the guest supports it.
              */
Signature · 1 line
2.50.1 (Apple Git-155)
Signature · 2 lines
Cheers
~ Vaibhav
#3 lore raw

Re: [PATCH v2 1/3] hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat

Hi Vaibhav,

Thanks for taking a look at this patch. My response is inline:

Quoted 53 lines · Vaibhav Jain

Hi Amit,

Thanks for the patch. My review comments inline below:

Quoted 34 lines · Amit Machhiwal

During H_CLIENT_ARCHITECTURE_SUPPORT, QEMU attempts to set the requested CPU compatibility mode via ppc_set_compat_all(). If this fails, the existing code may fall back to raw mode when supported by the guest.

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

When running with KVM, such failures indicate that the requested compatibility level is not supported by the host. Do not fallback in this case; instead, report the error and fail the CAS negotiation.

This makes the failure visible to the user and ensures that invalid compatibility requests are rejected early rather than being hidden by fallback behavior. For example, the following error is now reported:

qemu-system-ppc64: Unable to set CPU compatibility mode in KVM: Invalid argument

Fixes cc7b35b169e9 ("spapr: fallback to raw mode if best compat mode cannot be set during CAS")
---
 hw/ppc/spapr_hcall.c | 9 +++++++++
 1 file changed, 9 insertions(+)
hw/ppc/spapr_hcall.c +0 -0
index 032805a8d0db..de2ea6f5e579 100644
@@ -1204,6 +1204,15 @@ target_ulong do_client_architecture_support(PowerPCCPU *cpu,
         Error *local_err = NULL;
 

hw/ppc/spapr_hcall.c target_ulong do_client_architecture_support(PowerPCCPU *cpu, · line 1215

Quoted 10 lines
hw/ppc/spapr_hcall.c +9 -0
         if (ppc_set_compat_all(cas_pvr, &local_err) < 0) {
+            /*
+             * If KVM rejected the compat mode, do not fallback. This indicates
+             * the host cannot support the requested level.
+             */
+            if (kvm_enabled()) {
+                error_report_err(local_err);
+                return H_HARDWARE;
+            }
+

NAK on this change.

Quoted 6 lines

As per PAPR whether the guest can run in RAW mode needs to be negotiated between Guest and VMM. The existing code path via cas_check_pvr() and 'raw_mode_supported' already handles this case.

So I dont see a reason for this KVM specific changes needed. Can you please elaborate a bit more on the issue that gets fixed by this change.

I have mentioned the reason in the commit message. I'm quoting the part of it below:

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

The currently call chain is as below:

do_client_architecture_support()
-> ppc_set_compat_all()

     -> run_on_cpu()
       -> do_run_on_cpu()
         -> do_set_compat()
           -> ppc_set_compat()
             -> kvmppc_set_compat()  // returns error

Now when an error is returned via kvmppc_set_comapt(), its just ignored in the current situation silently in do_client_architecture_support(), while the caller is supposed to handle the error returned in an errp object. This would make the guest try to continue with a raw mode when the host was actually booted in a compatibility mode, while it shouldn't be doing that.

Please let me know your further views on this.

Thanks,
Amit

Quoted 17 lines

If this change is related to your Linux kernel patch series titled "KVM: PPC: Handle CPU compatibility mode for nested guests" then the ideal place to put compat check would be in ppc_check_compat() and not in do_client_architecture_support()

Quoted 6 lines
hw/ppc/spapr_hcall.c +0 -0
             /* We fail to set compat mode (likely because running with KVM PR),
              * but maybe we can fallback to raw mode if the guest supports it.
              */
Signature · 1 line
2.50.1 (Apple Git-155)
Signature · 2 lines
Cheers
~ Vaibhav
#4 lore raw

Re: [PATCH v2 1/3] hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat

Quoted 84 lines · Amit Machhiwal

Hi Vaibhav,

Thanks for taking a look at this patch. My response is inline:

Quoted 53 lines · Vaibhav Jain

Hi Amit,

Thanks for the patch. My review comments inline below:

Quoted 34 lines · Amit Machhiwal

During H_CLIENT_ARCHITECTURE_SUPPORT, QEMU attempts to set the requested CPU compatibility mode via ppc_set_compat_all(). If this fails, the existing code may fall back to raw mode when supported by the guest.

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

When running with KVM, such failures indicate that the requested compatibility level is not supported by the host. Do not fallback in this case; instead, report the error and fail the CAS negotiation.

This makes the failure visible to the user and ensures that invalid compatibility requests are rejected early rather than being hidden by fallback behavior. For example, the following error is now reported:

qemu-system-ppc64: Unable to set CPU compatibility mode in KVM: Invalid argument

Fixes cc7b35b169e9 ("spapr: fallback to raw mode if best compat mode cannot be set during CAS")
---
 hw/ppc/spapr_hcall.c | 9 +++++++++
 1 file changed, 9 insertions(+)
hw/ppc/spapr_hcall.c +0 -0
index 032805a8d0db..de2ea6f5e579 100644
@@ -1204,6 +1204,15 @@ target_ulong do_client_architecture_support(PowerPCCPU *cpu,
         Error *local_err = NULL;
 

hw/ppc/spapr_hcall.c target_ulong do_client_architecture_support(PowerPCCPU *cpu, · line 1215

Quoted 10 lines
hw/ppc/spapr_hcall.c +9 -0
         if (ppc_set_compat_all(cas_pvr, &local_err) < 0) {
+            /*
+             * If KVM rejected the compat mode, do not fallback. This indicates
+             * the host cannot support the requested level.
+             */
+            if (kvm_enabled()) {
+                error_report_err(local_err);
+                return H_HARDWARE;
+            }
+

NAK on this change.

Quoted 6 lines

As per PAPR whether the guest can run in RAW mode needs to be negotiated between Guest and VMM. The existing code path via cas_check_pvr() and 'raw_mode_supported' already handles this case.

So I dont see a reason for this KVM specific changes needed. Can you please elaborate a bit more on the issue that gets fixed by this change.

I have mentioned the reason in the commit message. I'm quoting the part of it below:

The current logic treats all failures uniformly and tried to fall back to raw mode whenever possible. As a result, errors from KVM (e.g. kvmppc_set_compat() returning -EINVAL) are silently masked, making debugging difficult and allowing the guest to proceed with an unsupported or incompatible configuration.

The currently call chain is as below:

do_client_architecture_support()
-> ppc_set_compat_all()

     -> run_on_cpu()
       -> do_run_on_cpu()
         -> do_set_compat()
           -> ppc_set_compat()
             -> kvmppc_set_compat()  // returns error
Quoted 6 lines

Now when an error is returned via kvmppc_set_comapt(), its just ignored in the current situation silently in do_client_architecture_support(), while the caller is supposed to handle the error returned in an errp object. This would make the guest try to continue with a raw mode when the host was actually booted in a compatibility mode, while it shouldn't be doing that.

Based on an off-mailing list discussion, I'll be working on discussed alternate approach for this. Will post next version based on how that goes. Thanks for the discussion, Vaibhav.

Thanks,
Amit

#5 lore raw

PATCH v2 2/3 linux-headers: Add uapi header changes

In reply to Amit Machhiwal

This is a temporary patch intended for review and testing purposes only. It defines the new ioctls introduced for checking the compatibility modes. The actual header changes are to be done once the kernel changes
[1] are merged.

[1] https://lore.kernel.org/all/[email protected]/

---
 linux-headers/asm-powerpc/kvm.h | 7 +++++++
 linux-headers/linux/kvm.h       | 3 +++
 2 files changed, 10 insertions(+)
linux-headers/asm-powerpc/kvm.h +7 -0
index 077c5437f521..df91b1f40c5b 100644
@@ -437,6 +437,13 @@ struct kvm_ppc_cpu_char {
 	__u64	behaviour_mask;		/* valid bits in behaviour */
 };
 
+/* For KVM_PPC_GET_COMPAT_CAPS */
+struct kvm_ppc_compat_caps {
+       __u32   flags;
+       __u64   compat_capabilities;    /* Capabilities supported by the host */
+};
+
+
 /*
  * Values for character and character_mask.
  * These are identical to the values used by H_GET_CPU_CHARACTERISTICS.
linux-headers/linux/kvm.h +3 -0
index a4ab42dcba97..b0c0014a0a0a 100644
@@ -966,6 +966,7 @@ struct kvm_enable_cap {
 #define KVM_CAP_GUEST_MEMFD_FLAGS 244
 #define KVM_CAP_ARM_SEA_TO_USER 245
 #define KVM_CAP_S390_USER_OPEREXEC 246
+#define KVM_CAP_PPC_COMPAT_CAPS 249
 
 struct kvm_irq_routing_irqchip {
 	__u32 irqchip;
@@ -1295,6 +1296,8 @@ struct kvm_vfio_spapr_tce {
 /* Available with KVM_CAP_COUNTER_OFFSET */
 #define KVM_ARM_SET_COUNTER_OFFSET _IOW(KVMIO,  0xb5, struct kvm_arm_counter_offset)
 #define KVM_ARM_GET_REG_WRITABLE_MASKS _IOR(KVMIO,  0xb6, struct reg_mask_range)
+/* Available with KVM_CAP_PPC_COMPAT_CAPS */
+#define KVM_PPC_GET_COMPAT_CAPS          _IOR(KVMIO,  0xe4, struct kvm_ppc_compat_caps)
 
 /* ioctl for vm fd */
 #define KVM_CREATE_DEVICE	  _IOWR(KVMIO,  0xe0, struct kvm_create_device)
Signature · 1 line
2.50.1 (Apple Git-155)
#6 lore raw

PATCH v2 3/3 target/ppc/kvm: Use host compatibility mode for nested guests

In reply to Amit Machhiwal

On POWER systems, the host CPU may run in a compatibility mode (e.g., a Power11 processor operating in Power10 compatibility mode). In such cases, the effective CPU level exposed to guests differs from the physical processor generation.

When running nested KVM guests, QEMU currently derives the host CPU type using mfpvr(), which reflects the physical processor version. This can result in a mismatch between the CPU model used by QEMU and the compatibility mode enforced by the host, leading to guest boot failures.

In particular, booting a nested guest on a Power11 LPAR configured in Power10 compatibility mode fails with errors such as:

KVM-NESTEDv2: couldn't set guest wide elements

This occurs because QEMU selects a CPU model based on the physical processor version, while the host operates in a lower compatibility mode. As a result, KVM rejects the requested compatibility level during guest initialization.

Add support for querying host compatibility capabilities via the KVM_PPC_GET_COMPAT_CAPS ioctl and derive the effective PVR based on the compatibility mode reported by KVM. When available, use this compatibility PVR instead of the raw hardware PVR when selecting the CPU model.

If the capability is not supported or the query fails, fall back to the existing behavior.

This ensures that QEMU selects a CPU model consistent with the host compatibility mode, allowing nested guests to boot correctly.

---
 target/ppc/kvm.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
target/ppc/kvm.c +57 -0
index 25c28ad089c6..7a00092c4208 100644
@@ -2602,11 +2602,68 @@ bool kvmppc_supports_ail_3(void)
     return cap_ail_mode_3;
 }
 
+#if defined(TARGET_PPC64)
+static target_ulong kvmppc_get_compat_caps(void)
+{
+    struct kvm_ppc_compat_caps host_compat;
+    target_ulong host_caps;
+    int ret;
+
+    if (!kvm_check_extension(kvm_state, KVM_CAP_PPC_COMPAT_CAPS)) {
+        return 0;
+    }
+
+    ret = kvm_vm_ioctl(kvm_state, KVM_PPC_GET_COMPAT_CAPS, &host_compat);
+    if (ret < 0) {
+        fprintf(stderr, "KVM: failed to get host capabilities\n");
+        return 0;
+    }
+
+    host_caps = host_compat.compat_capabilities;
+    return host_caps;
+}
+
+static uint32_t kvm_ppc_host_compat_pvr(void)
+{
+    uint32_t compat_host_pvr = 0;
+    int cap_idx = 0;
+    target_ulong host_caps = kvmppc_get_compat_caps();
+
+    if (host_caps) {
+        cap_idx = 63 - __builtin_ctzll(host_caps);
+        switch (cap_idx) {
+        case H_GUEST_CAP_P9_MODE_BMAP:
+            compat_host_pvr = CPU_POWERPC_POWER9_DD22;
+            break;
+        case H_GUEST_CAP_P10_MODE_BMAP:
+            compat_host_pvr = CPU_POWERPC_POWER10_DD20;
+            break;
+        case H_GUEST_CAP_P11_MODE_BMAP:
+            compat_host_pvr = CPU_POWERPC_POWER11_DD20;
+            break;
+        default:
+            break;
+        }
+    }
+
+    return compat_host_pvr;
+}
+#endif /* TARGET_PPC64 */
+
 PowerPCCPUClass *kvm_ppc_get_host_cpu_class(void)
 {
     uint32_t host_pvr = mfpvr();
     PowerPCCPUClass *pvr_pcc;
 
+#if defined(TARGET_PPC64)
+    uint32_t compat_host_pvr;
+
+    compat_host_pvr = kvm_ppc_host_compat_pvr();
+    if (compat_host_pvr) {
+        host_pvr = compat_host_pvr;
+    }
+#endif /* TARGET_PPC64 */
+
     pvr_pcc = ppc_cpu_class_by_pvr(host_pvr);
     if (pvr_pcc == NULL) {
         pvr_pcc = ppc_cpu_class_by_pvr_mask(host_pvr);
Signature · 1 line
2.50.1 (Apple Git-155)
Tested-by on the v2 series
#7 lore raw
In reply to Amit Machhiwal
Quoted 57 lines · Amit Machhiwal

On POWER systems, newer processor generations can operate in compatibility modes corresponding to earlier generations (e.g., a Power11 system running in Power10 compatibility mode). In such cases, the effective CPU level exposed to guests differs from the physical processor generation.

This creates issues for nested virtualization. When booting a nested KVM guest, QEMU may derive the CPU model from the raw hardware PVR and attempt to configure the guest accordingly. However, the host is constrained by the compatibility level negotiated with the hypervisor, and requests exceeding that level are rejected by KVM, leading to guest boot failures such as:

KVM-NESTEDv2: couldn't set guest wide elements

This series addresses the issue in two ways:

1. Do not silently fall back to raw mode when KVM rejects a requested compatibility level during CAS. Instead, propagate the error so invalid configurations are visible and fail early.

2. Query the effective CPU compatibility modes supported by the host via KVM and use this information to select an appropriate CPU model for nested guests.

With these changes, QEMU avoids masking KVM errors and ensures that nested guests are configured with CPU models consistent with the host compatibility mode, allowing them to boot correctly.

Patch summary:
[1/3] hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat [2/3] [DO_NOT_MERGE] linux-headers: Add uapi header changes [3/3] target/ppc/kvm: Use host compatibility mode for nested guests

Changes in v2:
- Patch 3: Guard compatibility mode code with #if defined(TARGET_PPC64) to fix compilation for ppc32 targets. The POWER9/10/11 PVR constants are only defined for 64-bit builds, and compatibility modes are only relevant for 64-bit systems.

Tested on:
- Power11 pSeries LPAR in Power10 compatibility mode
- Power10 PowerNV and QEMU PowerNV 11 TCG L0 host

CI test results: https://gitlab.com/amachhiw/qemu/-/pipelines/2494987253

Note: Patch 2 is marked DO_NOT_MERGE as it contains linux-headers updates that will be synced separately once the corresponding kernel patches are merged.

The corresponding Linux patches have been posted [1]

[1] https://lore.kernel.org/all/[email protected]/

Amit Machhiwal (3):
hw/ppc/spapr: Do not fallback to raw mode when KVM rejects compat [DO_NOT_MERGE] linux-headers: Add uapi header changes target/ppc/kvm: Use host compatibility mode for nested guests

Quoted 8 lines
  hw/ppc/spapr_hcall.c            |  9 ++++++
  linux-headers/asm-powerpc/kvm.h |  7 ++++
  linux-headers/linux/kvm.h       |  3 ++
  target/ppc/kvm.c                | 57 +++++++++++++++++++++++++++++++++
  4 files changed, 76 insertions(+)

base-commit: 3d626609ccae61a2e552bccd59c7a0931bab8261

Hi Amit,
I tried booting up a guest on P11 lpar booted with P10 compat mode applying your patch along with the linux patch series and it has been working perfectly fine.

Host lscpu:

lscpu
Architecture:                ppc64le
  Byte Order:                Little Endian
CPU(s):                      80
  On-line CPU(s) list:       0-79
Model name:                  POWER10 (architected), altivec supported

Guest lscpu:

lscpu
Architecture:                ppc64le
  Byte Order:                Little Endian
CPU(s):                      10
  On-line CPU(s) list:       0-9
Model name:                  POWER10 (architected), altivec supported

Feel free to add :

Thank you!
Anushree Mathur