QEMU-Devel Archive on lore.kernel.org
 help / color / Atom feed
* [PULL 00/28] ppc-for-4.2 queue 20191024
@ 2019-10-24  8:17 David Gibson
  2019-10-24  8:17 ` [PULL 01/28] xive: Make some device types not user creatable David Gibson
                   ` (28 more replies)
  0 siblings, 29 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

The following changes since commit f78398bfe544db81a974825b0a2aa826f6576414:

  Merge remote-tracking branch 'remotes/ericb/tags/pull-nbd-2019-10-22' into staging (2019-10-23 16:06:13 +0100)

are available in the Git repository at:

  git://github.com/dgibson/qemu.git tags/ppc-for-4.2-20191024

for you to fetch changes up to 97c00c54449b4ff349f85c6ce409dadd1b935a7d:

  spapr/xive: Set the OS CAM line at reset (2019-10-24 13:34:15 +1100)

----------------------------------------------------------------
ppc patch queue 2019-10-24

Last pull request before soft freeze.
  * Lots of fixes and cleanups for spapr interrupt controllers
  * More SLOF updates to fix problems with full FDT rendering at CAS
    time (alas, more yet are to come)
  * A few other assorted changes

This isn't quite as well tested as I usually try to do before a pull
request.  But I've been sick and running into some other difficulties,
and wanted to get this sent out before heading towards KVM forum.

----------------------------------------------------------------
Alexey Kardashevskiy (1):
      pseries: Update SLOF firmware image

Cédric Le Goater (8):
      ppc/pnv: Improve trigger data definition
      ppc/pnv: Use address_space_stq_be() when triggering an interrupt from PSI
      spapr: move CPU reset after presenter creation
      ppc/pnv: Introduce a PnvCore reset handler
      ppc/pnv: Add a PnvChip pointer to PnvCore
      ppc: Reset the interrupt presenter from the CPU reset handler
      ppc/pnv: Fix naming of routines realizing the CPUs
      spapr/xive: Set the OS CAM line at reset

David Gibson (13):
      spapr, xics, xive: Introduce SpaprInterruptController QOM interface
      spapr, xics, xive: Move cpu_intc_create from SpaprIrq to SpaprInterruptController
      spapr, xics, xive: Move irq claim and free from SpaprIrq to SpaprInterruptController
      spapr: Formalize notion of active interrupt controller
      spapr, xics, xive: Move set_irq from SpaprIrq to SpaprInterruptController
      spapr, xics, xive: Move print_info from SpaprIrq to SpaprInterruptController
      spapr, xics, xive: Move dt_populate from SpaprIrq to SpaprInterruptController
      spapr, xics, xive: Match signatures for XICS and XIVE KVM connect routines
      spapr: Remove SpaprIrq::init_kvm hook
      spapr, xics, xive: Move SpaprIrq::reset hook logic into activate/deactivate
      spapr, xics, xive: Move SpaprIrq::post_load hook to backends
      spapr: Remove SpaprIrq::nr_msis
      spapr: Move SpaprIrq::nr_xirqs to SpaprMachineClass

Greg Kurz (5):
      xive: Make some device types not user creatable
      xics: Make some device types not user creatable
      spapr: Set VSMT to smp_threads by default
      spapr: Don't request to unplug the same core twice
      spapr_cpu_core: Implement DeviceClass::reset

Stefan Brankovic (1):
      target/ppc: Fix for optimized vsl/vsr instructions

 hw/intc/pnv_xive.c                  |  20 +-
 hw/intc/spapr_xive.c                | 324 ++++++++++++-------
 hw/intc/spapr_xive_kvm.c            |  22 +-
 hw/intc/xics.c                      |  18 +-
 hw/intc/xics_kvm.c                  |   9 +-
 hw/intc/xics_spapr.c                | 117 ++++++-
 hw/intc/xive.c                      |  31 +-
 hw/ppc/pnv.c                        |  18 ++
 hw/ppc/pnv_core.c                   |  31 +-
 hw/ppc/pnv_psi.c                    |  15 +-
 hw/ppc/spapr.c                      |  26 +-
 hw/ppc/spapr_cpu_core.c             |  47 ++-
 hw/ppc/spapr_irq.c                  | 611 +++++++++++++-----------------------
 hw/ppc/spapr_pci.c                  |   7 +-
 include/hw/pci-host/spapr.h         |   4 +-
 include/hw/ppc/pnv.h                |   1 +
 include/hw/ppc/pnv_core.h           |   3 +
 include/hw/ppc/spapr.h              |   7 +-
 include/hw/ppc/spapr_irq.h          |  64 +++-
 include/hw/ppc/spapr_xive.h         |  10 +-
 include/hw/ppc/xics.h               |   1 +
 include/hw/ppc/xics_spapr.h         |   6 +-
 include/hw/ppc/xive.h               |   1 +
 include/hw/ppc/xive_regs.h          |  26 +-
 pc-bios/README                      |   2 +-
 pc-bios/slof.bin                    | Bin 930640 -> 928552 bytes
 roms/SLOF                           |   2 +-
 target/ppc/translate/vmx-impl.inc.c |  84 +++--
 28 files changed, 840 insertions(+), 667 deletions(-)


^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 01/28] xive: Make some device types not user creatable
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 02/28] xics: " David Gibson
                   ` (27 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Greg Kurz <groug@kaod.org>

Some device types of the XIVE model are exposed to the QEMU command
line:

$ ppc64-softmmu/qemu-system-ppc64 -device help | grep xive
name "xive-end-source", desc "XIVE END Source"
name "xive-source", desc "XIVE Interrupt Source"
name "xive-tctx", desc "XIVE Interrupt Thread Context"

These are internal devices that shouldn't be instantiable by the
user. By the way, they can't be because their respective realize
functions expect link properties that can't be set from the command
line:

qemu-system-ppc64: -device xive-source: required link 'xive' not found:
 Property '.xive' not found
qemu-system-ppc64: -device xive-end-source: required link 'xive' not found:
 Property '.xive' not found
qemu-system-ppc64: -device xive-tctx: required link 'cpu' not found:
 Property '.cpu' not found

Hide them by setting dc->user_creatable to false in their respective
class init functions.

Signed-off-by: Greg Kurz <groug@kaod.org>
Message-Id: <157017473006.331610.2983143972519884544.stgit@bahia.lan>
Message-Id: <157045578401.865784.6058183726552779559.stgit@bahia.lan>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
[dwg: Folded comment update into base patch]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/intc/xive.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/hw/intc/xive.c b/hw/intc/xive.c
index 29df06df11..453d389848 100644
--- a/hw/intc/xive.c
+++ b/hw/intc/xive.c
@@ -670,6 +670,11 @@ static void xive_tctx_class_init(ObjectClass *klass, void *data)
     dc->realize = xive_tctx_realize;
     dc->unrealize = xive_tctx_unrealize;
     dc->vmsd = &vmstate_xive_tctx;
+    /*
+     * Reason: part of XIVE interrupt controller, needs to be wired up
+     * by xive_tctx_create().
+     */
+    dc->user_creatable = false;
 }
 
 static const TypeInfo xive_tctx_info = {
@@ -1118,6 +1123,11 @@ static void xive_source_class_init(ObjectClass *klass, void *data)
     dc->props   = xive_source_properties;
     dc->realize = xive_source_realize;
     dc->vmsd    = &vmstate_xive_source;
+    /*
+     * Reason: part of XIVE interrupt controller, needs to be wired up,
+     * e.g. by spapr_xive_instance_init().
+     */
+    dc->user_creatable = false;
 }
 
 static const TypeInfo xive_source_info = {
@@ -1853,6 +1863,11 @@ static void xive_end_source_class_init(ObjectClass *klass, void *data)
     dc->desc    = "XIVE END Source";
     dc->props   = xive_end_source_properties;
     dc->realize = xive_end_source_realize;
+    /*
+     * Reason: part of XIVE interrupt controller, needs to be wired up,
+     * e.g. by spapr_xive_instance_init().
+     */
+    dc->user_creatable = false;
 }
 
 static const TypeInfo xive_end_source_info = {
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 02/28] xics: Make some device types not user creatable
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
  2019-10-24  8:17 ` [PULL 01/28] xive: Make some device types not user creatable David Gibson
@ 2019-10-24  8:17 ` " David Gibson
  2019-10-24  8:17 ` [PULL 03/28] target/ppc: Fix for optimized vsl/vsr instructions David Gibson
                   ` (26 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Greg Kurz <groug@kaod.org>

Some device types of the XICS model are exposed to the QEMU command
line:

$ ppc64-softmmu/qemu-system-ppc64 -device help | grep ic[sp]
name "icp"
name "ics"
name "ics-spapr"
name "pnv-icp", desc "PowerNV ICP"

These are internal devices that shouldn't be instantiable by the
user. By the way, they can't be because their respective realize
functions expect link properties that can't be set from the command
line:

qemu-system-ppc64: -device icp: required link 'xics' not found:
 Property '.xics' not found
qemu-system-ppc64: -device ics: required link 'xics' not found:
 Property '.xics' not found
qemu-system-ppc64: -device ics-spapr: required link 'xics' not found:
 Property '.xics' not found
qemu-system-ppc64: -device pnv-icp: required link 'xics' not found:
 Property '.xics' not found

Hide them by setting dc->user_creatable to false in the base class
"icp" and "ics" init functions.

Signed-off-by: Greg Kurz <groug@kaod.org>
Message-Id: <157017826724.337875.14822177178282524024.stgit@bahia.lan>
Message-Id: <157045578962.865784.8551555523533955113.stgit@bahia.lan>
[dwg: Folded reason comment into base patch]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/intc/xics.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/hw/intc/xics.c b/hw/intc/xics.c
index dfe7dbd254..b5ac408f7b 100644
--- a/hw/intc/xics.c
+++ b/hw/intc/xics.c
@@ -369,6 +369,11 @@ static void icp_class_init(ObjectClass *klass, void *data)
 
     dc->realize = icp_realize;
     dc->unrealize = icp_unrealize;
+    /*
+     * Reason: part of XICS interrupt controller, needs to be wired up
+     * by icp_create().
+     */
+    dc->user_creatable = false;
 }
 
 static const TypeInfo icp_info = {
@@ -689,6 +694,11 @@ static void ics_class_init(ObjectClass *klass, void *data)
     dc->props = ics_properties;
     dc->reset = ics_reset;
     dc->vmsd = &vmstate_ics;
+    /*
+     * Reason: part of XICS interrupt controller, needs to be wired up,
+     * e.g. by spapr_irq_init().
+     */
+    dc->user_creatable = false;
 }
 
 static const TypeInfo ics_info = {
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 03/28] target/ppc: Fix for optimized vsl/vsr instructions
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
  2019-10-24  8:17 ` [PULL 01/28] xive: Make some device types not user creatable David Gibson
  2019-10-24  8:17 ` [PULL 02/28] xics: " David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 04/28] ppc/pnv: Improve trigger data definition David Gibson
                   ` (25 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, Mark Cave-Ayland, qemu-devel, groug,
	Aleksandar Markovic, qemu-ppc, clg, Stefan Brankovic,
	David Gibson, Paul A. Clark

From: Stefan Brankovic <stefan.brankovic@rt-rk.com>

In previous implementation, invocation of TCG shift function could request
shift of TCG variable by 64 bits when variable 'sh' is 0, which is not
supported in TCG (values can be shifted by 0 to 63 bits). This patch fixes
this by using two separate invocation of TCG shift functions, with maximum
shift amount of 32.

Name of variable 'shifted' is changed to 'carry' so variable naming
is similar to old helper implementation.

Variables 'avrA' and 'avrB' are replaced with variable 'avr'.

Fixes: 4e6d0920e7547e6af4bbac5ffe9adfe6ea621822
Reported-by: "Paul A. Clark" <pc@us.ibm.com>
Reported-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Suggested-by: Aleksandar Markovic <aleksandar.markovic@rt-rk.com>
Signed-off-by: Stefan Brankovic <stefan.brankovic@rt-rk.com>
Message-Id: <1570196639-7025-2-git-send-email-stefan.brankovic@rt-rk.com>
Tested-by: Paul A. Clarke  <pc@us.ibm.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 target/ppc/translate/vmx-impl.inc.c | 84 ++++++++++++++---------------
 1 file changed, 40 insertions(+), 44 deletions(-)

diff --git a/target/ppc/translate/vmx-impl.inc.c b/target/ppc/translate/vmx-impl.inc.c
index 2472a5217a..81d5a7a341 100644
--- a/target/ppc/translate/vmx-impl.inc.c
+++ b/target/ppc/translate/vmx-impl.inc.c
@@ -590,40 +590,38 @@ static void trans_vsl(DisasContext *ctx)
     int VT = rD(ctx->opcode);
     int VA = rA(ctx->opcode);
     int VB = rB(ctx->opcode);
-    TCGv_i64 avrA = tcg_temp_new_i64();
-    TCGv_i64 avrB = tcg_temp_new_i64();
+    TCGv_i64 avr = tcg_temp_new_i64();
     TCGv_i64 sh = tcg_temp_new_i64();
-    TCGv_i64 shifted = tcg_temp_new_i64();
+    TCGv_i64 carry = tcg_temp_new_i64();
     TCGv_i64 tmp = tcg_temp_new_i64();
 
-    /* Place bits 125-127 of vB in sh. */
-    get_avr64(avrB, VB, false);
-    tcg_gen_andi_i64(sh, avrB, 0x07ULL);
+    /* Place bits 125-127 of vB in 'sh'. */
+    get_avr64(avr, VB, false);
+    tcg_gen_andi_i64(sh, avr, 0x07ULL);
 
     /*
-     * Save highest sh bits of lower doubleword element of vA in variable
-     * shifted and perform shift on lower doubleword.
+     * Save highest 'sh' bits of lower doubleword element of vA in variable
+     * 'carry' and perform shift on lower doubleword.
      */
-    get_avr64(avrA, VA, false);
-    tcg_gen_subfi_i64(tmp, 64, sh);
-    tcg_gen_shr_i64(shifted, avrA, tmp);
-    tcg_gen_andi_i64(shifted, shifted, 0x7fULL);
-    tcg_gen_shl_i64(avrA, avrA, sh);
-    set_avr64(VT, avrA, false);
+    get_avr64(avr, VA, false);
+    tcg_gen_subfi_i64(tmp, 32, sh);
+    tcg_gen_shri_i64(carry, avr, 32);
+    tcg_gen_shr_i64(carry, carry, tmp);
+    tcg_gen_shl_i64(avr, avr, sh);
+    set_avr64(VT, avr, false);
 
     /*
      * Perform shift on higher doubleword element of vA and replace lowest
-     * sh bits with shifted.
+     * 'sh' bits with 'carry'.
      */
-    get_avr64(avrA, VA, true);
-    tcg_gen_shl_i64(avrA, avrA, sh);
-    tcg_gen_or_i64(avrA, avrA, shifted);
-    set_avr64(VT, avrA, true);
+    get_avr64(avr, VA, true);
+    tcg_gen_shl_i64(avr, avr, sh);
+    tcg_gen_or_i64(avr, avr, carry);
+    set_avr64(VT, avr, true);
 
-    tcg_temp_free_i64(avrA);
-    tcg_temp_free_i64(avrB);
+    tcg_temp_free_i64(avr);
     tcg_temp_free_i64(sh);
-    tcg_temp_free_i64(shifted);
+    tcg_temp_free_i64(carry);
     tcg_temp_free_i64(tmp);
 }
 
@@ -639,39 +637,37 @@ static void trans_vsr(DisasContext *ctx)
     int VT = rD(ctx->opcode);
     int VA = rA(ctx->opcode);
     int VB = rB(ctx->opcode);
-    TCGv_i64 avrA = tcg_temp_new_i64();
-    TCGv_i64 avrB = tcg_temp_new_i64();
+    TCGv_i64 avr = tcg_temp_new_i64();
     TCGv_i64 sh = tcg_temp_new_i64();
-    TCGv_i64 shifted = tcg_temp_new_i64();
+    TCGv_i64 carry = tcg_temp_new_i64();
     TCGv_i64 tmp = tcg_temp_new_i64();
 
-    /* Place bits 125-127 of vB in sh. */
-    get_avr64(avrB, VB, false);
-    tcg_gen_andi_i64(sh, avrB, 0x07ULL);
+    /* Place bits 125-127 of vB in 'sh'. */
+    get_avr64(avr, VB, false);
+    tcg_gen_andi_i64(sh, avr, 0x07ULL);
 
     /*
-     * Save lowest sh bits of higher doubleword element of vA in variable
-     * shifted and perform shift on higher doubleword.
+     * Save lowest 'sh' bits of higher doubleword element of vA in variable
+     * 'carry' and perform shift on higher doubleword.
      */
-    get_avr64(avrA, VA, true);
-    tcg_gen_subfi_i64(tmp, 64, sh);
-    tcg_gen_shl_i64(shifted, avrA, tmp);
-    tcg_gen_andi_i64(shifted, shifted, 0xfe00000000000000ULL);
-    tcg_gen_shr_i64(avrA, avrA, sh);
-    set_avr64(VT, avrA, true);
+    get_avr64(avr, VA, true);
+    tcg_gen_subfi_i64(tmp, 32, sh);
+    tcg_gen_shli_i64(carry, avr, 32);
+    tcg_gen_shl_i64(carry, carry, tmp);
+    tcg_gen_shr_i64(avr, avr, sh);
+    set_avr64(VT, avr, true);
     /*
      * Perform shift on lower doubleword element of vA and replace highest
-     * sh bits with shifted.
+     * 'sh' bits with 'carry'.
      */
-    get_avr64(avrA, VA, false);
-    tcg_gen_shr_i64(avrA, avrA, sh);
-    tcg_gen_or_i64(avrA, avrA, shifted);
-    set_avr64(VT, avrA, false);
+    get_avr64(avr, VA, false);
+    tcg_gen_shr_i64(avr, avr, sh);
+    tcg_gen_or_i64(avr, avr, carry);
+    set_avr64(VT, avr, false);
 
-    tcg_temp_free_i64(avrA);
-    tcg_temp_free_i64(avrB);
+    tcg_temp_free_i64(avr);
     tcg_temp_free_i64(sh);
-    tcg_temp_free_i64(shifted);
+    tcg_temp_free_i64(carry);
     tcg_temp_free_i64(tmp);
 }
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 04/28] ppc/pnv: Improve trigger data definition
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (2 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 03/28] target/ppc: Fix for optimized vsl/vsr instructions David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 05/28] ppc/pnv: Use address_space_stq_be() when triggering an interrupt from PSI David Gibson
                   ` (24 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Cédric Le Goater <clg@kaod.org>

The trigger data is used for both triggers of a HW source interrupts,
PHB, PSI, and triggers for rerouting interrupts between interrupt
controllers.

When an interrupt is rerouted, the trigger data follows an "END
trigger" format. In that case, the remote IC needs EAS containing an
END index to perform a lookup of an END.

An END trigger, bit0 of word0 set to '1', is defined as :

             |0123|4567|0123|4567|0123|4567|0123|4567|
    W0 E=1   |1P--|BLOC|          END IDX            |
    W1 E=1   |M   |           END DATA               |

An EAS is defined as :

             |0123|4567|0123|4567|0123|4567|0123|4567|
    W0       |V---|BLOC|          END IDX            |
    W1       |M   |          END DATA                |

The END trigger adds an extra 'PQ' bit, bit1 of word0 set to '1',
signaling that the PQ bits have been checked. That bit is unused in
the initial EAS definition.

When a HW device performs the trigger, the trigger data follows an
"EAS trigger" format because the trigger data in that case contains an
EAS index which the IC needs to look for.

An EAS trigger, bit0 of word0 set to '0', is defined as :

             |0123|4567|0123|4567|0123|4567|0123|4567|
    W0 E=0   |0P--|---- ---- ---- ---- ---- ---- ----|
    W1 E=0   |BLOC|            EAS INDEX             |

There is also a 'PQ' bit, bit1 of word0 to '1', signaling that the
PQ bits have been checked.

Introduce these new trigger bits and rename the XIVE_SRCNO macros in
XIVE_EAS to reflect better the nature of the data.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Message-Id: <20191007084102.29776-2-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/intc/pnv_xive.c         | 20 ++++++++++++++++----
 hw/intc/xive.c             |  4 ++--
 include/hw/ppc/xive_regs.h | 26 +++++++++++++++++++++++---
 3 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/hw/intc/pnv_xive.c b/hw/intc/pnv_xive.c
index ed6e9d71bb..348f2fdd26 100644
--- a/hw/intc/pnv_xive.c
+++ b/hw/intc/pnv_xive.c
@@ -385,7 +385,7 @@ static int pnv_xive_get_eas(XiveRouter *xrtr, uint8_t blk, uint32_t idx,
     PnvXive *xive = PNV_XIVE(xrtr);
 
     if (pnv_xive_get_ic(blk) != xive) {
-        xive_error(xive, "VST: EAS %x is remote !?", XIVE_SRCNO(blk, idx));
+        xive_error(xive, "VST: EAS %x is remote !?", XIVE_EAS(blk, idx));
         return -1;
     }
 
@@ -431,7 +431,7 @@ static void pnv_xive_notify(XiveNotifier *xn, uint32_t srcno)
     PnvXive *xive = PNV_XIVE(xn);
     uint8_t blk = xive->chip->chip_id;
 
-    xive_router_notify(xn, XIVE_SRCNO(blk, srcno));
+    xive_router_notify(xn, XIVE_EAS(blk, srcno));
 }
 
 /*
@@ -1225,12 +1225,24 @@ static const MemoryRegionOps pnv_xive_ic_reg_ops = {
 
 static void pnv_xive_ic_hw_trigger(PnvXive *xive, hwaddr addr, uint64_t val)
 {
+    uint8_t blk;
+    uint32_t idx;
+
+    if (val & XIVE_TRIGGER_END) {
+        xive_error(xive, "IC: END trigger at @0x%"HWADDR_PRIx" data 0x%"PRIx64,
+                   addr, val);
+        return;
+    }
+
     /*
      * Forward the source event notification directly to the Router.
      * The source interrupt number should already be correctly encoded
      * with the chip block id by the sending device (PHB, PSI).
      */
-    xive_router_notify(XIVE_NOTIFIER(xive), val);
+    blk = XIVE_EAS_BLOCK(val);
+    idx = XIVE_EAS_INDEX(val);
+
+    xive_router_notify(XIVE_NOTIFIER(xive), XIVE_EAS(blk, idx));
 }
 
 static void pnv_xive_ic_notify_write(void *opaque, hwaddr addr, uint64_t val,
@@ -1566,7 +1578,7 @@ void pnv_xive_pic_print_info(PnvXive *xive, Monitor *mon)
 {
     XiveRouter *xrtr = XIVE_ROUTER(xive);
     uint8_t blk = xive->chip->chip_id;
-    uint32_t srcno0 = XIVE_SRCNO(blk, 0);
+    uint32_t srcno0 = XIVE_EAS(blk, 0);
     uint32_t nr_ipis = pnv_xive_nr_ipis(xive);
     uint32_t nr_ends = pnv_xive_nr_ends(xive);
     XiveEAS eas;
diff --git a/hw/intc/xive.c b/hw/intc/xive.c
index 453d389848..d420c6571e 100644
--- a/hw/intc/xive.c
+++ b/hw/intc/xive.c
@@ -1658,8 +1658,8 @@ do_escalation:
 void xive_router_notify(XiveNotifier *xn, uint32_t lisn)
 {
     XiveRouter *xrtr = XIVE_ROUTER(xn);
-    uint8_t eas_blk = XIVE_SRCNO_BLOCK(lisn);
-    uint32_t eas_idx = XIVE_SRCNO_INDEX(lisn);
+    uint8_t eas_blk = XIVE_EAS_BLOCK(lisn);
+    uint32_t eas_idx = XIVE_EAS_INDEX(lisn);
     XiveEAS eas;
 
     /* EAS cache lookup */
diff --git a/include/hw/ppc/xive_regs.h b/include/hw/ppc/xive_regs.h
index 08c8bf7172..55307cd153 100644
--- a/include/hw/ppc/xive_regs.h
+++ b/include/hw/ppc/xive_regs.h
@@ -22,9 +22,29 @@
 /*
  * Interrupt source number encoding on PowerBUS
  */
-#define XIVE_SRCNO_BLOCK(srcno) (((srcno) >> 28) & 0xf)
-#define XIVE_SRCNO_INDEX(srcno) ((srcno) & 0x0fffffff)
-#define XIVE_SRCNO(blk, idx)    ((uint32_t)(blk) << 28 | (idx))
+/*
+ * Trigger data definition
+ *
+ * The trigger definition is used for triggers both for HW source
+ * interrupts (PHB, PSI), as well as for rerouting interrupts between
+ * Interrupt Controller.
+ *
+ * HW source controllers set bit0 of word0 to ‘0’ as they provide EAS
+ * information (EAS block + EAS index) in the 8 byte data and not END
+ * information, which is use for rerouting interrupts.
+ *
+ * bit1 of word0 to ‘1’ signals that the state bit check has been
+ * performed.
+ */
+#define XIVE_TRIGGER_END        PPC_BIT(0)
+#define XIVE_TRIGGER_PQ         PPC_BIT(1)
+
+/*
+ * QEMU macros to manipulate the trigger payload in native endian
+ */
+#define XIVE_EAS_BLOCK(n)       (((n) >> 28) & 0xf)
+#define XIVE_EAS_INDEX(n)       ((n) & 0x0fffffff)
+#define XIVE_EAS(blk, idx)      ((uint32_t)(blk) << 28 | (idx))
 
 #define TM_SHIFT                16
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 05/28] ppc/pnv: Use address_space_stq_be() when triggering an interrupt from PSI
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (3 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 04/28] ppc/pnv: Improve trigger data definition David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 06/28] spapr: Set VSMT to smp_threads by default David Gibson
                   ` (23 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Cédric Le Goater <clg@kaod.org>

Include the XIVE_TRIGGER_PQ bit in the trigger data which is how
hardware signals to the IC that the PQ bits of the interrupt source
have been checked.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Message-Id: <20191007084102.29776-3-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/pnv_psi.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/hw/ppc/pnv_psi.c b/hw/ppc/pnv_psi.c
index a997f16bb4..68d0dfacfe 100644
--- a/hw/ppc/pnv_psi.c
+++ b/hw/ppc/pnv_psi.c
@@ -660,10 +660,19 @@ static void pnv_psi_notify(XiveNotifier *xf, uint32_t srcno)
 
     uint32_t offset =
         (psi->regs[PSIHB_REG(PSIHB9_IVT_OFFSET)] >> PSIHB9_IVT_OFF_SHIFT);
-    uint64_t lisn = cpu_to_be64(offset + srcno);
+    uint64_t data = XIVE_TRIGGER_PQ | offset | srcno;
+    MemTxResult result;
 
-    if (valid) {
-        cpu_physical_memory_write(notify_addr, &lisn, sizeof(lisn));
+    if (!valid) {
+        return;
+    }
+
+    address_space_stq_be(&address_space_memory, notify_addr, data,
+                         MEMTXATTRS_UNSPECIFIED, &result);
+    if (result != MEMTX_OK) {
+        qemu_log_mask(LOG_GUEST_ERROR, "%s: trigger failed @%"
+                      HWADDR_PRIx "\n", __func__, notif_port);
+        return;
     }
 }
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 06/28] spapr: Set VSMT to smp_threads by default
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (4 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 05/28] ppc/pnv: Use address_space_stq_be() when triggering an interrupt from PSI David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-11-08 13:11   ` Laurent Vivier
  2019-10-24  8:17 ` [PULL 07/28] spapr, xics, xive: Introduce SpaprInterruptController QOM interface David Gibson
                   ` (22 subsequent siblings)
  28 siblings, 1 reply; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Greg Kurz <groug@kaod.org>

Support for setting VSMT is available in KVM since linux-4.13. Most distros
that support KVM on POWER already have it. It thus seem reasonable enough
to have the default machine to set VSMT to smp_threads.

This brings contiguous VCPU ids and thus brings their upper bound down to
the machine's max_cpus. This is especially useful for XIVE KVM devices,
which may thus allocate only one VP descriptor per VCPU.

Signed-off-by: Greg Kurz <groug@kaod.org>
Message-Id: <157010411885.246126.12610015369068227139.stgit@bahia.lan>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/spapr.c         | 7 ++++++-
 include/hw/ppc/spapr.h | 1 +
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 4eb97d3a9b..428b834f30 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -2496,6 +2496,7 @@ static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
 static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *ms = MACHINE(spapr);
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
     Error *local_err = NULL;
     bool vsmt_user = !!spapr->vsmt;
     int kvm_smt = kvmppc_smt_threads();
@@ -2522,7 +2523,7 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
             goto out;
         }
         /* In this case, spapr->vsmt has been set by the command line */
-    } else {
+    } else if (!smc->smp_threads_vsmt) {
         /*
          * Default VSMT value is tricky, because we need it to be as
          * consistent as possible (for migration), but this requires
@@ -2531,6 +2532,8 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
          * overwhelmingly common case in production systems.
          */
         spapr->vsmt = MAX(8, smp_threads);
+    } else {
+        spapr->vsmt = smp_threads;
     }
 
     /* KVM: If necessary, set the SMT mode: */
@@ -4438,6 +4441,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
     smc->irq = &spapr_irq_dual;
     smc->dr_phb_enabled = true;
     smc->linux_pci_probe = true;
+    smc->smp_threads_vsmt = true;
 }
 
 static const TypeInfo spapr_machine_info = {
@@ -4505,6 +4509,7 @@ static void spapr_machine_4_1_class_options(MachineClass *mc)
 
     spapr_machine_4_2_class_options(mc);
     smc->linux_pci_probe = false;
+    smc->smp_threads_vsmt = false;
     compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
 }
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index cbd1a4c9f3..2009eb64f9 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -122,6 +122,7 @@ struct SpaprMachineClass {
     bool broken_host_serial_model; /* present real host info to the guest */
     bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
     bool linux_pci_probe;
+    bool smp_threads_vsmt; /* set VSMT to smp_threads by default */
 
     void (*phb_placement)(SpaprMachineState *spapr, uint32_t index,
                           uint64_t *buid, hwaddr *pio, 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 07/28] spapr, xics, xive: Introduce SpaprInterruptController QOM interface
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (5 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 06/28] spapr: Set VSMT to smp_threads by default David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 08/28] spapr, xics, xive: Move cpu_intc_create from SpaprIrq to SpaprInterruptController David Gibson
                   ` (21 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

The SpaprIrq structure is used to represent ths spapr machine's irq
backend.  Except that it kind of conflates two concepts: one is the
backend proper - a specific interrupt controller that we might or
might not be using, the other is the irq configuration which covers
the layout of irq space and which interrupt controllers are allowed.

This leads to some pretty confusing code paths for the "dual"
configuration where its hooks redirect to other SpaprIrq structures
depending on the currently active irq controller.

To clean this up, we start by introducing a new
SpaprInterruptController QOM interface to represent strictly an
interrupt controller backend, not counting anything configuration
related.  We implement this interface in the XICs and XIVE interrupt
controllers, and in future we'll move relevant methods from SpaprIrq
into it.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c       |  4 ++++
 hw/intc/xics_spapr.c       |  4 ++++
 hw/ppc/spapr_irq.c         | 13 +++++++++++++
 include/hw/ppc/spapr_irq.h | 14 ++++++++++++++
 4 files changed, 35 insertions(+)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 04879abf2e..b67e9c3245 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -519,6 +519,10 @@ static const TypeInfo spapr_xive_info = {
     .instance_init = spapr_xive_instance_init,
     .instance_size = sizeof(SpaprXive),
     .class_init = spapr_xive_class_init,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_SPAPR_INTC },
+        { }
+    },
 };
 
 static void spapr_xive_register_types(void)
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 6e5eb24b3c..4874e6be55 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -343,6 +343,10 @@ static const TypeInfo ics_spapr_info = {
     .name = TYPE_ICS_SPAPR,
     .parent = TYPE_ICS,
     .class_init = ics_spapr_class_init,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_SPAPR_INTC },
+        { }
+    },
 };
 
 static void xics_spapr_register_types(void)
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 457eabe24c..8791dec1ba 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -23,6 +23,12 @@
 
 #include "trace.h"
 
+static const TypeInfo spapr_intc_info = {
+    .name = TYPE_SPAPR_INTC,
+    .parent = TYPE_INTERFACE,
+    .class_size = sizeof(SpaprInterruptControllerClass),
+};
+
 void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis)
 {
     spapr->irq_map_nr = nr_msis;
@@ -762,3 +768,10 @@ SpaprIrq spapr_irq_xics_legacy = {
     .set_irq     = spapr_irq_set_irq_xics,
     .init_kvm    = spapr_irq_init_kvm_xics,
 };
+
+static void spapr_irq_register_types(void)
+{
+    type_register_static(&spapr_intc_info);
+}
+
+type_init(spapr_irq_register_types)
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 69a37f608e..b9398e0be3 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -31,6 +31,20 @@
 
 typedef struct SpaprMachineState SpaprMachineState;
 
+typedef struct SpaprInterruptController SpaprInterruptController;
+
+#define TYPE_SPAPR_INTC "spapr-interrupt-controller"
+#define SPAPR_INTC(obj)                                     \
+    INTERFACE_CHECK(SpaprInterruptController, (obj), TYPE_SPAPR_INTC)
+#define SPAPR_INTC_CLASS(klass)                                     \
+    OBJECT_CLASS_CHECK(SpaprInterruptControllerClass, (klass), TYPE_SPAPR_INTC)
+#define SPAPR_INTC_GET_CLASS(obj)                                   \
+    OBJECT_GET_CLASS(SpaprInterruptControllerClass, (obj), TYPE_SPAPR_INTC)
+
+typedef struct SpaprInterruptControllerClass {
+    InterfaceClass parent;
+} SpaprInterruptControllerClass;
+
 void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis);
 int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
                         Error **errp);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 08/28] spapr, xics, xive: Move cpu_intc_create from SpaprIrq to SpaprInterruptController
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (6 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 07/28] spapr, xics, xive: Introduce SpaprInterruptController QOM interface David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 09/28] spapr, xics, xive: Move irq claim and free " David Gibson
                   ` (20 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

This method essentially represents code which belongs to the interrupt
controller, but needs to be called on all possible intcs, rather than
just the currently active one.  The "dual" version therefore calls
into the xics and xive versions confusingly.

Handle this more directly, by making it instead a method on the intc
backend, and always calling it on every backend that exists.

While we're there, streamline the error reporting a bit.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c       | 25 ++++++++++++
 hw/intc/xics_spapr.c       | 18 +++++++++
 hw/ppc/spapr_cpu_core.c    |  3 +-
 hw/ppc/spapr_irq.c         | 81 +++++++++++---------------------------
 include/hw/ppc/spapr_irq.h | 13 +++++-
 5 files changed, 79 insertions(+), 61 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index b67e9c3245..9338daba3d 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -495,10 +495,33 @@ static Property spapr_xive_properties[] = {
     DEFINE_PROP_END_OF_LIST(),
 };
 
+static int spapr_xive_cpu_intc_create(SpaprInterruptController *intc,
+                                      PowerPCCPU *cpu, Error **errp)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    Object *obj;
+    SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+
+    obj = xive_tctx_create(OBJECT(cpu), XIVE_ROUTER(xive), errp);
+    if (!obj) {
+        return -1;
+    }
+
+    spapr_cpu->tctx = XIVE_TCTX(obj);
+
+    /*
+     * (TCG) Early setting the OS CAM line for hotplugged CPUs as they
+     * don't beneficiate from the reset of the XIVE IRQ backend
+     */
+    spapr_xive_set_tctx_os_cam(spapr_cpu->tctx);
+    return 0;
+}
+
 static void spapr_xive_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
     XiveRouterClass *xrc = XIVE_ROUTER_CLASS(klass);
+    SpaprInterruptControllerClass *sicc = SPAPR_INTC_CLASS(klass);
 
     dc->desc    = "sPAPR XIVE Interrupt Controller";
     dc->props   = spapr_xive_properties;
@@ -511,6 +534,8 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     xrc->get_nvt = spapr_xive_get_nvt;
     xrc->write_nvt = spapr_xive_write_nvt;
     xrc->get_tctx = spapr_xive_get_tctx;
+
+    sicc->cpu_intc_create = spapr_xive_cpu_intc_create;
 }
 
 static const TypeInfo spapr_xive_info = {
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 4874e6be55..946311b858 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -330,13 +330,31 @@ void spapr_dt_xics(SpaprMachineState *spapr, uint32_t nr_servers, void *fdt,
     _FDT(fdt_setprop_cell(fdt, node, "phandle", phandle));
 }
 
+static int xics_spapr_cpu_intc_create(SpaprInterruptController *intc,
+                                       PowerPCCPU *cpu, Error **errp)
+{
+    ICSState *ics = ICS_SPAPR(intc);
+    Object *obj;
+    SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
+
+    obj = icp_create(OBJECT(cpu), TYPE_ICP, ics->xics, errp);
+    if (!obj) {
+        return -1;
+    }
+
+    spapr_cpu->icp = ICP(obj);
+    return 0;
+}
+
 static void ics_spapr_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
     ICSStateClass *isc = ICS_CLASS(klass);
+    SpaprInterruptControllerClass *sicc = SPAPR_INTC_CLASS(klass);
 
     device_class_set_parent_realize(dc, ics_spapr_realize,
                                     &isc->parent_realize);
+    sicc->cpu_intc_create = xics_spapr_cpu_intc_create;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr_cpu_core.c b/hw/ppc/spapr_cpu_core.c
index 1d93de8161..3e4302c7d5 100644
--- a/hw/ppc/spapr_cpu_core.c
+++ b/hw/ppc/spapr_cpu_core.c
@@ -237,8 +237,7 @@ static void spapr_realize_vcpu(PowerPCCPU *cpu, SpaprMachineState *spapr,
     qemu_register_reset(spapr_cpu_reset, cpu);
     spapr_cpu_reset(cpu);
 
-    spapr->irq->cpu_intc_create(spapr, cpu, &local_err);
-    if (local_err) {
+    if (spapr_irq_cpu_intc_create(spapr, cpu, &local_err) < 0) {
         goto error_unregister;
     }
 
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 8791dec1ba..9cb2fc71ca 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -138,23 +138,6 @@ static void spapr_irq_print_info_xics(SpaprMachineState *spapr, Monitor *mon)
     ics_pic_print_info(spapr->ics, mon);
 }
 
-static void spapr_irq_cpu_intc_create_xics(SpaprMachineState *spapr,
-                                           PowerPCCPU *cpu, Error **errp)
-{
-    Error *local_err = NULL;
-    Object *obj;
-    SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
-
-    obj = icp_create(OBJECT(cpu), TYPE_ICP, XICS_FABRIC(spapr),
-                     &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return;
-    }
-
-    spapr_cpu->icp = ICP(obj);
-}
-
 static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
 {
     if (!kvm_irqchip_in_kernel()) {
@@ -203,7 +186,6 @@ SpaprIrq spapr_irq_xics = {
     .free        = spapr_irq_free_xics,
     .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
-    .cpu_intc_create = spapr_irq_cpu_intc_create_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
     .set_irq     = spapr_irq_set_irq_xics,
@@ -239,28 +221,6 @@ static void spapr_irq_print_info_xive(SpaprMachineState *spapr,
     spapr_xive_pic_print_info(spapr->xive, mon);
 }
 
-static void spapr_irq_cpu_intc_create_xive(SpaprMachineState *spapr,
-                                           PowerPCCPU *cpu, Error **errp)
-{
-    Error *local_err = NULL;
-    Object *obj;
-    SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
-
-    obj = xive_tctx_create(OBJECT(cpu), XIVE_ROUTER(spapr->xive), &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return;
-    }
-
-    spapr_cpu->tctx = XIVE_TCTX(obj);
-
-    /*
-     * (TCG) Early setting the OS CAM line for hotplugged CPUs as they
-     * don't beneficiate from the reset of the XIVE IRQ backend
-     */
-    spapr_xive_set_tctx_os_cam(spapr_cpu->tctx);
-}
-
 static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
 {
     return spapr_xive_post_load(spapr->xive, version_id);
@@ -316,7 +276,6 @@ SpaprIrq spapr_irq_xive = {
     .free        = spapr_irq_free_xive,
     .print_info  = spapr_irq_print_info_xive,
     .dt_populate = spapr_dt_xive,
-    .cpu_intc_create = spapr_irq_cpu_intc_create_xive,
     .post_load   = spapr_irq_post_load_xive,
     .reset       = spapr_irq_reset_xive,
     .set_irq     = spapr_irq_set_irq_xive,
@@ -381,20 +340,6 @@ static void spapr_irq_dt_populate_dual(SpaprMachineState *spapr,
     spapr_irq_current(spapr)->dt_populate(spapr, nr_servers, fdt, phandle);
 }
 
-static void spapr_irq_cpu_intc_create_dual(SpaprMachineState *spapr,
-                                           PowerPCCPU *cpu, Error **errp)
-{
-    Error *local_err = NULL;
-
-    spapr_irq_xive.cpu_intc_create(spapr, cpu, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return;
-    }
-
-    spapr_irq_xics.cpu_intc_create(spapr, cpu, errp);
-}
-
 static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
 {
     /*
@@ -460,7 +405,6 @@ SpaprIrq spapr_irq_dual = {
     .free        = spapr_irq_free_dual,
     .print_info  = spapr_irq_print_info_dual,
     .dt_populate = spapr_irq_dt_populate_dual,
-    .cpu_intc_create = spapr_irq_cpu_intc_create_dual,
     .post_load   = spapr_irq_post_load_dual,
     .reset       = spapr_irq_reset_dual,
     .set_irq     = spapr_irq_set_irq_dual,
@@ -527,6 +471,30 @@ static int spapr_irq_check(SpaprMachineState *spapr, Error **errp)
 /*
  * sPAPR IRQ frontend routines for devices
  */
+#define ALL_INTCS(spapr_) \
+    { SPAPR_INTC((spapr_)->ics), SPAPR_INTC((spapr_)->xive), }
+
+int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
+                              PowerPCCPU *cpu, Error **errp)
+{
+    SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
+    int i;
+    int rc;
+
+    for (i = 0; i < ARRAY_SIZE(intcs); i++) {
+        SpaprInterruptController *intc = intcs[i];
+        if (intc) {
+            SpaprInterruptControllerClass *sicc = SPAPR_INTC_GET_CLASS(intc);
+            rc = sicc->cpu_intc_create(intc, cpu, errp);
+            if (rc < 0) {
+                return rc;
+            }
+        }
+    }
+
+    return 0;
+}
+
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
@@ -762,7 +730,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .free        = spapr_irq_free_xics,
     .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
-    .cpu_intc_create = spapr_irq_cpu_intc_create_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
     .set_irq     = spapr_irq_set_irq_xics,
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index b9398e0be3..5e641e23c1 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -43,8 +43,19 @@ typedef struct SpaprInterruptController SpaprInterruptController;
 
 typedef struct SpaprInterruptControllerClass {
     InterfaceClass parent;
+
+    /*
+     * These methods will typically be called on all intcs, active and
+     * inactive
+     */
+    int (*cpu_intc_create)(SpaprInterruptController *intc,
+                            PowerPCCPU *cpu, Error **errp);
 } SpaprInterruptControllerClass;
 
+int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
+                              PowerPCCPU *cpu, Error **errp);
+
+
 void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis);
 int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
                         Error **errp);
@@ -61,8 +72,6 @@ typedef struct SpaprIrq {
     void (*print_info)(SpaprMachineState *spapr, Monitor *mon);
     void (*dt_populate)(SpaprMachineState *spapr, uint32_t nr_servers,
                         void *fdt, uint32_t phandle);
-    void (*cpu_intc_create)(SpaprMachineState *spapr, PowerPCCPU *cpu,
-                            Error **errp);
     int (*post_load)(SpaprMachineState *spapr, int version_id);
     void (*reset)(SpaprMachineState *spapr, Error **errp);
     void (*set_irq)(void *opaque, int srcno, int val);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 09/28] spapr, xics, xive: Move irq claim and free from SpaprIrq to SpaprInterruptController
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (7 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 08/28] spapr, xics, xive: Move cpu_intc_create from SpaprIrq to SpaprInterruptController David Gibson
@ 2019-10-24  8:17 ` " David Gibson
  2019-10-24  8:17 ` [PULL 10/28] spapr: Formalize notion of active interrupt controller David Gibson
                   ` (19 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

These methods, like cpu_intc_create, really belong to the interrupt
controller, but need to be called on all possible intcs.

Like cpu_intc_create, therefore, make them methods on the intc and
always call it for all existing intcs.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c        |  71 ++++++++++++-----------
 hw/intc/xics_spapr.c        |  29 ++++++++++
 hw/ppc/spapr_irq.c          | 110 +++++++++++-------------------------
 include/hw/ppc/spapr_irq.h  |   5 +-
 include/hw/ppc/spapr_xive.h |   2 -
 5 files changed, 102 insertions(+), 115 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 9338daba3d..ff1a175b44 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -487,6 +487,42 @@ static const VMStateDescription vmstate_spapr_xive = {
     },
 };
 
+static int spapr_xive_claim_irq(SpaprInterruptController *intc, int lisn,
+                                bool lsi, Error **errp)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    XiveSource *xsrc = &xive->source;
+
+    assert(lisn < xive->nr_irqs);
+
+    if (xive_eas_is_valid(&xive->eat[lisn])) {
+        error_setg(errp, "IRQ %d is not free", lisn);
+        return -EBUSY;
+    }
+
+    /*
+     * Set default values when allocating an IRQ number
+     */
+    xive->eat[lisn].w |= cpu_to_be64(EAS_VALID | EAS_MASKED);
+    if (lsi) {
+        xive_source_irq_set_lsi(xsrc, lisn);
+    }
+
+    if (kvm_irqchip_in_kernel()) {
+        return kvmppc_xive_source_reset_one(xsrc, lisn, errp);
+    }
+
+    return 0;
+}
+
+static void spapr_xive_free_irq(SpaprInterruptController *intc, int lisn)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    assert(lisn < xive->nr_irqs);
+
+    xive->eat[lisn].w &= cpu_to_be64(~EAS_VALID);
+}
+
 static Property spapr_xive_properties[] = {
     DEFINE_PROP_UINT32("nr-irqs", SpaprXive, nr_irqs, 0),
     DEFINE_PROP_UINT32("nr-ends", SpaprXive, nr_ends, 0),
@@ -536,6 +572,8 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     xrc->get_tctx = spapr_xive_get_tctx;
 
     sicc->cpu_intc_create = spapr_xive_cpu_intc_create;
+    sicc->claim_irq = spapr_xive_claim_irq;
+    sicc->free_irq = spapr_xive_free_irq;
 }
 
 static const TypeInfo spapr_xive_info = {
@@ -557,39 +595,6 @@ static void spapr_xive_register_types(void)
 
 type_init(spapr_xive_register_types)
 
-int spapr_xive_irq_claim(SpaprXive *xive, int lisn, bool lsi, Error **errp)
-{
-    XiveSource *xsrc = &xive->source;
-
-    assert(lisn < xive->nr_irqs);
-
-    if (xive_eas_is_valid(&xive->eat[lisn])) {
-        error_setg(errp, "IRQ %d is not free", lisn);
-        return -EBUSY;
-    }
-
-    /*
-     * Set default values when allocating an IRQ number
-     */
-    xive->eat[lisn].w |= cpu_to_be64(EAS_VALID | EAS_MASKED);
-    if (lsi) {
-        xive_source_irq_set_lsi(xsrc, lisn);
-    }
-
-    if (kvm_irqchip_in_kernel()) {
-        return kvmppc_xive_source_reset_one(xsrc, lisn, errp);
-    }
-
-    return 0;
-}
-
-void spapr_xive_irq_free(SpaprXive *xive, int lisn)
-{
-    assert(lisn < xive->nr_irqs);
-
-    xive->eat[lisn].w &= cpu_to_be64(~EAS_VALID);
-}
-
 /*
  * XIVE hcalls
  *
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 946311b858..224fe1efcd 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -346,6 +346,33 @@ static int xics_spapr_cpu_intc_create(SpaprInterruptController *intc,
     return 0;
 }
 
+static int xics_spapr_claim_irq(SpaprInterruptController *intc, int irq,
+                                bool lsi, Error **errp)
+{
+    ICSState *ics = ICS_SPAPR(intc);
+
+    assert(ics);
+    assert(ics_valid_irq(ics, irq));
+
+    if (!ics_irq_free(ics, irq - ics->offset)) {
+        error_setg(errp, "IRQ %d is not free", irq);
+        return -EBUSY;
+    }
+
+    ics_set_irq_type(ics, irq - ics->offset, lsi);
+    return 0;
+}
+
+static void xics_spapr_free_irq(SpaprInterruptController *intc, int irq)
+{
+    ICSState *ics = ICS_SPAPR(intc);
+    uint32_t srcno = irq - ics->offset;
+
+    assert(ics_valid_irq(ics, irq));
+
+    memset(&ics->irqs[srcno], 0, sizeof(ICSIRQState));
+}
+
 static void ics_spapr_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -355,6 +382,8 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     device_class_set_parent_realize(dc, ics_spapr_realize,
                                     &isc->parent_realize);
     sicc->cpu_intc_create = xics_spapr_cpu_intc_create;
+    sicc->claim_irq = xics_spapr_claim_irq;
+    sicc->free_irq = xics_spapr_free_irq;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 9cb2fc71ca..83882cfad3 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -98,33 +98,6 @@ static void spapr_irq_init_kvm(SpaprMachineState *spapr,
  * XICS IRQ backend.
  */
 
-static int spapr_irq_claim_xics(SpaprMachineState *spapr, int irq, bool lsi,
-                                Error **errp)
-{
-    ICSState *ics = spapr->ics;
-
-    assert(ics);
-    assert(ics_valid_irq(ics, irq));
-
-    if (!ics_irq_free(ics, irq - ics->offset)) {
-        error_setg(errp, "IRQ %d is not free", irq);
-        return -1;
-    }
-
-    ics_set_irq_type(ics, irq - ics->offset, lsi);
-    return 0;
-}
-
-static void spapr_irq_free_xics(SpaprMachineState *spapr, int irq)
-{
-    ICSState *ics = spapr->ics;
-    uint32_t srcno = irq - ics->offset;
-
-    assert(ics_valid_irq(ics, irq));
-
-    memset(&ics->irqs[srcno], 0, sizeof(ICSIRQState));
-}
-
 static void spapr_irq_print_info_xics(SpaprMachineState *spapr, Monitor *mon)
 {
     CPUState *cs;
@@ -182,8 +155,6 @@ SpaprIrq spapr_irq_xics = {
     .xics        = true,
     .xive        = false,
 
-    .claim       = spapr_irq_claim_xics,
-    .free        = spapr_irq_free_xics,
     .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
@@ -196,17 +167,6 @@ SpaprIrq spapr_irq_xics = {
  * XIVE IRQ backend.
  */
 
-static int spapr_irq_claim_xive(SpaprMachineState *spapr, int irq, bool lsi,
-                                Error **errp)
-{
-    return spapr_xive_irq_claim(spapr->xive, irq, lsi, errp);
-}
-
-static void spapr_irq_free_xive(SpaprMachineState *spapr, int irq)
-{
-    spapr_xive_irq_free(spapr->xive, irq);
-}
-
 static void spapr_irq_print_info_xive(SpaprMachineState *spapr,
                                       Monitor *mon)
 {
@@ -272,8 +232,6 @@ SpaprIrq spapr_irq_xive = {
     .xics        = false,
     .xive        = true,
 
-    .claim       = spapr_irq_claim_xive,
-    .free        = spapr_irq_free_xive,
     .print_info  = spapr_irq_print_info_xive,
     .dt_populate = spapr_dt_xive,
     .post_load   = spapr_irq_post_load_xive,
@@ -301,33 +259,6 @@ static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
         &spapr_irq_xive : &spapr_irq_xics;
 }
 
-static int spapr_irq_claim_dual(SpaprMachineState *spapr, int irq, bool lsi,
-                                Error **errp)
-{
-    Error *local_err = NULL;
-    int ret;
-
-    ret = spapr_irq_xics.claim(spapr, irq, lsi, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return ret;
-    }
-
-    ret = spapr_irq_xive.claim(spapr, irq, lsi, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return ret;
-    }
-
-    return ret;
-}
-
-static void spapr_irq_free_dual(SpaprMachineState *spapr, int irq)
-{
-    spapr_irq_xics.free(spapr, irq);
-    spapr_irq_xive.free(spapr, irq);
-}
-
 static void spapr_irq_print_info_dual(SpaprMachineState *spapr, Monitor *mon)
 {
     spapr_irq_current(spapr)->print_info(spapr, mon);
@@ -401,8 +332,6 @@ SpaprIrq spapr_irq_dual = {
     .xics        = true,
     .xive        = true,
 
-    .claim       = spapr_irq_claim_dual,
-    .free        = spapr_irq_free_dual,
     .print_info  = spapr_irq_print_info_dual,
     .dt_populate = spapr_irq_dt_populate_dual,
     .post_load   = spapr_irq_post_load_dual,
@@ -572,8 +501,11 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 
         /* Enable the CPU IPIs */
         for (i = 0; i < nr_servers; ++i) {
-            if (spapr_xive_irq_claim(spapr->xive, SPAPR_IRQ_IPI + i,
-                                     false, errp) < 0) {
+            SpaprInterruptControllerClass *sicc
+                = SPAPR_INTC_GET_CLASS(spapr->xive);
+
+            if (sicc->claim_irq(SPAPR_INTC(spapr->xive), SPAPR_IRQ_IPI + i,
+                                false, errp) < 0) {
                 return;
             }
         }
@@ -587,21 +519,45 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 
 int spapr_irq_claim(SpaprMachineState *spapr, int irq, bool lsi, Error **errp)
 {
+    SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
+    int i;
+    int rc;
+
     assert(irq >= SPAPR_XIRQ_BASE);
     assert(irq < (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
 
-    return spapr->irq->claim(spapr, irq, lsi, errp);
+    for (i = 0; i < ARRAY_SIZE(intcs); i++) {
+        SpaprInterruptController *intc = intcs[i];
+        if (intc) {
+            SpaprInterruptControllerClass *sicc = SPAPR_INTC_GET_CLASS(intc);
+            rc = sicc->claim_irq(intc, irq, lsi, errp);
+            if (rc < 0) {
+                return rc;
+            }
+        }
+    }
+
+    return 0;
 }
 
 void spapr_irq_free(SpaprMachineState *spapr, int irq, int num)
 {
-    int i;
+    SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
+    int i, j;
 
     assert(irq >= SPAPR_XIRQ_BASE);
     assert((irq + num) <= (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
 
     for (i = irq; i < (irq + num); i++) {
-        spapr->irq->free(spapr, i);
+        for (j = 0; j < ARRAY_SIZE(intcs); j++) {
+            SpaprInterruptController *intc = intcs[j];
+
+            if (intc) {
+                SpaprInterruptControllerClass *sicc
+                    = SPAPR_INTC_GET_CLASS(intc);
+                sicc->free_irq(intc, i);
+            }
+        }
     }
 }
 
@@ -726,8 +682,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .xics        = true,
     .xive        = false,
 
-    .claim       = spapr_irq_claim_xics,
-    .free        = spapr_irq_free_xics,
     .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 5e641e23c1..adfef0fcbe 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -50,6 +50,9 @@ typedef struct SpaprInterruptControllerClass {
      */
     int (*cpu_intc_create)(SpaprInterruptController *intc,
                             PowerPCCPU *cpu, Error **errp);
+    int (*claim_irq)(SpaprInterruptController *intc, int irq, bool lsi,
+                     Error **errp);
+    void (*free_irq)(SpaprInterruptController *intc, int irq);
 } SpaprInterruptControllerClass;
 
 int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
@@ -67,8 +70,6 @@ typedef struct SpaprIrq {
     bool        xics;
     bool        xive;
 
-    int (*claim)(SpaprMachineState *spapr, int irq, bool lsi, Error **errp);
-    void (*free)(SpaprMachineState *spapr, int irq);
     void (*print_info)(SpaprMachineState *spapr, Monitor *mon);
     void (*dt_populate)(SpaprMachineState *spapr, uint32_t nr_servers,
                         void *fdt, uint32_t phandle);
diff --git a/include/hw/ppc/spapr_xive.h b/include/hw/ppc/spapr_xive.h
index 0df20a6590..8f875673f5 100644
--- a/include/hw/ppc/spapr_xive.h
+++ b/include/hw/ppc/spapr_xive.h
@@ -54,8 +54,6 @@ typedef struct SpaprXive {
  */
 #define SPAPR_XIVE_BLOCK_ID 0x0
 
-int spapr_xive_irq_claim(SpaprXive *xive, int lisn, bool lsi, Error **errp);
-void spapr_xive_irq_free(SpaprXive *xive, int lisn);
 void spapr_xive_pic_print_info(SpaprXive *xive, Monitor *mon);
 int spapr_xive_post_load(SpaprXive *xive, int version_id);
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 10/28] spapr: Formalize notion of active interrupt controller
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (8 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 09/28] spapr, xics, xive: Move irq claim and free " David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 11/28] spapr, xics, xive: Move set_irq from SpaprIrq to SpaprInterruptController David Gibson
                   ` (18 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

spapr now has the mechanism of constructing both XICS and XIVE instances of
the SpaprInterruptController interface.  However, only one of the interrupt
controllers will actually be active at any given time, depending on feature
negotiation with the guest.  This is handled in the current code via
spapr_irq_current() which checks the OV5 vector from feature negotiation to
determine the current backend.

Determining the active controller at the point we need it like this
can be pretty confusing, because it makes it very non obvious at what
points the active controller can change.  This can make it difficult
to reason about the code and where a change of active controller could
appear in sequence with other events.

Make this mechanism more explicit by adding an 'active_intc' pointer
and an explicit spapr_irq_update_active_intc() function to update it
from the CAS state.  We also add hooks on the intc backend which will
get called when it is activated or deactivated.

For now we just introduce the switch and hooks, later patches will
actually start using them.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/ppc/spapr_irq.c         | 51 ++++++++++++++++++++++++++++++++++++++
 include/hw/ppc/spapr.h     |  5 ++--
 include/hw/ppc/spapr_irq.h |  5 ++++
 3 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 83882cfad3..249a2688ac 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -586,6 +586,7 @@ qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
 
 int spapr_irq_post_load(SpaprMachineState *spapr, int version_id)
 {
+    spapr_irq_update_active_intc(spapr);
     return spapr->irq->post_load(spapr, version_id);
 }
 
@@ -593,6 +594,8 @@ void spapr_irq_reset(SpaprMachineState *spapr, Error **errp)
 {
     assert(!spapr->irq_map || bitmap_empty(spapr->irq_map, spapr->irq_map_nr));
 
+    spapr_irq_update_active_intc(spapr);
+
     if (spapr->irq->reset) {
         spapr->irq->reset(spapr, errp);
     }
@@ -619,6 +622,54 @@ int spapr_irq_get_phandle(SpaprMachineState *spapr, void *fdt, Error **errp)
     return phandle;
 }
 
+static void set_active_intc(SpaprMachineState *spapr,
+                            SpaprInterruptController *new_intc)
+{
+    SpaprInterruptControllerClass *sicc;
+
+    assert(new_intc);
+
+    if (new_intc == spapr->active_intc) {
+        /* Nothing to do */
+        return;
+    }
+
+    if (spapr->active_intc) {
+        sicc = SPAPR_INTC_GET_CLASS(spapr->active_intc);
+        if (sicc->deactivate) {
+            sicc->deactivate(spapr->active_intc);
+        }
+    }
+
+    sicc = SPAPR_INTC_GET_CLASS(new_intc);
+    if (sicc->activate) {
+        sicc->activate(new_intc, &error_fatal);
+    }
+
+    spapr->active_intc = new_intc;
+}
+
+void spapr_irq_update_active_intc(SpaprMachineState *spapr)
+{
+    SpaprInterruptController *new_intc;
+
+    if (!spapr->ics) {
+        /*
+         * XXX before we run CAS, ov5_cas is initialized empty, which
+         * indicates XICS, even if we have ic-mode=xive.  TODO: clean
+         * up the CAS path so that we have a clearer way of handling
+         * this.
+         */
+        new_intc = SPAPR_INTC(spapr->xive);
+    } else if (spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT)) {
+        new_intc = SPAPR_INTC(spapr->xive);
+    } else {
+        new_intc = SPAPR_INTC(spapr->ics);
+    }
+
+    set_active_intc(spapr, new_intc);
+}
+
 /*
  * XICS legacy routines - to deprecate one day
  */
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index 2009eb64f9..3b34cf5207 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -144,7 +144,6 @@ struct SpaprMachineState {
     struct SpaprVioBus *vio_bus;
     QLIST_HEAD(, SpaprPhbState) phbs;
     struct SpaprNvram *nvram;
-    ICSState *ics;
     SpaprRtcState rtc;
 
     SpaprResizeHpt resize_hpt;
@@ -196,9 +195,11 @@ struct SpaprMachineState {
 
     int32_t irq_map_nr;
     unsigned long *irq_map;
-    SpaprXive  *xive;
     SpaprIrq *irq;
     qemu_irq *qirqs;
+    SpaprInterruptController *active_intc;
+    ICSState *ics;
+    SpaprXive *xive;
 
     bool cmd_line_caps[SPAPR_CAP_NUM];
     SpaprCapabilities def, eff, mig;
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index adfef0fcbe..593059eff5 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -44,6 +44,9 @@ typedef struct SpaprInterruptController SpaprInterruptController;
 typedef struct SpaprInterruptControllerClass {
     InterfaceClass parent;
 
+    int (*activate)(SpaprInterruptController *intc, Error **errp);
+    void (*deactivate)(SpaprInterruptController *intc);
+
     /*
      * These methods will typically be called on all intcs, active and
      * inactive
@@ -55,6 +58,8 @@ typedef struct SpaprInterruptControllerClass {
     void (*free_irq)(SpaprInterruptController *intc, int irq);
 } SpaprInterruptControllerClass;
 
+void spapr_irq_update_active_intc(SpaprMachineState *spapr);
+
 int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
                               PowerPCCPU *cpu, Error **errp);
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 11/28] spapr, xics, xive: Move set_irq from SpaprIrq to SpaprInterruptController
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (9 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 10/28] spapr: Formalize notion of active interrupt controller David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:17 ` [PULL 12/28] spapr, xics, xive: Move print_info " David Gibson
                   ` (17 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

This method depends only on the active irq controller.  Now that we've
formalized the notion of active controller we can dispatch directly through
that, rather than dispatching via SpaprIrq with the dual version having
to do a second conditional dispatch.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c       | 12 +++++++++++
 hw/intc/xics_spapr.c       |  9 +++++++++
 hw/ppc/spapr_irq.c         | 41 ++++++++++----------------------------
 include/hw/ppc/spapr_irq.h |  4 +++-
 4 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index ff1a175b44..52d5e71793 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -553,6 +553,17 @@ static int spapr_xive_cpu_intc_create(SpaprInterruptController *intc,
     return 0;
 }
 
+static void spapr_xive_set_irq(SpaprInterruptController *intc, int irq, int val)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+
+    if (kvm_irqchip_in_kernel()) {
+        kvmppc_xive_source_set_irq(&xive->source, irq, val);
+    } else {
+        xive_source_set_irq(&xive->source, irq, val);
+    }
+}
+
 static void spapr_xive_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -574,6 +585,7 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     sicc->cpu_intc_create = spapr_xive_cpu_intc_create;
     sicc->claim_irq = spapr_xive_claim_irq;
     sicc->free_irq = spapr_xive_free_irq;
+    sicc->set_irq = spapr_xive_set_irq;
 }
 
 static const TypeInfo spapr_xive_info = {
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 224fe1efcd..02372697f6 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -373,6 +373,14 @@ static void xics_spapr_free_irq(SpaprInterruptController *intc, int irq)
     memset(&ics->irqs[srcno], 0, sizeof(ICSIRQState));
 }
 
+static void xics_spapr_set_irq(SpaprInterruptController *intc, int irq, int val)
+{
+    ICSState *ics = ICS_SPAPR(intc);
+    uint32_t srcno = irq - ics->offset;
+
+    ics_set_irq(ics, srcno, val);
+}
+
 static void ics_spapr_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -384,6 +392,7 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     sicc->cpu_intc_create = xics_spapr_cpu_intc_create;
     sicc->claim_irq = xics_spapr_claim_irq;
     sicc->free_irq = xics_spapr_free_irq;
+    sicc->set_irq = xics_spapr_set_irq;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 249a2688ac..bfccb815ed 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -123,14 +123,6 @@ static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
     return 0;
 }
 
-static void spapr_irq_set_irq_xics(void *opaque, int irq, int val)
-{
-    SpaprMachineState *spapr = opaque;
-    uint32_t srcno = irq - spapr->ics->offset;
-
-    ics_set_irq(spapr->ics, srcno, val);
-}
-
 static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
 {
     Error *local_err = NULL;
@@ -159,7 +151,6 @@ SpaprIrq spapr_irq_xics = {
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
-    .set_irq     = spapr_irq_set_irq_xics,
     .init_kvm    = spapr_irq_init_kvm_xics,
 };
 
@@ -208,17 +199,6 @@ static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
     spapr_xive_mmio_set_enabled(spapr->xive, true);
 }
 
-static void spapr_irq_set_irq_xive(void *opaque, int irq, int val)
-{
-    SpaprMachineState *spapr = opaque;
-
-    if (kvm_irqchip_in_kernel()) {
-        kvmppc_xive_source_set_irq(&spapr->xive->source, irq, val);
-    } else {
-        xive_source_set_irq(&spapr->xive->source, irq, val);
-    }
-}
-
 static void spapr_irq_init_kvm_xive(SpaprMachineState *spapr, Error **errp)
 {
     if (kvm_enabled()) {
@@ -236,7 +216,6 @@ SpaprIrq spapr_irq_xive = {
     .dt_populate = spapr_dt_xive,
     .post_load   = spapr_irq_post_load_xive,
     .reset       = spapr_irq_reset_xive,
-    .set_irq     = spapr_irq_set_irq_xive,
     .init_kvm    = spapr_irq_init_kvm_xive,
 };
 
@@ -316,13 +295,6 @@ static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
     spapr_irq_current(spapr)->reset(spapr, errp);
 }
 
-static void spapr_irq_set_irq_dual(void *opaque, int irq, int val)
-{
-    SpaprMachineState *spapr = opaque;
-
-    spapr_irq_current(spapr)->set_irq(spapr, irq, val);
-}
-
 /*
  * Define values in sync with the XIVE and XICS backend
  */
@@ -336,7 +308,6 @@ SpaprIrq spapr_irq_dual = {
     .dt_populate = spapr_irq_dt_populate_dual,
     .post_load   = spapr_irq_post_load_dual,
     .reset       = spapr_irq_reset_dual,
-    .set_irq     = spapr_irq_set_irq_dual,
     .init_kvm    = NULL, /* should not be used */
 };
 
@@ -424,6 +395,15 @@ int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
     return 0;
 }
 
+static void spapr_set_irq(void *opaque, int irq, int level)
+{
+    SpaprMachineState *spapr = SPAPR_MACHINE(opaque);
+    SpaprInterruptControllerClass *sicc
+        = SPAPR_INTC_GET_CLASS(spapr->active_intc);
+
+    sicc->set_irq(spapr->active_intc, irq, level);
+}
+
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
@@ -513,7 +493,7 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
         spapr_xive_hcall_init(spapr);
     }
 
-    spapr->qirqs = qemu_allocate_irqs(spapr->irq->set_irq, spapr,
+    spapr->qirqs = qemu_allocate_irqs(spapr_set_irq, spapr,
                                       spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE);
 }
 
@@ -737,7 +717,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
-    .set_irq     = spapr_irq_set_irq_xics,
     .init_kvm    = spapr_irq_init_kvm_xics,
 };
 
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 593059eff5..ece8d2ea48 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -56,6 +56,9 @@ typedef struct SpaprInterruptControllerClass {
     int (*claim_irq)(SpaprInterruptController *intc, int irq, bool lsi,
                      Error **errp);
     void (*free_irq)(SpaprInterruptController *intc, int irq);
+
+    /* These methods should only be called on the active intc */
+    void (*set_irq)(SpaprInterruptController *intc, int irq, int val);
 } SpaprInterruptControllerClass;
 
 void spapr_irq_update_active_intc(SpaprMachineState *spapr);
@@ -80,7 +83,6 @@ typedef struct SpaprIrq {
                         void *fdt, uint32_t phandle);
     int (*post_load)(SpaprMachineState *spapr, int version_id);
     void (*reset)(SpaprMachineState *spapr, Error **errp);
-    void (*set_irq)(void *opaque, int srcno, int val);
     void (*init_kvm)(SpaprMachineState *spapr, Error **errp);
 } SpaprIrq;
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 12/28] spapr, xics, xive: Move print_info from SpaprIrq to SpaprInterruptController
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (10 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 11/28] spapr, xics, xive: Move set_irq from SpaprIrq to SpaprInterruptController David Gibson
@ 2019-10-24  8:17 ` " David Gibson
  2019-10-24  8:17 ` [PULL 13/28] spapr, xics, xive: Move dt_populate " David Gibson
                   ` (16 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

This method depends only on the active irq controller.  Now that we've
formalized the notion of active controller we can dispatch directly
through that, rather than dispatching via SpaprIrq with the dual
version having to do a second conditional dispatch.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c       | 15 +++++++++++++
 hw/intc/xics_spapr.c       | 15 +++++++++++++
 hw/ppc/spapr.c             |  2 +-
 hw/ppc/spapr_irq.c         | 44 +++++++-------------------------------
 include/hw/ppc/spapr_irq.h |  4 ++--
 5 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 52d5e71793..700ec5c9c1 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -564,6 +564,20 @@ static void spapr_xive_set_irq(SpaprInterruptController *intc, int irq, int val)
     }
 }
 
+static void spapr_xive_print_info(SpaprInterruptController *intc, Monitor *mon)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    CPUState *cs;
+
+    CPU_FOREACH(cs) {
+        PowerPCCPU *cpu = POWERPC_CPU(cs);
+
+        xive_tctx_pic_print_info(spapr_cpu_state(cpu)->tctx, mon);
+    }
+
+    spapr_xive_pic_print_info(xive, mon);
+}
+
 static void spapr_xive_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -586,6 +600,7 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     sicc->claim_irq = spapr_xive_claim_irq;
     sicc->free_irq = spapr_xive_free_irq;
     sicc->set_irq = spapr_xive_set_irq;
+    sicc->print_info = spapr_xive_print_info;
 }
 
 static const TypeInfo spapr_xive_info = {
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 02372697f6..415defe394 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -381,6 +381,20 @@ static void xics_spapr_set_irq(SpaprInterruptController *intc, int irq, int val)
     ics_set_irq(ics, srcno, val);
 }
 
+static void xics_spapr_print_info(SpaprInterruptController *intc, Monitor *mon)
+{
+    ICSState *ics = ICS_SPAPR(intc);
+    CPUState *cs;
+
+    CPU_FOREACH(cs) {
+        PowerPCCPU *cpu = POWERPC_CPU(cs);
+
+        icp_pic_print_info(spapr_cpu_state(cpu)->icp, mon);
+    }
+
+    ics_pic_print_info(ics, mon);
+}
+
 static void ics_spapr_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -393,6 +407,7 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     sicc->claim_irq = xics_spapr_claim_irq;
     sicc->free_irq = xics_spapr_free_irq;
     sicc->set_irq = xics_spapr_set_irq;
+    sicc->print_info = xics_spapr_print_info;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 428b834f30..24fe12b244 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -4266,7 +4266,7 @@ static void spapr_pic_print_info(InterruptStatsProvider *obj,
 {
     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
 
-    spapr->irq->print_info(spapr, mon);
+    spapr_irq_print_info(spapr, mon);
     monitor_printf(mon, "irqchip: %s\n",
                    kvm_irqchip_in_kernel() ? "in-kernel" : "emulated");
 }
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index bfccb815ed..a29b527232 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -98,19 +98,6 @@ static void spapr_irq_init_kvm(SpaprMachineState *spapr,
  * XICS IRQ backend.
  */
 
-static void spapr_irq_print_info_xics(SpaprMachineState *spapr, Monitor *mon)
-{
-    CPUState *cs;
-
-    CPU_FOREACH(cs) {
-        PowerPCCPU *cpu = POWERPC_CPU(cs);
-
-        icp_pic_print_info(spapr_cpu_state(cpu)->icp, mon);
-    }
-
-    ics_pic_print_info(spapr->ics, mon);
-}
-
 static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
 {
     if (!kvm_irqchip_in_kernel()) {
@@ -147,7 +134,6 @@ SpaprIrq spapr_irq_xics = {
     .xics        = true,
     .xive        = false,
 
-    .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
@@ -158,20 +144,6 @@ SpaprIrq spapr_irq_xics = {
  * XIVE IRQ backend.
  */
 
-static void spapr_irq_print_info_xive(SpaprMachineState *spapr,
-                                      Monitor *mon)
-{
-    CPUState *cs;
-
-    CPU_FOREACH(cs) {
-        PowerPCCPU *cpu = POWERPC_CPU(cs);
-
-        xive_tctx_pic_print_info(spapr_cpu_state(cpu)->tctx, mon);
-    }
-
-    spapr_xive_pic_print_info(spapr->xive, mon);
-}
-
 static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
 {
     return spapr_xive_post_load(spapr->xive, version_id);
@@ -212,7 +184,6 @@ SpaprIrq spapr_irq_xive = {
     .xics        = false,
     .xive        = true,
 
-    .print_info  = spapr_irq_print_info_xive,
     .dt_populate = spapr_dt_xive,
     .post_load   = spapr_irq_post_load_xive,
     .reset       = spapr_irq_reset_xive,
@@ -238,11 +209,6 @@ static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
         &spapr_irq_xive : &spapr_irq_xics;
 }
 
-static void spapr_irq_print_info_dual(SpaprMachineState *spapr, Monitor *mon)
-{
-    spapr_irq_current(spapr)->print_info(spapr, mon);
-}
-
 static void spapr_irq_dt_populate_dual(SpaprMachineState *spapr,
                                        uint32_t nr_servers, void *fdt,
                                        uint32_t phandle)
@@ -304,7 +270,6 @@ SpaprIrq spapr_irq_dual = {
     .xics        = true,
     .xive        = true,
 
-    .print_info  = spapr_irq_print_info_dual,
     .dt_populate = spapr_irq_dt_populate_dual,
     .post_load   = spapr_irq_post_load_dual,
     .reset       = spapr_irq_reset_dual,
@@ -404,6 +369,14 @@ static void spapr_set_irq(void *opaque, int irq, int level)
     sicc->set_irq(spapr->active_intc, irq, level);
 }
 
+void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon)
+{
+    SpaprInterruptControllerClass *sicc
+        = SPAPR_INTC_GET_CLASS(spapr->active_intc);
+
+    sicc->print_info(spapr->active_intc, mon);
+}
+
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
@@ -713,7 +686,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .xics        = true,
     .xive        = false,
 
-    .print_info  = spapr_irq_print_info_xics,
     .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index ece8d2ea48..bdfeb3b107 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -59,13 +59,14 @@ typedef struct SpaprInterruptControllerClass {
 
     /* These methods should only be called on the active intc */
     void (*set_irq)(SpaprInterruptController *intc, int irq, int val);
+    void (*print_info)(SpaprInterruptController *intc, Monitor *mon);
 } SpaprInterruptControllerClass;
 
 void spapr_irq_update_active_intc(SpaprMachineState *spapr);
 
 int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
                               PowerPCCPU *cpu, Error **errp);
-
+void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon);
 
 void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis);
 int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
@@ -78,7 +79,6 @@ typedef struct SpaprIrq {
     bool        xics;
     bool        xive;
 
-    void (*print_info)(SpaprMachineState *spapr, Monitor *mon);
     void (*dt_populate)(SpaprMachineState *spapr, uint32_t nr_servers,
                         void *fdt, uint32_t phandle);
     int (*post_load)(SpaprMachineState *spapr, int version_id);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 13/28] spapr, xics, xive: Move dt_populate from SpaprIrq to SpaprInterruptController
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (11 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 12/28] spapr, xics, xive: Move print_info " David Gibson
@ 2019-10-24  8:17 ` " David Gibson
  2019-10-24  8:17 ` [PULL 14/28] spapr, xics, xive: Match signatures for XICS and XIVE KVM connect routines David Gibson
                   ` (15 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

This method depends only on the active irq controller.  Now that we've
formalized the notion of active controller we can dispatch directly
through that, rather than dispatching via SpaprIrq with the dual
version having to do a second conditional dispatch.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c        | 125 ++++++++++++++++++------------------
 hw/intc/xics_spapr.c        |   5 +-
 hw/ppc/spapr.c              |   3 +-
 hw/ppc/spapr_irq.c          |  20 +++---
 include/hw/ppc/spapr_irq.h  |   6 +-
 include/hw/ppc/spapr_xive.h |   2 -
 include/hw/ppc/xics_spapr.h |   2 -
 7 files changed, 80 insertions(+), 83 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 700ec5c9c1..37ffb74ca5 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -578,6 +578,68 @@ static void spapr_xive_print_info(SpaprInterruptController *intc, Monitor *mon)
     spapr_xive_pic_print_info(xive, mon);
 }
 
+static void spapr_xive_dt(SpaprInterruptController *intc, uint32_t nr_servers,
+                          void *fdt, uint32_t phandle)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    int node;
+    uint64_t timas[2 * 2];
+    /* Interrupt number ranges for the IPIs */
+    uint32_t lisn_ranges[] = {
+        cpu_to_be32(0),
+        cpu_to_be32(nr_servers),
+    };
+    /*
+     * EQ size - the sizes of pages supported by the system 4K, 64K,
+     * 2M, 16M. We only advertise 64K for the moment.
+     */
+    uint32_t eq_sizes[] = {
+        cpu_to_be32(16), /* 64K */
+    };
+    /*
+     * The following array is in sync with the reserved priorities
+     * defined by the 'spapr_xive_priority_is_reserved' routine.
+     */
+    uint32_t plat_res_int_priorities[] = {
+        cpu_to_be32(7),    /* start */
+        cpu_to_be32(0xf8), /* count */
+    };
+
+    /* Thread Interrupt Management Area : User (ring 3) and OS (ring 2) */
+    timas[0] = cpu_to_be64(xive->tm_base +
+                           XIVE_TM_USER_PAGE * (1ull << TM_SHIFT));
+    timas[1] = cpu_to_be64(1ull << TM_SHIFT);
+    timas[2] = cpu_to_be64(xive->tm_base +
+                           XIVE_TM_OS_PAGE * (1ull << TM_SHIFT));
+    timas[3] = cpu_to_be64(1ull << TM_SHIFT);
+
+    _FDT(node = fdt_add_subnode(fdt, 0, xive->nodename));
+
+    _FDT(fdt_setprop_string(fdt, node, "device_type", "power-ivpe"));
+    _FDT(fdt_setprop(fdt, node, "reg", timas, sizeof(timas)));
+
+    _FDT(fdt_setprop_string(fdt, node, "compatible", "ibm,power-ivpe"));
+    _FDT(fdt_setprop(fdt, node, "ibm,xive-eq-sizes", eq_sizes,
+                     sizeof(eq_sizes)));
+    _FDT(fdt_setprop(fdt, node, "ibm,xive-lisn-ranges", lisn_ranges,
+                     sizeof(lisn_ranges)));
+
+    /* For Linux to link the LSIs to the interrupt controller. */
+    _FDT(fdt_setprop(fdt, node, "interrupt-controller", NULL, 0));
+    _FDT(fdt_setprop_cell(fdt, node, "#interrupt-cells", 2));
+
+    /* For SLOF */
+    _FDT(fdt_setprop_cell(fdt, node, "linux,phandle", phandle));
+    _FDT(fdt_setprop_cell(fdt, node, "phandle", phandle));
+
+    /*
+     * The "ibm,plat-res-int-priorities" property defines the priority
+     * ranges reserved by the hypervisor
+     */
+    _FDT(fdt_setprop(fdt, 0, "ibm,plat-res-int-priorities",
+                     plat_res_int_priorities, sizeof(plat_res_int_priorities)));
+}
+
 static void spapr_xive_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -601,6 +663,7 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     sicc->free_irq = spapr_xive_free_irq;
     sicc->set_irq = spapr_xive_set_irq;
     sicc->print_info = spapr_xive_print_info;
+    sicc->dt = spapr_xive_dt;
 }
 
 static const TypeInfo spapr_xive_info = {
@@ -1601,65 +1664,3 @@ void spapr_xive_hcall_init(SpaprMachineState *spapr)
     spapr_register_hypercall(H_INT_SYNC, h_int_sync);
     spapr_register_hypercall(H_INT_RESET, h_int_reset);
 }
-
-void spapr_dt_xive(SpaprMachineState *spapr, uint32_t nr_servers, void *fdt,
-                   uint32_t phandle)
-{
-    SpaprXive *xive = spapr->xive;
-    int node;
-    uint64_t timas[2 * 2];
-    /* Interrupt number ranges for the IPIs */
-    uint32_t lisn_ranges[] = {
-        cpu_to_be32(0),
-        cpu_to_be32(nr_servers),
-    };
-    /*
-     * EQ size - the sizes of pages supported by the system 4K, 64K,
-     * 2M, 16M. We only advertise 64K for the moment.
-     */
-    uint32_t eq_sizes[] = {
-        cpu_to_be32(16), /* 64K */
-    };
-    /*
-     * The following array is in sync with the reserved priorities
-     * defined by the 'spapr_xive_priority_is_reserved' routine.
-     */
-    uint32_t plat_res_int_priorities[] = {
-        cpu_to_be32(7),    /* start */
-        cpu_to_be32(0xf8), /* count */
-    };
-
-    /* Thread Interrupt Management Area : User (ring 3) and OS (ring 2) */
-    timas[0] = cpu_to_be64(xive->tm_base +
-                           XIVE_TM_USER_PAGE * (1ull << TM_SHIFT));
-    timas[1] = cpu_to_be64(1ull << TM_SHIFT);
-    timas[2] = cpu_to_be64(xive->tm_base +
-                           XIVE_TM_OS_PAGE * (1ull << TM_SHIFT));
-    timas[3] = cpu_to_be64(1ull << TM_SHIFT);
-
-    _FDT(node = fdt_add_subnode(fdt, 0, xive->nodename));
-
-    _FDT(fdt_setprop_string(fdt, node, "device_type", "power-ivpe"));
-    _FDT(fdt_setprop(fdt, node, "reg", timas, sizeof(timas)));
-
-    _FDT(fdt_setprop_string(fdt, node, "compatible", "ibm,power-ivpe"));
-    _FDT(fdt_setprop(fdt, node, "ibm,xive-eq-sizes", eq_sizes,
-                     sizeof(eq_sizes)));
-    _FDT(fdt_setprop(fdt, node, "ibm,xive-lisn-ranges", lisn_ranges,
-                     sizeof(lisn_ranges)));
-
-    /* For Linux to link the LSIs to the interrupt controller. */
-    _FDT(fdt_setprop(fdt, node, "interrupt-controller", NULL, 0));
-    _FDT(fdt_setprop_cell(fdt, node, "#interrupt-cells", 2));
-
-    /* For SLOF */
-    _FDT(fdt_setprop_cell(fdt, node, "linux,phandle", phandle));
-    _FDT(fdt_setprop_cell(fdt, node, "phandle", phandle));
-
-    /*
-     * The "ibm,plat-res-int-priorities" property defines the priority
-     * ranges reserved by the hypervisor
-     */
-    _FDT(fdt_setprop(fdt, 0, "ibm,plat-res-int-priorities",
-                     plat_res_int_priorities, sizeof(plat_res_int_priorities)));
-}
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 415defe394..4eabafc7e1 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -308,8 +308,8 @@ static void ics_spapr_realize(DeviceState *dev, Error **errp)
     spapr_register_hypercall(H_IPOLL, h_ipoll);
 }
 
-void spapr_dt_xics(SpaprMachineState *spapr, uint32_t nr_servers, void *fdt,
-                   uint32_t phandle)
+static void xics_spapr_dt(SpaprInterruptController *intc, uint32_t nr_servers,
+                          void *fdt, uint32_t phandle)
 {
     uint32_t interrupt_server_ranges_prop[] = {
         0, cpu_to_be32(nr_servers),
@@ -408,6 +408,7 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     sicc->free_irq = xics_spapr_free_irq;
     sicc->set_irq = xics_spapr_set_irq;
     sicc->print_info = xics_spapr_print_info;
+    sicc->dt = xics_spapr_dt;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 24fe12b244..c9623600c2 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -1247,8 +1247,7 @@ static void *spapr_build_fdt(SpaprMachineState *spapr)
     _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2));
 
     /* /interrupt controller */
-    spapr->irq->dt_populate(spapr, spapr_max_server_number(spapr), fdt,
-                          PHANDLE_INTC);
+    spapr_irq_dt(spapr, spapr_max_server_number(spapr), fdt, PHANDLE_INTC);
 
     ret = spapr_populate_memory(spapr, fdt);
     if (ret < 0) {
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index a29b527232..a8005072e6 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -134,7 +134,6 @@ SpaprIrq spapr_irq_xics = {
     .xics        = true,
     .xive        = false,
 
-    .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
     .init_kvm    = spapr_irq_init_kvm_xics,
@@ -184,7 +183,6 @@ SpaprIrq spapr_irq_xive = {
     .xics        = false,
     .xive        = true,
 
-    .dt_populate = spapr_dt_xive,
     .post_load   = spapr_irq_post_load_xive,
     .reset       = spapr_irq_reset_xive,
     .init_kvm    = spapr_irq_init_kvm_xive,
@@ -209,13 +207,6 @@ static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
         &spapr_irq_xive : &spapr_irq_xics;
 }
 
-static void spapr_irq_dt_populate_dual(SpaprMachineState *spapr,
-                                       uint32_t nr_servers, void *fdt,
-                                       uint32_t phandle)
-{
-    spapr_irq_current(spapr)->dt_populate(spapr, nr_servers, fdt, phandle);
-}
-
 static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
 {
     /*
@@ -270,7 +261,6 @@ SpaprIrq spapr_irq_dual = {
     .xics        = true,
     .xive        = true,
 
-    .dt_populate = spapr_irq_dt_populate_dual,
     .post_load   = spapr_irq_post_load_dual,
     .reset       = spapr_irq_reset_dual,
     .init_kvm    = NULL, /* should not be used */
@@ -377,6 +367,15 @@ void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon)
     sicc->print_info(spapr->active_intc, mon);
 }
 
+void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
+                  void *fdt, uint32_t phandle)
+{
+    SpaprInterruptControllerClass *sicc
+        = SPAPR_INTC_GET_CLASS(spapr->active_intc);
+
+    sicc->dt(spapr->active_intc, nr_servers, fdt, phandle);
+}
+
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
@@ -686,7 +685,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .xics        = true,
     .xive        = false,
 
-    .dt_populate = spapr_dt_xics,
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
     .init_kvm    = spapr_irq_init_kvm_xics,
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index bdfeb3b107..0df95e1b5a 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -60,6 +60,8 @@ typedef struct SpaprInterruptControllerClass {
     /* These methods should only be called on the active intc */
     void (*set_irq)(SpaprInterruptController *intc, int irq, int val);
     void (*print_info)(SpaprInterruptController *intc, Monitor *mon);
+    void (*dt)(SpaprInterruptController *intc, uint32_t nr_servers,
+               void *fdt, uint32_t phandle);
 } SpaprInterruptControllerClass;
 
 void spapr_irq_update_active_intc(SpaprMachineState *spapr);
@@ -67,6 +69,8 @@ void spapr_irq_update_active_intc(SpaprMachineState *spapr);
 int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
                               PowerPCCPU *cpu, Error **errp);
 void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon);
+void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
+                  void *fdt, uint32_t phandle);
 
 void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis);
 int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
@@ -79,8 +83,6 @@ typedef struct SpaprIrq {
     bool        xics;
     bool        xive;
 
-    void (*dt_populate)(SpaprMachineState *spapr, uint32_t nr_servers,
-                        void *fdt, uint32_t phandle);
     int (*post_load)(SpaprMachineState *spapr, int version_id);
     void (*reset)(SpaprMachineState *spapr, Error **errp);
     void (*init_kvm)(SpaprMachineState *spapr, Error **errp);
diff --git a/include/hw/ppc/spapr_xive.h b/include/hw/ppc/spapr_xive.h
index 8f875673f5..ebe156eb30 100644
--- a/include/hw/ppc/spapr_xive.h
+++ b/include/hw/ppc/spapr_xive.h
@@ -58,8 +58,6 @@ void spapr_xive_pic_print_info(SpaprXive *xive, Monitor *mon);
 int spapr_xive_post_load(SpaprXive *xive, int version_id);
 
 void spapr_xive_hcall_init(SpaprMachineState *spapr);
-void spapr_dt_xive(SpaprMachineState *spapr, uint32_t nr_servers, void *fdt,
-                   uint32_t phandle);
 void spapr_xive_set_tctx_os_cam(XiveTCTX *tctx);
 void spapr_xive_mmio_set_enabled(SpaprXive *xive, bool enable);
 void spapr_xive_map_mmio(SpaprXive *xive);
diff --git a/include/hw/ppc/xics_spapr.h b/include/hw/ppc/xics_spapr.h
index 0b35e85c26..8e4fb6adce 100644
--- a/include/hw/ppc/xics_spapr.h
+++ b/include/hw/ppc/xics_spapr.h
@@ -32,8 +32,6 @@
 #define TYPE_ICS_SPAPR "ics-spapr"
 #define ICS_SPAPR(obj) OBJECT_CHECK(ICSState, (obj), TYPE_ICS_SPAPR)
 
-void spapr_dt_xics(SpaprMachineState *spapr, uint32_t nr_servers, void *fdt,
-                   uint32_t phandle);
 int xics_kvm_connect(SpaprMachineState *spapr, Error **errp);
 void xics_kvm_disconnect(SpaprMachineState *spapr, Error **errp);
 bool xics_kvm_has_broken_disconnect(SpaprMachineState *spapr);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 14/28] spapr, xics, xive: Match signatures for XICS and XIVE KVM connect routines
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (12 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 13/28] spapr, xics, xive: Move dt_populate " David Gibson
@ 2019-10-24  8:17 ` David Gibson
  2019-10-24  8:18 ` [PULL 15/28] spapr: Remove SpaprIrq::init_kvm hook David Gibson
                   ` (14 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:17 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

Both XICS and XIVE have routines to connect and disconnect KVM with
similar but not identical signatures.  This adjusts them to match
exactly, which will be useful for further cleanups later.

While we're there, we add an explicit return value to the connect path
to streamline error reporting in the callers.  We remove error
reporting the disconnect path.  In the XICS case this wasn't used at
all.  In the XIVE case the only error case was if the KVM device was
set up, but KVM didn't have the capability to do so which is pretty
obviously impossible.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive_kvm.c    | 22 ++++++++++------------
 hw/intc/xics_kvm.c          |  9 +++++----
 hw/ppc/spapr_irq.c          | 22 +++++-----------------
 include/hw/ppc/spapr_xive.h |  4 ++--
 include/hw/ppc/xics_spapr.h |  4 ++--
 5 files changed, 24 insertions(+), 37 deletions(-)

diff --git a/hw/intc/spapr_xive_kvm.c b/hw/intc/spapr_xive_kvm.c
index 51b334b676..08012ac7cd 100644
--- a/hw/intc/spapr_xive_kvm.c
+++ b/hw/intc/spapr_xive_kvm.c
@@ -740,8 +740,9 @@ static void *kvmppc_xive_mmap(SpaprXive *xive, int pgoff, size_t len,
  * All the XIVE memory regions are now backed by mappings from the KVM
  * XIVE device.
  */
-void kvmppc_xive_connect(SpaprXive *xive, Error **errp)
+int kvmppc_xive_connect(SpaprInterruptController *intc, Error **errp)
 {
+    SpaprXive *xive = SPAPR_XIVE(intc);
     XiveSource *xsrc = &xive->source;
     Error *local_err = NULL;
     size_t esb_len = (1ull << xsrc->esb_shift) * xsrc->nr_irqs;
@@ -753,19 +754,19 @@ void kvmppc_xive_connect(SpaprXive *xive, Error **errp)
      * rebooting under the XIVE-only interrupt mode.
      */
     if (xive->fd != -1) {
-        return;
+        return 0;
     }
 
     if (!kvmppc_has_cap_xive()) {
         error_setg(errp, "IRQ_XIVE capability must be present for KVM");
-        return;
+        return -1;
     }
 
     /* First, create the KVM XIVE device */
     xive->fd = kvm_create_device(kvm_state, KVM_DEV_TYPE_XIVE, false);
     if (xive->fd < 0) {
         error_setg_errno(errp, -xive->fd, "XIVE: error creating KVM device");
-        return;
+        return -1;
     }
 
     /*
@@ -821,15 +822,17 @@ void kvmppc_xive_connect(SpaprXive *xive, Error **errp)
     kvm_kernel_irqchip = true;
     kvm_msi_via_irqfd_allowed = true;
     kvm_gsi_direct_mapping = true;
-    return;
+    return 0;
 
 fail:
     error_propagate(errp, local_err);
-    kvmppc_xive_disconnect(xive, NULL);
+    kvmppc_xive_disconnect(intc);
+    return -1;
 }
 
-void kvmppc_xive_disconnect(SpaprXive *xive, Error **errp)
+void kvmppc_xive_disconnect(SpaprInterruptController *intc)
 {
+    SpaprXive *xive = SPAPR_XIVE(intc);
     XiveSource *xsrc;
     size_t esb_len;
 
@@ -838,11 +841,6 @@ void kvmppc_xive_disconnect(SpaprXive *xive, Error **errp)
         return;
     }
 
-    if (!kvmppc_has_cap_xive()) {
-        error_setg(errp, "IRQ_XIVE capability must be present for KVM");
-        return;
-    }
-
     /* Clear the KVM mapping */
     xsrc = &xive->source;
     esb_len = (1ull << xsrc->esb_shift) * xsrc->nr_irqs;
diff --git a/hw/intc/xics_kvm.c b/hw/intc/xics_kvm.c
index ba90d6dc96..954c424b36 100644
--- a/hw/intc/xics_kvm.c
+++ b/hw/intc/xics_kvm.c
@@ -342,8 +342,9 @@ void ics_kvm_set_irq(ICSState *ics, int srcno, int val)
     }
 }
 
-int xics_kvm_connect(SpaprMachineState *spapr, Error **errp)
+int xics_kvm_connect(SpaprInterruptController *intc, Error **errp)
 {
+    ICSState *ics = ICS_SPAPR(intc);
     int rc;
     CPUState *cs;
     Error *local_err = NULL;
@@ -413,7 +414,7 @@ int xics_kvm_connect(SpaprMachineState *spapr, Error **errp)
     }
 
     /* Update the KVM sources */
-    ics_set_kvm_state(spapr->ics, &local_err);
+    ics_set_kvm_state(ics, &local_err);
     if (local_err) {
         goto fail;
     }
@@ -431,11 +432,11 @@ int xics_kvm_connect(SpaprMachineState *spapr, Error **errp)
 
 fail:
     error_propagate(errp, local_err);
-    xics_kvm_disconnect(spapr, NULL);
+    xics_kvm_disconnect(intc);
     return -1;
 }
 
-void xics_kvm_disconnect(SpaprMachineState *spapr, Error **errp)
+void xics_kvm_disconnect(SpaprInterruptController *intc)
 {
     /*
      * Only on P9 using the XICS-on XIVE KVM device:
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index a8005072e6..5c8ffb27da 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -124,7 +124,7 @@ static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
 static void spapr_irq_init_kvm_xics(SpaprMachineState *spapr, Error **errp)
 {
     if (kvm_enabled()) {
-        xics_kvm_connect(spapr, errp);
+        xics_kvm_connect(SPAPR_INTC(spapr->ics), errp);
     }
 }
 
@@ -173,7 +173,7 @@ static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
 static void spapr_irq_init_kvm_xive(SpaprMachineState *spapr, Error **errp)
 {
     if (kvm_enabled()) {
-        kvmppc_xive_connect(spapr->xive, errp);
+        kvmppc_xive_connect(SPAPR_INTC(spapr->xive), errp);
     }
 }
 
@@ -215,7 +215,7 @@ static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
      */
     if (spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT)) {
         if (kvm_irqchip_in_kernel()) {
-            xics_kvm_disconnect(spapr, &error_fatal);
+            xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
         }
         spapr_irq_xive.reset(spapr, &error_fatal);
     }
@@ -225,8 +225,6 @@ static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
 
 static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
 {
-    Error *local_err = NULL;
-
     /*
      * Deactivate the XIVE MMIOs. The XIVE backend will reenable them
      * if selected.
@@ -235,18 +233,8 @@ static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
 
     /* Destroy all KVM devices */
     if (kvm_irqchip_in_kernel()) {
-        xics_kvm_disconnect(spapr, &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
-            error_prepend(errp, "KVM XICS disconnect failed: ");
-            return;
-        }
-        kvmppc_xive_disconnect(spapr->xive, &local_err);
-        if (local_err) {
-            error_propagate(errp, local_err);
-            error_prepend(errp, "KVM XIVE disconnect failed: ");
-            return;
-        }
+        xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
+        kvmppc_xive_disconnect(SPAPR_INTC(spapr->xive));
     }
 
     spapr_irq_current(spapr)->reset(spapr, errp);
diff --git a/include/hw/ppc/spapr_xive.h b/include/hw/ppc/spapr_xive.h
index ebe156eb30..64972754f9 100644
--- a/include/hw/ppc/spapr_xive.h
+++ b/include/hw/ppc/spapr_xive.h
@@ -68,8 +68,8 @@ int spapr_xive_end_to_target(uint8_t end_blk, uint32_t end_idx,
 /*
  * KVM XIVE device helpers
  */
-void kvmppc_xive_connect(SpaprXive *xive, Error **errp);
-void kvmppc_xive_disconnect(SpaprXive *xive, Error **errp);
+int kvmppc_xive_connect(SpaprInterruptController *intc, Error **errp);
+void kvmppc_xive_disconnect(SpaprInterruptController *intc);
 void kvmppc_xive_reset(SpaprXive *xive, Error **errp);
 void kvmppc_xive_set_source_config(SpaprXive *xive, uint32_t lisn, XiveEAS *eas,
                                    Error **errp);
diff --git a/include/hw/ppc/xics_spapr.h b/include/hw/ppc/xics_spapr.h
index 8e4fb6adce..28b87038c8 100644
--- a/include/hw/ppc/xics_spapr.h
+++ b/include/hw/ppc/xics_spapr.h
@@ -32,8 +32,8 @@
 #define TYPE_ICS_SPAPR "ics-spapr"
 #define ICS_SPAPR(obj) OBJECT_CHECK(ICSState, (obj), TYPE_ICS_SPAPR)
 
-int xics_kvm_connect(SpaprMachineState *spapr, Error **errp);
-void xics_kvm_disconnect(SpaprMachineState *spapr, Error **errp);
+int xics_kvm_connect(SpaprInterruptController *intc, Error **errp);
+void xics_kvm_disconnect(SpaprInterruptController *intc);
 bool xics_kvm_has_broken_disconnect(SpaprMachineState *spapr);
 
 #endif /* XICS_SPAPR_H */
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 15/28] spapr: Remove SpaprIrq::init_kvm hook
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (13 preceding siblings ...)
  2019-10-24  8:17 ` [PULL 14/28] spapr, xics, xive: Match signatures for XICS and XIVE KVM connect routines David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 16/28] spapr, xics, xive: Move SpaprIrq::reset hook logic into activate/deactivate David Gibson
                   ` (13 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

This hook is a bit odd.  The only caller is spapr_irq_init_kvm(), but
it explicitly takes an SpaprIrq *, so it's never really called through the
current SpaprIrq.  Essentially this is just a way of passing through a
function pointer so that spapr_irq_init_kvm() can handle some
configuration and error handling logic without duplicating it between the
xics and xive reset paths.

So, make it just take that function pointer.  Because of earlier reworks
to the KVM connect/disconnect code in the xics and xive backends we can
also eliminate some wrapper functions and streamline error handling a bit.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/ppc/spapr_irq.c         | 74 +++++++++++++-------------------------
 include/hw/ppc/spapr_irq.h |  1 -
 2 files changed, 25 insertions(+), 50 deletions(-)

diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 5c8ffb27da..7cd18e5b15 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -65,33 +65,35 @@ void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num)
     bitmap_clear(spapr->irq_map, irq - SPAPR_IRQ_MSI, num);
 }
 
-static void spapr_irq_init_kvm(SpaprMachineState *spapr,
-                                  SpaprIrq *irq, Error **errp)
+static int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
+                              SpaprInterruptController *intc,
+                              Error **errp)
 {
-    MachineState *machine = MACHINE(spapr);
+    MachineState *machine = MACHINE(qdev_get_machine());
     Error *local_err = NULL;
 
     if (kvm_enabled() && machine_kernel_irqchip_allowed(machine)) {
-        irq->init_kvm(spapr, &local_err);
-        if (local_err && machine_kernel_irqchip_required(machine)) {
-            error_prepend(&local_err,
-                          "kernel_irqchip requested but unavailable: ");
-            error_propagate(errp, local_err);
-            return;
-        }
+        if (fn(intc, &local_err) < 0) {
+            if (machine_kernel_irqchip_required(machine)) {
+                error_prepend(&local_err,
+                              "kernel_irqchip requested but unavailable: ");
+                error_propagate(errp, local_err);
+                return -1;
+            }
 
-        if (!local_err) {
-            return;
+            /*
+             * We failed to initialize the KVM device, fallback to
+             * emulated mode
+             */
+            error_prepend(&local_err,
+                          "kernel_irqchip allowed but unavailable: ");
+            error_append_hint(&local_err,
+                              "Falling back to kernel-irqchip=off\n");
+            warn_report_err(local_err);
         }
-
-        /*
-         * We failed to initialize the KVM device, fallback to
-         * emulated mode
-         */
-        error_prepend(&local_err, "kernel_irqchip allowed but unavailable: ");
-        error_append_hint(&local_err, "Falling back to kernel-irqchip=off\n");
-        warn_report_err(local_err);
     }
+
+    return 0;
 }
 
 /*
@@ -112,20 +114,7 @@ static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
 
 static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
 {
-    Error *local_err = NULL;
-
-    spapr_irq_init_kvm(spapr, &spapr_irq_xics, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        return;
-    }
-}
-
-static void spapr_irq_init_kvm_xics(SpaprMachineState *spapr, Error **errp)
-{
-    if (kvm_enabled()) {
-        xics_kvm_connect(SPAPR_INTC(spapr->ics), errp);
-    }
+    spapr_irq_init_kvm(xics_kvm_connect, SPAPR_INTC(spapr->ics), errp);
 }
 
 SpaprIrq spapr_irq_xics = {
@@ -136,7 +125,6 @@ SpaprIrq spapr_irq_xics = {
 
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
-    .init_kvm    = spapr_irq_init_kvm_xics,
 };
 
 /*
@@ -151,7 +139,6 @@ static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
 static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
 {
     CPUState *cs;
-    Error *local_err = NULL;
 
     CPU_FOREACH(cs) {
         PowerPCCPU *cpu = POWERPC_CPU(cs);
@@ -160,9 +147,8 @@ static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
         spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
     }
 
-    spapr_irq_init_kvm(spapr, &spapr_irq_xive, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
+    if (spapr_irq_init_kvm(kvmppc_xive_connect,
+                           SPAPR_INTC(spapr->xive), errp) < 0) {
         return;
     }
 
@@ -170,13 +156,6 @@ static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
     spapr_xive_mmio_set_enabled(spapr->xive, true);
 }
 
-static void spapr_irq_init_kvm_xive(SpaprMachineState *spapr, Error **errp)
-{
-    if (kvm_enabled()) {
-        kvmppc_xive_connect(SPAPR_INTC(spapr->xive), errp);
-    }
-}
-
 SpaprIrq spapr_irq_xive = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
     .nr_msis     = SPAPR_NR_MSIS,
@@ -185,7 +164,6 @@ SpaprIrq spapr_irq_xive = {
 
     .post_load   = spapr_irq_post_load_xive,
     .reset       = spapr_irq_reset_xive,
-    .init_kvm    = spapr_irq_init_kvm_xive,
 };
 
 /*
@@ -251,7 +229,6 @@ SpaprIrq spapr_irq_dual = {
 
     .post_load   = spapr_irq_post_load_dual,
     .reset       = spapr_irq_reset_dual,
-    .init_kvm    = NULL, /* should not be used */
 };
 
 
@@ -675,7 +652,6 @@ SpaprIrq spapr_irq_xics_legacy = {
 
     .post_load   = spapr_irq_post_load_xics,
     .reset       = spapr_irq_reset_xics,
-    .init_kvm    = spapr_irq_init_kvm_xics,
 };
 
 static void spapr_irq_register_types(void)
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 0df95e1b5a..06179b271f 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -85,7 +85,6 @@ typedef struct SpaprIrq {
 
     int (*post_load)(SpaprMachineState *spapr, int version_id);
     void (*reset)(SpaprMachineState *spapr, Error **errp);
-    void (*init_kvm)(SpaprMachineState *spapr, Error **errp);
 } SpaprIrq;
 
 extern SpaprIrq spapr_irq_xics;
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 16/28] spapr, xics, xive: Move SpaprIrq::reset hook logic into activate/deactivate
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (14 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 15/28] spapr: Remove SpaprIrq::init_kvm hook David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 17/28] spapr, xics, xive: Move SpaprIrq::post_load hook to backends David Gibson
                   ` (12 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

It turns out that all the logic in the SpaprIrq::reset hooks (and some in
the SpaprIrq::post_load hooks) isn't really related to resetting the irq
backend (that's handled by the backends' own reset routines).  Rather its
about getting the backend ready to be the active interrupt controller or
stopping being the active interrupt controller - reset (and post_load) is
just the only time that changes at present.

To make this flow clearer, move the logic into the explicit backend
activate and deactivate hooks.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c       | 38 +++++++++++++++++++++
 hw/intc/xics_spapr.c       | 17 ++++++++++
 hw/ppc/spapr_irq.c         | 67 ++------------------------------------
 include/hw/ppc/spapr_irq.h |  4 ++-
 4 files changed, 61 insertions(+), 65 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 37ffb74ca5..1811653aac 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -640,6 +640,42 @@ static void spapr_xive_dt(SpaprInterruptController *intc, uint32_t nr_servers,
                      plat_res_int_priorities, sizeof(plat_res_int_priorities)));
 }
 
+static int spapr_xive_activate(SpaprInterruptController *intc, Error **errp)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+    CPUState *cs;
+
+    CPU_FOREACH(cs) {
+        PowerPCCPU *cpu = POWERPC_CPU(cs);
+
+        /* (TCG) Set the OS CAM line of the thread interrupt context. */
+        spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
+    }
+
+    if (kvm_enabled()) {
+        int rc = spapr_irq_init_kvm(kvmppc_xive_connect, intc, errp);
+        if (rc < 0) {
+            return rc;
+        }
+    }
+
+    /* Activate the XIVE MMIOs */
+    spapr_xive_mmio_set_enabled(xive, true);
+
+    return 0;
+}
+
+static void spapr_xive_deactivate(SpaprInterruptController *intc)
+{
+    SpaprXive *xive = SPAPR_XIVE(intc);
+
+    spapr_xive_mmio_set_enabled(xive, false);
+
+    if (kvm_irqchip_in_kernel()) {
+        kvmppc_xive_disconnect(intc);
+    }
+}
+
 static void spapr_xive_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -658,6 +694,8 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     xrc->write_nvt = spapr_xive_write_nvt;
     xrc->get_tctx = spapr_xive_get_tctx;
 
+    sicc->activate = spapr_xive_activate;
+    sicc->deactivate = spapr_xive_deactivate;
     sicc->cpu_intc_create = spapr_xive_cpu_intc_create;
     sicc->claim_irq = spapr_xive_claim_irq;
     sicc->free_irq = spapr_xive_free_irq;
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 4eabafc7e1..90b4d48877 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -395,6 +395,21 @@ static void xics_spapr_print_info(SpaprInterruptController *intc, Monitor *mon)
     ics_pic_print_info(ics, mon);
 }
 
+static int xics_spapr_activate(SpaprInterruptController *intc, Error **errp)
+{
+    if (kvm_enabled()) {
+        return spapr_irq_init_kvm(xics_kvm_connect, intc, errp);
+    }
+    return 0;
+}
+
+static void xics_spapr_deactivate(SpaprInterruptController *intc)
+{
+    if (kvm_irqchip_in_kernel()) {
+        xics_kvm_disconnect(intc);
+    }
+}
+
 static void ics_spapr_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
@@ -403,6 +418,8 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
 
     device_class_set_parent_realize(dc, ics_spapr_realize,
                                     &isc->parent_realize);
+    sicc->activate = xics_spapr_activate;
+    sicc->deactivate = xics_spapr_deactivate;
     sicc->cpu_intc_create = xics_spapr_cpu_intc_create;
     sicc->claim_irq = xics_spapr_claim_irq;
     sicc->free_irq = xics_spapr_free_irq;
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 7cd18e5b15..f70b331f44 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -65,9 +65,9 @@ void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num)
     bitmap_clear(spapr->irq_map, irq - SPAPR_IRQ_MSI, num);
 }
 
-static int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
-                              SpaprInterruptController *intc,
-                              Error **errp)
+int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
+                       SpaprInterruptController *intc,
+                       Error **errp)
 {
     MachineState *machine = MACHINE(qdev_get_machine());
     Error *local_err = NULL;
@@ -112,11 +112,6 @@ static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
     return 0;
 }
 
-static void spapr_irq_reset_xics(SpaprMachineState *spapr, Error **errp)
-{
-    spapr_irq_init_kvm(xics_kvm_connect, SPAPR_INTC(spapr->ics), errp);
-}
-
 SpaprIrq spapr_irq_xics = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
     .nr_msis     = SPAPR_NR_MSIS,
@@ -124,7 +119,6 @@ SpaprIrq spapr_irq_xics = {
     .xive        = false,
 
     .post_load   = spapr_irq_post_load_xics,
-    .reset       = spapr_irq_reset_xics,
 };
 
 /*
@@ -136,26 +130,6 @@ static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
     return spapr_xive_post_load(spapr->xive, version_id);
 }
 
-static void spapr_irq_reset_xive(SpaprMachineState *spapr, Error **errp)
-{
-    CPUState *cs;
-
-    CPU_FOREACH(cs) {
-        PowerPCCPU *cpu = POWERPC_CPU(cs);
-
-        /* (TCG) Set the OS CAM line of the thread interrupt context. */
-        spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
-    }
-
-    if (spapr_irq_init_kvm(kvmppc_xive_connect,
-                           SPAPR_INTC(spapr->xive), errp) < 0) {
-        return;
-    }
-
-    /* Activate the XIVE MMIOs */
-    spapr_xive_mmio_set_enabled(spapr->xive, true);
-}
-
 SpaprIrq spapr_irq_xive = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
     .nr_msis     = SPAPR_NR_MSIS,
@@ -163,7 +137,6 @@ SpaprIrq spapr_irq_xive = {
     .xive        = true,
 
     .post_load   = spapr_irq_post_load_xive,
-    .reset       = spapr_irq_reset_xive,
 };
 
 /*
@@ -187,37 +160,9 @@ static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
 
 static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
 {
-    /*
-     * Force a reset of the XIVE backend after migration. The machine
-     * defaults to XICS at startup.
-     */
-    if (spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT)) {
-        if (kvm_irqchip_in_kernel()) {
-            xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
-        }
-        spapr_irq_xive.reset(spapr, &error_fatal);
-    }
-
     return spapr_irq_current(spapr)->post_load(spapr, version_id);
 }
 
-static void spapr_irq_reset_dual(SpaprMachineState *spapr, Error **errp)
-{
-    /*
-     * Deactivate the XIVE MMIOs. The XIVE backend will reenable them
-     * if selected.
-     */
-    spapr_xive_mmio_set_enabled(spapr->xive, false);
-
-    /* Destroy all KVM devices */
-    if (kvm_irqchip_in_kernel()) {
-        xics_kvm_disconnect(SPAPR_INTC(spapr->ics));
-        kvmppc_xive_disconnect(SPAPR_INTC(spapr->xive));
-    }
-
-    spapr_irq_current(spapr)->reset(spapr, errp);
-}
-
 /*
  * Define values in sync with the XIVE and XICS backend
  */
@@ -228,7 +173,6 @@ SpaprIrq spapr_irq_dual = {
     .xive        = true,
 
     .post_load   = spapr_irq_post_load_dual,
-    .reset       = spapr_irq_reset_dual,
 };
 
 
@@ -512,10 +456,6 @@ void spapr_irq_reset(SpaprMachineState *spapr, Error **errp)
     assert(!spapr->irq_map || bitmap_empty(spapr->irq_map, spapr->irq_map_nr));
 
     spapr_irq_update_active_intc(spapr);
-
-    if (spapr->irq->reset) {
-        spapr->irq->reset(spapr, errp);
-    }
 }
 
 int spapr_irq_get_phandle(SpaprMachineState *spapr, void *fdt, Error **errp)
@@ -651,7 +591,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .xive        = false,
 
     .post_load   = spapr_irq_post_load_xics,
-    .reset       = spapr_irq_reset_xics,
 };
 
 static void spapr_irq_register_types(void)
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 06179b271f..e02e44624b 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -84,7 +84,6 @@ typedef struct SpaprIrq {
     bool        xive;
 
     int (*post_load)(SpaprMachineState *spapr, int version_id);
-    void (*reset)(SpaprMachineState *spapr, Error **errp);
 } SpaprIrq;
 
 extern SpaprIrq spapr_irq_xics;
@@ -99,6 +98,9 @@ qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq);
 int spapr_irq_post_load(SpaprMachineState *spapr, int version_id);
 void spapr_irq_reset(SpaprMachineState *spapr, Error **errp);
 int spapr_irq_get_phandle(SpaprMachineState *spapr, void *fdt, Error **errp);
+int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
+                       SpaprInterruptController *intc,
+                       Error **errp);
 
 /*
  * XICS legacy routines
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 17/28] spapr, xics, xive: Move SpaprIrq::post_load hook to backends
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (15 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 16/28] spapr, xics, xive: Move SpaprIrq::reset hook logic into activate/deactivate David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 18/28] spapr: Remove SpaprIrq::nr_msis David Gibson
                   ` (11 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

The remaining logic in the post_load hook really belongs to the interrupt
controller backends, and just needs to be called on the active controller
(after the active controller is set to the right thing based on the
incoming migration in the generic spapr_irq_post_load() logic).

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/intc/spapr_xive.c        |  5 +++--
 hw/intc/xics_spapr.c        | 13 +++++++++++
 hw/ppc/spapr_irq.c          | 45 ++++---------------------------------
 include/hw/ppc/spapr_irq.h  |  3 +--
 include/hw/ppc/spapr_xive.h |  1 -
 5 files changed, 21 insertions(+), 46 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 1811653aac..ba32d2cc5b 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -462,10 +462,10 @@ static int vmstate_spapr_xive_pre_save(void *opaque)
  * Called by the sPAPR IRQ backend 'post_load' method at the machine
  * level.
  */
-int spapr_xive_post_load(SpaprXive *xive, int version_id)
+static int spapr_xive_post_load(SpaprInterruptController *intc, int version_id)
 {
     if (kvm_irqchip_in_kernel()) {
-        return kvmppc_xive_post_load(xive, version_id);
+        return kvmppc_xive_post_load(SPAPR_XIVE(intc), version_id);
     }
 
     return 0;
@@ -702,6 +702,7 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     sicc->set_irq = spapr_xive_set_irq;
     sicc->print_info = spapr_xive_print_info;
     sicc->dt = spapr_xive_dt;
+    sicc->post_load = spapr_xive_post_load;
 }
 
 static const TypeInfo spapr_xive_info = {
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 90b4d48877..4f64b9a9fc 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -395,6 +395,18 @@ static void xics_spapr_print_info(SpaprInterruptController *intc, Monitor *mon)
     ics_pic_print_info(ics, mon);
 }
 
+static int xics_spapr_post_load(SpaprInterruptController *intc, int version_id)
+{
+    if (!kvm_irqchip_in_kernel()) {
+        CPUState *cs;
+        CPU_FOREACH(cs) {
+            PowerPCCPU *cpu = POWERPC_CPU(cs);
+            icp_resend(spapr_cpu_state(cpu)->icp);
+        }
+    }
+    return 0;
+}
+
 static int xics_spapr_activate(SpaprInterruptController *intc, Error **errp)
 {
     if (kvm_enabled()) {
@@ -426,6 +438,7 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     sicc->set_irq = xics_spapr_set_irq;
     sicc->print_info = xics_spapr_print_info;
     sicc->dt = xics_spapr_dt;
+    sicc->post_load = xics_spapr_post_load;
 }
 
 static const TypeInfo ics_spapr_info = {
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index f70b331f44..f3d18b1dad 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -100,43 +100,22 @@ int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
  * XICS IRQ backend.
  */
 
-static int spapr_irq_post_load_xics(SpaprMachineState *spapr, int version_id)
-{
-    if (!kvm_irqchip_in_kernel()) {
-        CPUState *cs;
-        CPU_FOREACH(cs) {
-            PowerPCCPU *cpu = POWERPC_CPU(cs);
-            icp_resend(spapr_cpu_state(cpu)->icp);
-        }
-    }
-    return 0;
-}
-
 SpaprIrq spapr_irq_xics = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
     .nr_msis     = SPAPR_NR_MSIS,
     .xics        = true,
     .xive        = false,
-
-    .post_load   = spapr_irq_post_load_xics,
 };
 
 /*
  * XIVE IRQ backend.
  */
 
-static int spapr_irq_post_load_xive(SpaprMachineState *spapr, int version_id)
-{
-    return spapr_xive_post_load(spapr->xive, version_id);
-}
-
 SpaprIrq spapr_irq_xive = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
     .nr_msis     = SPAPR_NR_MSIS,
     .xics        = false,
     .xive        = true,
-
-    .post_load   = spapr_irq_post_load_xive,
 };
 
 /*
@@ -148,21 +127,6 @@ SpaprIrq spapr_irq_xive = {
  * activated after an extra machine reset.
  */
 
-/*
- * Returns the sPAPR IRQ backend negotiated by CAS. XICS is the
- * default.
- */
-static SpaprIrq *spapr_irq_current(SpaprMachineState *spapr)
-{
-    return spapr_ovec_test(spapr->ov5_cas, OV5_XIVE_EXPLOIT) ?
-        &spapr_irq_xive : &spapr_irq_xics;
-}
-
-static int spapr_irq_post_load_dual(SpaprMachineState *spapr, int version_id)
-{
-    return spapr_irq_current(spapr)->post_load(spapr, version_id);
-}
-
 /*
  * Define values in sync with the XIVE and XICS backend
  */
@@ -171,8 +135,6 @@ SpaprIrq spapr_irq_dual = {
     .nr_msis     = SPAPR_NR_MSIS,
     .xics        = true,
     .xive        = true,
-
-    .post_load   = spapr_irq_post_load_dual,
 };
 
 
@@ -447,8 +409,11 @@ qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
 
 int spapr_irq_post_load(SpaprMachineState *spapr, int version_id)
 {
+    SpaprInterruptControllerClass *sicc;
+
     spapr_irq_update_active_intc(spapr);
-    return spapr->irq->post_load(spapr, version_id);
+    sicc = SPAPR_INTC_GET_CLASS(spapr->active_intc);
+    return sicc->post_load(spapr->active_intc, version_id);
 }
 
 void spapr_irq_reset(SpaprMachineState *spapr, Error **errp)
@@ -589,8 +554,6 @@ SpaprIrq spapr_irq_xics_legacy = {
     .nr_msis     = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
     .xics        = true,
     .xive        = false,
-
-    .post_load   = spapr_irq_post_load_xics,
 };
 
 static void spapr_irq_register_types(void)
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index e02e44624b..08173e714c 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -62,6 +62,7 @@ typedef struct SpaprInterruptControllerClass {
     void (*print_info)(SpaprInterruptController *intc, Monitor *mon);
     void (*dt)(SpaprInterruptController *intc, uint32_t nr_servers,
                void *fdt, uint32_t phandle);
+    int (*post_load)(SpaprInterruptController *intc, int version_id);
 } SpaprInterruptControllerClass;
 
 void spapr_irq_update_active_intc(SpaprMachineState *spapr);
@@ -82,8 +83,6 @@ typedef struct SpaprIrq {
     uint32_t    nr_msis;
     bool        xics;
     bool        xive;
-
-    int (*post_load)(SpaprMachineState *spapr, int version_id);
 } SpaprIrq;
 
 extern SpaprIrq spapr_irq_xics;
diff --git a/include/hw/ppc/spapr_xive.h b/include/hw/ppc/spapr_xive.h
index 64972754f9..d84bd5c229 100644
--- a/include/hw/ppc/spapr_xive.h
+++ b/include/hw/ppc/spapr_xive.h
@@ -55,7 +55,6 @@ typedef struct SpaprXive {
 #define SPAPR_XIVE_BLOCK_ID 0x0
 
 void spapr_xive_pic_print_info(SpaprXive *xive, Monitor *mon);
-int spapr_xive_post_load(SpaprXive *xive, int version_id);
 
 void spapr_xive_hcall_init(SpaprMachineState *spapr);
 void spapr_xive_set_tctx_os_cam(XiveTCTX *tctx);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 18/28] spapr: Remove SpaprIrq::nr_msis
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (16 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 17/28] spapr, xics, xive: Move SpaprIrq::post_load hook to backends David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 19/28] spapr: Move SpaprIrq::nr_xirqs to SpaprMachineClass David Gibson
                   ` (10 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

The nr_msis value we use here has to line up with whether we're using
legacy or modern irq allocation.  Therefore it's safer to derive it based
on legacy_irq_allocation rather than having SpaprIrq contain a canned
value.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/ppc/spapr.c              |  5 ++---
 hw/ppc/spapr_irq.c          | 26 +++++++++++++++++---------
 hw/ppc/spapr_pci.c          |  7 ++++---
 include/hw/pci-host/spapr.h |  4 ++--
 include/hw/ppc/spapr_irq.h  |  4 +---
 5 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index c9623600c2..99867b5e6d 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -1267,7 +1267,7 @@ static void *spapr_build_fdt(SpaprMachineState *spapr)
     }
 
     QLIST_FOREACH(phb, &spapr->phbs, list) {
-        ret = spapr_dt_phb(phb, PHANDLE_INTC, fdt, spapr->irq->nr_msis, NULL);
+        ret = spapr_dt_phb(spapr, phb, PHANDLE_INTC, fdt, NULL);
         if (ret < 0) {
             error_report("couldn't setup PCI devices in fdt");
             exit(1);
@@ -3905,8 +3905,7 @@ int spapr_phb_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
         return -1;
     }
 
-    if (spapr_dt_phb(sphb, intc_phandle, fdt, spapr->irq->nr_msis,
-                     fdt_start_offset)) {
+    if (spapr_dt_phb(spapr, sphb, intc_phandle, fdt, fdt_start_offset)) {
         error_setg(errp, "unable to create FDT node for PHB %d", sphb->index);
         return -1;
     }
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index f3d18b1dad..be90d36333 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -29,9 +29,14 @@ static const TypeInfo spapr_intc_info = {
     .class_size = sizeof(SpaprInterruptControllerClass),
 };
 
-void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis)
+static void spapr_irq_msi_init(SpaprMachineState *spapr)
 {
-    spapr->irq_map_nr = nr_msis;
+    if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
+        /* Legacy mode doesn't use this allocator */
+        return;
+    }
+
+    spapr->irq_map_nr = spapr_irq_nr_msis(spapr);
     spapr->irq_map = bitmap_new(spapr->irq_map_nr);
 }
 
@@ -102,7 +107,6 @@ int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
 
 SpaprIrq spapr_irq_xics = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
-    .nr_msis     = SPAPR_NR_MSIS,
     .xics        = true,
     .xive        = false,
 };
@@ -113,7 +117,6 @@ SpaprIrq spapr_irq_xics = {
 
 SpaprIrq spapr_irq_xive = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
-    .nr_msis     = SPAPR_NR_MSIS,
     .xics        = false,
     .xive        = true,
 };
@@ -132,7 +135,6 @@ SpaprIrq spapr_irq_xive = {
  */
 SpaprIrq spapr_irq_dual = {
     .nr_xirqs    = SPAPR_NR_XIRQS,
-    .nr_msis     = SPAPR_NR_MSIS,
     .xics        = true,
     .xive        = true,
 };
@@ -247,6 +249,15 @@ void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
     sicc->dt(spapr->active_intc, nr_servers, fdt, phandle);
 }
 
+uint32_t spapr_irq_nr_msis(SpaprMachineState *spapr)
+{
+    if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
+        return spapr->irq->nr_xirqs;
+    } else {
+        return SPAPR_XIRQ_BASE + spapr->irq->nr_xirqs - SPAPR_IRQ_MSI;
+    }
+}
+
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
@@ -267,9 +278,7 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
     }
 
     /* Initialize the MSI IRQ allocator. */
-    if (!SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
-        spapr_irq_msi_init(spapr, spapr->irq->nr_msis);
-    }
+    spapr_irq_msi_init(spapr);
 
     if (spapr->irq->xics) {
         Error *local_err = NULL;
@@ -551,7 +560,6 @@ int spapr_irq_find(SpaprMachineState *spapr, int num, bool align, Error **errp)
 
 SpaprIrq spapr_irq_xics_legacy = {
     .nr_xirqs    = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
-    .nr_msis     = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
     .xics        = true,
     .xive        = false,
 };
diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c
index 01ff41d4c4..cc0e7829b6 100644
--- a/hw/ppc/spapr_pci.c
+++ b/hw/ppc/spapr_pci.c
@@ -2277,8 +2277,8 @@ static void spapr_phb_pci_enumerate(SpaprPhbState *phb)
 
 }
 
-int spapr_dt_phb(SpaprPhbState *phb, uint32_t intc_phandle, void *fdt,
-                 uint32_t nr_msis, int *node_offset)
+int spapr_dt_phb(SpaprMachineState *spapr, SpaprPhbState *phb,
+                 uint32_t intc_phandle, void *fdt, int *node_offset)
 {
     int bus_off, i, j, ret;
     uint32_t bus_range[] = { cpu_to_be32(0), cpu_to_be32(0xff) };
@@ -2343,7 +2343,8 @@ int spapr_dt_phb(SpaprPhbState *phb, uint32_t intc_phandle, void *fdt,
     _FDT(fdt_setprop(fdt, bus_off, "ranges", &ranges, sizeof_ranges));
     _FDT(fdt_setprop(fdt, bus_off, "reg", &bus_reg, sizeof(bus_reg)));
     _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pci-config-space-type", 0x1));
-    _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pe-total-#msi", nr_msis));
+    _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pe-total-#msi",
+                          spapr_irq_nr_msis(spapr)));
 
     /* Dynamic DMA window */
     if (phb->ddw_enabled) {
diff --git a/include/hw/pci-host/spapr.h b/include/hw/pci-host/spapr.h
index 23506f05d9..8877ff51fb 100644
--- a/include/hw/pci-host/spapr.h
+++ b/include/hw/pci-host/spapr.h
@@ -128,8 +128,8 @@ struct SpaprPhbState {
 #define SPAPR_PCI_NV2ATSD_WIN_SIZE   (NVGPU_MAX_NUM * NVGPU_MAX_LINKS * \
                                       64 * KiB)
 
-int spapr_dt_phb(SpaprPhbState *phb, uint32_t intc_phandle, void *fdt,
-                 uint32_t nr_msis, int *node_offset);
+int spapr_dt_phb(SpaprMachineState *spapr, SpaprPhbState *phb,
+                 uint32_t intc_phandle, void *fdt, int *node_offset);
 
 void spapr_pci_rtas_init(void);
 
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 08173e714c..befe8e01dc 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -27,7 +27,6 @@
 #define SPAPR_IRQ_MSI        (SPAPR_XIRQ_BASE + 0x0300)
 
 #define SPAPR_NR_XIRQS       0x1000
-#define SPAPR_NR_MSIS        (SPAPR_XIRQ_BASE + SPAPR_NR_XIRQS - SPAPR_IRQ_MSI)
 
 typedef struct SpaprMachineState SpaprMachineState;
 
@@ -73,14 +72,13 @@ void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon);
 void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
                   void *fdt, uint32_t phandle);
 
-void spapr_irq_msi_init(SpaprMachineState *spapr, uint32_t nr_msis);
+uint32_t spapr_irq_nr_msis(SpaprMachineState *spapr);
 int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
                         Error **errp);
 void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num);
 
 typedef struct SpaprIrq {
     uint32_t    nr_xirqs;
-    uint32_t    nr_msis;
     bool        xics;
     bool        xive;
 } SpaprIrq;
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 19/28] spapr: Move SpaprIrq::nr_xirqs to SpaprMachineClass
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (17 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 18/28] spapr: Remove SpaprIrq::nr_msis David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 20/28] pseries: Update SLOF firmware image David Gibson
                   ` (9 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

For the benefit of peripheral device allocation, the number of available
irqs really wants to be the same on a given machine type version,
regardless of what irq backends we are using.  That's the case now, but
only because we make sure the different SpaprIrq instances have the same
value except for the special legacy one.

Since this really only depends on machine type version, move the value to
SpaprMachineClass instead of SpaprIrq.  This also puts the code to set it
to the lower value on old machine types right next to setting
legacy_irq_allocation, which needs to go hand in hand.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
 hw/ppc/spapr.c             |  2 ++
 hw/ppc/spapr_irq.c         | 33 ++++++++++++++++-----------------
 include/hw/ppc/spapr.h     |  1 +
 include/hw/ppc/spapr_irq.h |  1 -
 4 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index 99867b5e6d..f9410d390a 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -4440,6 +4440,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
     smc->dr_phb_enabled = true;
     smc->linux_pci_probe = true;
     smc->smp_threads_vsmt = true;
+    smc->nr_xirqs = SPAPR_NR_XIRQS;
 }
 
 static const TypeInfo spapr_machine_info = {
@@ -4576,6 +4577,7 @@ static void spapr_machine_3_0_class_options(MachineClass *mc)
     compat_props_add(mc->compat_props, hw_compat_3_0, hw_compat_3_0_len);
 
     smc->legacy_irq_allocation = true;
+    smc->nr_xirqs = 0x400;
     smc->irq = &spapr_irq_xics_legacy;
 }
 
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index be90d36333..234d1073e5 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -106,7 +106,6 @@ int spapr_irq_init_kvm(int (*fn)(SpaprInterruptController *, Error **),
  */
 
 SpaprIrq spapr_irq_xics = {
-    .nr_xirqs    = SPAPR_NR_XIRQS,
     .xics        = true,
     .xive        = false,
 };
@@ -116,7 +115,6 @@ SpaprIrq spapr_irq_xics = {
  */
 
 SpaprIrq spapr_irq_xive = {
-    .nr_xirqs    = SPAPR_NR_XIRQS,
     .xics        = false,
     .xive        = true,
 };
@@ -134,7 +132,6 @@ SpaprIrq spapr_irq_xive = {
  * Define values in sync with the XIVE and XICS backend
  */
 SpaprIrq spapr_irq_dual = {
-    .nr_xirqs    = SPAPR_NR_XIRQS,
     .xics        = true,
     .xive        = true,
 };
@@ -251,16 +248,19 @@ void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
 
 uint32_t spapr_irq_nr_msis(SpaprMachineState *spapr)
 {
-    if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
-        return spapr->irq->nr_xirqs;
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
+
+    if (smc->legacy_irq_allocation) {
+        return smc->nr_xirqs;
     } else {
-        return SPAPR_XIRQ_BASE + spapr->irq->nr_xirqs - SPAPR_IRQ_MSI;
+        return SPAPR_XIRQ_BASE + smc->nr_xirqs - SPAPR_IRQ_MSI;
     }
 }
 
 void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
 {
     MachineState *machine = MACHINE(spapr);
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
 
     if (machine_kernel_irqchip_split(machine)) {
         error_setg(errp, "kernel_irqchip split mode not supported on pseries");
@@ -298,8 +298,7 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
             return;
         }
 
-        object_property_set_int(obj, spapr->irq->nr_xirqs, "nr-irqs",
-                                &local_err);
+        object_property_set_int(obj, smc->nr_xirqs, "nr-irqs", &local_err);
         if (local_err) {
             error_propagate(errp, local_err);
             return;
@@ -320,8 +319,7 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
         int i;
 
         dev = qdev_create(NULL, TYPE_SPAPR_XIVE);
-        qdev_prop_set_uint32(dev, "nr-irqs",
-                             spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE);
+        qdev_prop_set_uint32(dev, "nr-irqs", smc->nr_xirqs + SPAPR_XIRQ_BASE);
         /*
          * 8 XIVE END structures per CPU. One for each available
          * priority
@@ -346,17 +344,18 @@ void spapr_irq_init(SpaprMachineState *spapr, Error **errp)
     }
 
     spapr->qirqs = qemu_allocate_irqs(spapr_set_irq, spapr,
-                                      spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE);
+                                      smc->nr_xirqs + SPAPR_XIRQ_BASE);
 }
 
 int spapr_irq_claim(SpaprMachineState *spapr, int irq, bool lsi, Error **errp)
 {
     SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
     int i;
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
     int rc;
 
     assert(irq >= SPAPR_XIRQ_BASE);
-    assert(irq < (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
+    assert(irq < (smc->nr_xirqs + SPAPR_XIRQ_BASE));
 
     for (i = 0; i < ARRAY_SIZE(intcs); i++) {
         SpaprInterruptController *intc = intcs[i];
@@ -376,9 +375,10 @@ void spapr_irq_free(SpaprMachineState *spapr, int irq, int num)
 {
     SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
     int i, j;
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
 
     assert(irq >= SPAPR_XIRQ_BASE);
-    assert((irq + num) <= (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
+    assert((irq + num) <= (smc->nr_xirqs + SPAPR_XIRQ_BASE));
 
     for (i = irq; i < (irq + num); i++) {
         for (j = 0; j < ARRAY_SIZE(intcs); j++) {
@@ -395,6 +395,8 @@ void spapr_irq_free(SpaprMachineState *spapr, int irq, int num)
 
 qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
 {
+    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
+
     /*
      * This interface is basically for VIO and PHB devices to find the
      * right qemu_irq to manipulate, so we only allow access to the
@@ -403,7 +405,7 @@ qemu_irq spapr_qirq(SpaprMachineState *spapr, int irq)
      * interfaces, we can change this if we need to in future.
      */
     assert(irq >= SPAPR_XIRQ_BASE);
-    assert(irq < (spapr->irq->nr_xirqs + SPAPR_XIRQ_BASE));
+    assert(irq < (smc->nr_xirqs + SPAPR_XIRQ_BASE));
 
     if (spapr->ics) {
         assert(ics_valid_irq(spapr->ics, irq));
@@ -556,10 +558,7 @@ int spapr_irq_find(SpaprMachineState *spapr, int num, bool align, Error **errp)
     return first + ics->offset;
 }
 
-#define SPAPR_IRQ_XICS_LEGACY_NR_XIRQS     0x400
-
 SpaprIrq spapr_irq_xics_legacy = {
-    .nr_xirqs    = SPAPR_IRQ_XICS_LEGACY_NR_XIRQS,
     .xics        = true,
     .xive        = false,
 };
diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
index 3b34cf5207..d5ab5ea7b2 100644
--- a/include/hw/ppc/spapr.h
+++ b/include/hw/ppc/spapr.h
@@ -119,6 +119,7 @@ struct SpaprMachineClass {
     bool use_ohci_by_default;  /* use USB-OHCI instead of XHCI */
     bool pre_2_10_has_unused_icps;
     bool legacy_irq_allocation;
+    uint32_t nr_xirqs;
     bool broken_host_serial_model; /* present real host info to the guest */
     bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
     bool linux_pci_probe;
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index befe8e01dc..5e150a6679 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -78,7 +78,6 @@ int spapr_irq_msi_alloc(SpaprMachineState *spapr, uint32_t num, bool align,
 void spapr_irq_msi_free(SpaprMachineState *spapr, int irq, uint32_t num);
 
 typedef struct SpaprIrq {
-    uint32_t    nr_xirqs;
     bool        xics;
     bool        xive;
 } SpaprIrq;
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 20/28] pseries: Update SLOF firmware image
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (18 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 19/28] spapr: Move SpaprIrq::nr_xirqs to SpaprMachineClass David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 21/28] spapr: Don't request to unplug the same core twice David Gibson
                   ` (8 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, Alexey Kardashevskiy, qemu-devel, groug, qemu-ppc, clg,
	David Gibson

From: Alexey Kardashevskiy <aik@ozlabs.ru>

This aims v4.2 and fixes:
1. full FDT rendering;
2. gcc9 -Waddress-of-packed-member.

Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 pc-bios/README   |   2 +-
 pc-bios/slof.bin | Bin 930640 -> 928552 bytes
 roms/SLOF        |   2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pc-bios/README b/pc-bios/README
index 0b0b5d42ad..830645c51f 100644
--- a/pc-bios/README
+++ b/pc-bios/README
@@ -17,7 +17,7 @@
 - SLOF (Slimline Open Firmware) is a free IEEE 1275 Open Firmware
   implementation for certain IBM POWER hardware.  The sources are at
   https://github.com/aik/SLOF, and the image currently in qemu is
-  built from git tag qemu-slof-20190911.
+  built from git tag qemu-slof-20191022.
 
 - sgabios (the Serial Graphics Adapter option ROM) provides a means for
   legacy x86 software to communicate with an attached serial console as
diff --git a/pc-bios/slof.bin b/pc-bios/slof.bin
index 2af0c5d5fc0c6aa06c34016f6deb767700ad4d3f..0b93fe8c011fc352803dc24e3110b7f926493769 100644
GIT binary patch
delta 118274
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
Y!gOEP_L;}Kw$J*}Z>Im?>WAn2KMr!Q;Q#;t

delta 124758
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
IVLO}uAMh!0ng9R*

diff --git a/roms/SLOF b/roms/SLOF
index bcc3c4e5c2..899d988365 160000
--- a/roms/SLOF
+++ b/roms/SLOF
@@ -1 +1 @@
-Subproject commit bcc3c4e5c21a015f4680894c4ec978a90d4a2d69
+Subproject commit 899d98836513bb3d6a4f4e48ef7cee887ee5f57b
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 21/28] spapr: Don't request to unplug the same core twice
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (19 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 20/28] pseries: Update SLOF firmware image David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 22/28] spapr: move CPU reset after presenter creation David Gibson
                   ` (7 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Greg Kurz <groug@kaod.org>

We must not call spapr_drc_detach() on a detached DRC otherwise bad things
can happen, ie. QEMU hangs or crashes. This is easily demonstrated with
a CPU hotplug/unplug loop using QMP.

Signed-off-by: Greg Kurz <groug@kaod.org>
Message-Id: <157185826035.3073024.1664101000438499392.stgit@bahia.lan>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/spapr.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index f9410d390a..94f9d27096 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -3741,9 +3741,10 @@ void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev,
                           spapr_vcpu_id(spapr, cc->core_id));
     g_assert(drc);
 
-    spapr_drc_detach(drc);
-
-    spapr_hotplug_req_remove_by_index(drc);
+    if (!spapr_drc_unplug_requested(drc)) {
+        spapr_drc_detach(drc);
+        spapr_hotplug_req_remove_by_index(drc);
+    }
 }
 
 int spapr_core_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 22/28] spapr: move CPU reset after presenter creation
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (20 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 21/28] spapr: Don't request to unplug the same core twice David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 23/28] spapr_cpu_core: Implement DeviceClass::reset David Gibson
                   ` (6 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, qemu-devel, groug, qemu-ppc, clg,
	Philippe Mathieu-Daudé,
	David Gibson

From: Cédric Le Goater <clg@kaod.org>

This change prepares ground for future changes which will reset the
interrupt presenter in the reset handler of the sPAPR and PowerNV
cores.

Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
Message-Id: <20191022163812.330-2-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/spapr_cpu_core.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/hw/ppc/spapr_cpu_core.c b/hw/ppc/spapr_cpu_core.c
index 3e4302c7d5..2b21285d20 100644
--- a/hw/ppc/spapr_cpu_core.c
+++ b/hw/ppc/spapr_cpu_core.c
@@ -234,13 +234,16 @@ static void spapr_realize_vcpu(PowerPCCPU *cpu, SpaprMachineState *spapr,
     cpu_ppc_set_vhyp(cpu, PPC_VIRTUAL_HYPERVISOR(spapr));
     kvmppc_set_papr(cpu);
 
-    qemu_register_reset(spapr_cpu_reset, cpu);
-    spapr_cpu_reset(cpu);
-
     if (spapr_irq_cpu_intc_create(spapr, cpu, &local_err) < 0) {
-        goto error_unregister;
+        goto error_intc_create;
     }
 
+    /*
+     * FIXME: Hot-plugged CPUs are not reset. Do it at realize.
+     */
+    qemu_register_reset(spapr_cpu_reset, cpu);
+    spapr_cpu_reset(cpu);
+
     if (!sc->pre_3_0_migration) {
         vmstate_register(NULL, cs->cpu_index, &vmstate_spapr_cpu_state,
                          cpu->machine_data);
@@ -248,8 +251,7 @@ static void spapr_realize_vcpu(PowerPCCPU *cpu, SpaprMachineState *spapr,
 
     return;
 
-error_unregister:
-    qemu_unregister_reset(spapr_cpu_reset, cpu);
+error_intc_create:
     cpu_remove_sync(CPU(cpu));
 error:
     error_propagate(errp, local_err);
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 23/28] spapr_cpu_core: Implement DeviceClass::reset
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (21 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 22/28] spapr: move CPU reset after presenter creation David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 24/28] ppc/pnv: Introduce a PnvCore reset handler David Gibson
                   ` (5 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, qemu-devel, groug, qemu-ppc, clg,
	Philippe Mathieu-Daudé,
	David Gibson

From: Greg Kurz <groug@kaod.org>

Since vCPUs aren't plugged into a bus, we manually register a reset
handler for each vCPU. We also call this handler at realize time
to ensure hot plugged vCPUs are reset before being exposed to the
guest. This results in vCPUs being reset twice at machine reset.
It doesn't break anything but it is slightly suboptimal and above
all confusing.

The hotplug path in device_set_realized() already knows how to reset
a hotplugged device if the device reset handler is present. Implement
one for sPAPR CPU cores that resets all vCPUs under a core.

While here rename spapr_cpu_reset() to spapr_reset_vcpu() for
consistency with spapr_realize_vcpu() and spapr_unrealize_vcpu().

Signed-off-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
[clg: add documentation on the reset helper usage ]
Signed-off-by: Cédric Le Goater <clg@kaod.org>
Message-Id: <20191022163812.330-3-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/spapr_cpu_core.c | 37 ++++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/hw/ppc/spapr_cpu_core.c b/hw/ppc/spapr_cpu_core.c
index 2b21285d20..2e34832d0e 100644
--- a/hw/ppc/spapr_cpu_core.c
+++ b/hw/ppc/spapr_cpu_core.c
@@ -25,9 +25,8 @@
 #include "sysemu/hw_accel.h"
 #include "qemu/error-report.h"
 
-static void spapr_cpu_reset(void *opaque)
+static void spapr_reset_vcpu(PowerPCCPU *cpu)
 {
-    PowerPCCPU *cpu = opaque;
     CPUState *cs = CPU(cpu);
     CPUPPCState *env = &cpu->env;
     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
@@ -193,7 +192,6 @@ static void spapr_unrealize_vcpu(PowerPCCPU *cpu, SpaprCpuCore *sc)
     if (!sc->pre_3_0_migration) {
         vmstate_unregister(NULL, &vmstate_spapr_cpu_state, cpu->machine_data);
     }
-    qemu_unregister_reset(spapr_cpu_reset, cpu);
     if (spapr_cpu_state(cpu)->icp) {
         object_unparent(OBJECT(spapr_cpu_state(cpu)->icp));
     }
@@ -204,12 +202,36 @@ static void spapr_unrealize_vcpu(PowerPCCPU *cpu, SpaprCpuCore *sc)
     object_unparent(OBJECT(cpu));
 }
 
+/*
+ * Called when CPUs are hot-plugged.
+ */
+static void spapr_cpu_core_reset(DeviceState *dev)
+{
+    CPUCore *cc = CPU_CORE(dev);
+    SpaprCpuCore *sc = SPAPR_CPU_CORE(dev);
+    int i;
+
+    for (i = 0; i < cc->nr_threads; i++) {
+        spapr_reset_vcpu(sc->threads[i]);
+    }
+}
+
+/*
+ * Called by the machine reset.
+ */
+static void spapr_cpu_core_reset_handler(void *opaque)
+{
+    spapr_cpu_core_reset(opaque);
+}
+
 static void spapr_cpu_core_unrealize(DeviceState *dev, Error **errp)
 {
     SpaprCpuCore *sc = SPAPR_CPU_CORE(OBJECT(dev));
     CPUCore *cc = CPU_CORE(dev);
     int i;
 
+    qemu_unregister_reset(spapr_cpu_core_reset_handler, sc);
+
     for (i = 0; i < cc->nr_threads; i++) {
         spapr_unrealize_vcpu(sc->threads[i], sc);
     }
@@ -238,12 +260,6 @@ static void spapr_realize_vcpu(PowerPCCPU *cpu, SpaprMachineState *spapr,
         goto error_intc_create;
     }
 
-    /*
-     * FIXME: Hot-plugged CPUs are not reset. Do it at realize.
-     */
-    qemu_register_reset(spapr_cpu_reset, cpu);
-    spapr_cpu_reset(cpu);
-
     if (!sc->pre_3_0_migration) {
         vmstate_register(NULL, cs->cpu_index, &vmstate_spapr_cpu_state,
                          cpu->machine_data);
@@ -338,6 +354,8 @@ static void spapr_cpu_core_realize(DeviceState *dev, Error **errp)
             goto err_unrealize;
         }
     }
+
+    qemu_register_reset(spapr_cpu_core_reset_handler, sc);
     return;
 
 err_unrealize:
@@ -366,6 +384,7 @@ static void spapr_cpu_core_class_init(ObjectClass *oc, void *data)
 
     dc->realize = spapr_cpu_core_realize;
     dc->unrealize = spapr_cpu_core_unrealize;
+    dc->reset = spapr_cpu_core_reset;
     dc->props = spapr_cpu_core_properties;
     scc->cpu_type = data;
 }
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 24/28] ppc/pnv: Introduce a PnvCore reset handler
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (22 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 23/28] spapr_cpu_core: Implement DeviceClass::reset David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 25/28] ppc/pnv: Add a PnvChip pointer to PnvCore David Gibson
                   ` (4 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Cédric Le Goater <clg@kaod.org>

in which individual CPUs are reset. It will ease the introduction of
future change reseting the interrupt presenter from the CPU reset
handler.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20191022163812.330-4-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/pnv_core.c | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/hw/ppc/pnv_core.c b/hw/ppc/pnv_core.c
index b1a7489e7a..9f981a4940 100644
--- a/hw/ppc/pnv_core.c
+++ b/hw/ppc/pnv_core.c
@@ -40,9 +40,8 @@ static const char *pnv_core_cpu_typename(PnvCore *pc)
     return cpu_type;
 }
 
-static void pnv_cpu_reset(void *opaque)
+static void pnv_core_cpu_reset(PowerPCCPU *cpu)
 {
-    PowerPCCPU *cpu = opaque;
     CPUState *cs = CPU(cpu);
     CPUPPCState *env = &cpu->env;
 
@@ -192,8 +191,17 @@ static void pnv_realize_vcpu(PowerPCCPU *cpu, PnvChip *chip, Error **errp)
 
     /* Set time-base frequency to 512 MHz */
     cpu_ppc_tb_init(env, PNV_TIMEBASE_FREQ);
+}
+
+static void pnv_core_reset(void *dev)
+{
+    CPUCore *cc = CPU_CORE(dev);
+    PnvCore *pc = PNV_CORE(dev);
+    int i;
 
-    qemu_register_reset(pnv_cpu_reset, cpu);
+    for (i = 0; i < cc->nr_threads; i++) {
+        pnv_core_cpu_reset(pc->threads[i]);
+    }
 }
 
 static void pnv_core_realize(DeviceState *dev, Error **errp)
@@ -244,6 +252,8 @@ static void pnv_core_realize(DeviceState *dev, Error **errp)
     snprintf(name, sizeof(name), "xscom-core.%d", cc->core_id);
     pnv_xscom_region_init(&pc->xscom_regs, OBJECT(dev), pcc->xscom_ops,
                           pc, name, PNV_XSCOM_EX_SIZE);
+
+    qemu_register_reset(pnv_core_reset, pc);
     return;
 
 err:
@@ -259,7 +269,6 @@ static void pnv_unrealize_vcpu(PowerPCCPU *cpu)
 {
     PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
 
-    qemu_unregister_reset(pnv_cpu_reset, cpu);
     object_unparent(OBJECT(pnv_cpu_state(cpu)->intc));
     cpu_remove_sync(CPU(cpu));
     cpu->machine_data = NULL;
@@ -273,6 +282,8 @@ static void pnv_core_unrealize(DeviceState *dev, Error **errp)
     CPUCore *cc = CPU_CORE(dev);
     int i;
 
+    qemu_unregister_reset(pnv_core_reset, pc);
+
     for (i = 0; i < cc->nr_threads; i++) {
         pnv_unrealize_vcpu(pc->threads[i]);
     }
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 25/28] ppc/pnv: Add a PnvChip pointer to PnvCore
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (23 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 24/28] ppc/pnv: Introduce a PnvCore reset handler David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 26/28] ppc: Reset the interrupt presenter from the CPU reset handler David Gibson
                   ` (3 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, qemu-devel, groug, qemu-ppc, clg,
	Philippe Mathieu-Daudé,
	David Gibson

From: Cédric Le Goater <clg@kaod.org>

We will use it to reset the interrupt presenter from the CPU reset
handler.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20191022163812.330-5-clg@kaod.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/pnv_core.c         | 3 ++-
 include/hw/ppc/pnv_core.h | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/hw/ppc/pnv_core.c b/hw/ppc/pnv_core.c
index 9f981a4940..cc17bbfed8 100644
--- a/hw/ppc/pnv_core.c
+++ b/hw/ppc/pnv_core.c
@@ -222,6 +222,7 @@ static void pnv_core_realize(DeviceState *dev, Error **errp)
                                 "required link 'chip' not found: ");
         return;
     }
+    pc->chip = PNV_CHIP(chip);
 
     pc->threads = g_new(PowerPCCPU *, cc->nr_threads);
     for (i = 0; i < cc->nr_threads; i++) {
@@ -243,7 +244,7 @@ static void pnv_core_realize(DeviceState *dev, Error **errp)
     }
 
     for (j = 0; j < cc->nr_threads; j++) {
-        pnv_realize_vcpu(pc->threads[j], PNV_CHIP(chip), &local_err);
+        pnv_realize_vcpu(pc->threads[j], pc->chip, &local_err);
         if (local_err) {
             goto err;
         }
diff --git a/include/hw/ppc/pnv_core.h b/include/hw/ppc/pnv_core.h
index bfbd2ec42a..55eee95104 100644
--- a/include/hw/ppc/pnv_core.h
+++ b/include/hw/ppc/pnv_core.h
@@ -31,6 +31,8 @@
 #define PNV_CORE_GET_CLASS(obj) \
      OBJECT_GET_CLASS(PnvCoreClass, (obj), TYPE_PNV_CORE)
 
+typedef struct PnvChip PnvChip;
+
 typedef struct PnvCore {
     /*< private >*/
     CPUCore parent_obj;
@@ -38,6 +40,7 @@ typedef struct PnvCore {
     /*< public >*/
     PowerPCCPU **threads;
     uint32_t pir;
+    PnvChip *chip;
 
     MemoryRegion xscom_regs;
 } PnvCore;
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 26/28] ppc: Reset the interrupt presenter from the CPU reset handler
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (24 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 25/28] ppc/pnv: Add a PnvChip pointer to PnvCore David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 27/28] ppc/pnv: Fix naming of routines realizing the CPUs David Gibson
                   ` (2 subsequent siblings)
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, qemu-devel, groug, qemu-ppc, clg,
	Philippe Mathieu-Daudé,
	David Gibson

From: Cédric Le Goater <clg@kaod.org>

On the sPAPR machine and PowerNV machine, the interrupt presenters are
created by a machine handler at the core level and are reset
independently. This is not consistent and it raises issues when it
comes to handle hot-plugged CPUs. In that case, the presenters are not
reset. This is less of an issue in XICS, although a zero MFFR could
be a concern, but in XIVE, the OS CAM line is not set and this breaks
the presenting algorithm. The current code has workarounds which need
a global cleanup.

Extend the sPAPR IRQ backend and the PowerNV Chip class with a new
cpu_intc_reset() handler called by the CPU reset handler and remove
the XiveTCTX reset handler which is now redundant.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Message-Id: <20191022163812.330-6-clg@kaod.org>
Reviewed-by: Greg Kurz <groug@kaod.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/intc/spapr_xive.c       |  9 +++++++++
 hw/intc/xics.c             |  8 ++------
 hw/intc/xics_spapr.c       |  7 +++++++
 hw/intc/xive.c             | 12 +-----------
 hw/ppc/pnv.c               | 18 ++++++++++++++++++
 hw/ppc/pnv_core.c          |  7 +++++--
 hw/ppc/spapr_cpu_core.c    |  5 ++++-
 hw/ppc/spapr_irq.c         | 14 ++++++++++++++
 include/hw/ppc/pnv.h       |  1 +
 include/hw/ppc/spapr_irq.h |  2 ++
 include/hw/ppc/xics.h      |  1 +
 include/hw/ppc/xive.h      |  1 +
 12 files changed, 65 insertions(+), 20 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index ba32d2cc5b..20a8d8285f 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -553,6 +553,14 @@ static int spapr_xive_cpu_intc_create(SpaprInterruptController *intc,
     return 0;
 }
 
+static void spapr_xive_cpu_intc_reset(SpaprInterruptController *intc,
+                                     PowerPCCPU *cpu)
+{
+    XiveTCTX *tctx = spapr_cpu_state(cpu)->tctx;
+
+    xive_tctx_reset(tctx);
+}
+
 static void spapr_xive_set_irq(SpaprInterruptController *intc, int irq, int val)
 {
     SpaprXive *xive = SPAPR_XIVE(intc);
@@ -697,6 +705,7 @@ static void spapr_xive_class_init(ObjectClass *klass, void *data)
     sicc->activate = spapr_xive_activate;
     sicc->deactivate = spapr_xive_deactivate;
     sicc->cpu_intc_create = spapr_xive_cpu_intc_create;
+    sicc->cpu_intc_reset = spapr_xive_cpu_intc_reset;
     sicc->claim_irq = spapr_xive_claim_irq;
     sicc->free_irq = spapr_xive_free_irq;
     sicc->set_irq = spapr_xive_set_irq;
diff --git a/hw/intc/xics.c b/hw/intc/xics.c
index b5ac408f7b..6da05763f9 100644
--- a/hw/intc/xics.c
+++ b/hw/intc/xics.c
@@ -274,10 +274,8 @@ static const VMStateDescription vmstate_icp_server = {
     },
 };
 
-static void icp_reset_handler(void *dev)
+void icp_reset(ICPState *icp)
 {
-    ICPState *icp = ICP(dev);
-
     icp->xirr = 0;
     icp->pending_priority = 0xff;
     icp->mfrr = 0xff;
@@ -288,7 +286,7 @@ static void icp_reset_handler(void *dev)
     if (kvm_irqchip_in_kernel()) {
         Error *local_err = NULL;
 
-        icp_set_kvm_state(ICP(dev), &local_err);
+        icp_set_kvm_state(icp, &local_err);
         if (local_err) {
             error_report_err(local_err);
         }
@@ -351,7 +349,6 @@ static void icp_realize(DeviceState *dev, Error **errp)
         }
     }
 
-    qemu_register_reset(icp_reset_handler, dev);
     vmstate_register(NULL, icp->cs->cpu_index, &vmstate_icp_server, icp);
 }
 
@@ -360,7 +357,6 @@ static void icp_unrealize(DeviceState *dev, Error **errp)
     ICPState *icp = ICP(dev);
 
     vmstate_unregister(NULL, &vmstate_icp_server, icp);
-    qemu_unregister_reset(icp_reset_handler, dev);
 }
 
 static void icp_class_init(ObjectClass *klass, void *data)
diff --git a/hw/intc/xics_spapr.c b/hw/intc/xics_spapr.c
index 4f64b9a9fc..7418fb9f37 100644
--- a/hw/intc/xics_spapr.c
+++ b/hw/intc/xics_spapr.c
@@ -346,6 +346,12 @@ static int xics_spapr_cpu_intc_create(SpaprInterruptController *intc,
     return 0;
 }
 
+static void xics_spapr_cpu_intc_reset(SpaprInterruptController *intc,
+                                     PowerPCCPU *cpu)
+{
+    icp_reset(spapr_cpu_state(cpu)->icp);
+}
+
 static int xics_spapr_claim_irq(SpaprInterruptController *intc, int irq,
                                 bool lsi, Error **errp)
 {
@@ -433,6 +439,7 @@ static void ics_spapr_class_init(ObjectClass *klass, void *data)
     sicc->activate = xics_spapr_activate;
     sicc->deactivate = xics_spapr_deactivate;
     sicc->cpu_intc_create = xics_spapr_cpu_intc_create;
+    sicc->cpu_intc_reset = xics_spapr_cpu_intc_reset;
     sicc->claim_irq = xics_spapr_claim_irq;
     sicc->free_irq = xics_spapr_free_irq;
     sicc->set_irq = xics_spapr_set_irq;
diff --git a/hw/intc/xive.c b/hw/intc/xive.c
index d420c6571e..f066be5eb5 100644
--- a/hw/intc/xive.c
+++ b/hw/intc/xive.c
@@ -547,10 +547,8 @@ void xive_tctx_pic_print_info(XiveTCTX *tctx, Monitor *mon)
     }
 }
 
-static void xive_tctx_reset(void *dev)
+void xive_tctx_reset(XiveTCTX *tctx)
 {
-    XiveTCTX *tctx = XIVE_TCTX(dev);
-
     memset(tctx->regs, 0, sizeof(tctx->regs));
 
     /* Set some defaults */
@@ -607,13 +605,6 @@ static void xive_tctx_realize(DeviceState *dev, Error **errp)
             return;
         }
     }
-
-    qemu_register_reset(xive_tctx_reset, dev);
-}
-
-static void xive_tctx_unrealize(DeviceState *dev, Error **errp)
-{
-    qemu_unregister_reset(xive_tctx_reset, dev);
 }
 
 static int vmstate_xive_tctx_pre_save(void *opaque)
@@ -668,7 +659,6 @@ static void xive_tctx_class_init(ObjectClass *klass, void *data)
 
     dc->desc = "XIVE Interrupt Thread Context";
     dc->realize = xive_tctx_realize;
-    dc->unrealize = xive_tctx_unrealize;
     dc->vmsd = &vmstate_xive_tctx;
     /*
      * Reason: part of XIVE interrupt controller, needs to be wired up
diff --git a/hw/ppc/pnv.c b/hw/ppc/pnv.c
index 7cf64b6d25..4a51fb65a8 100644
--- a/hw/ppc/pnv.c
+++ b/hw/ppc/pnv.c
@@ -778,6 +778,13 @@ static void pnv_chip_power8_intc_create(PnvChip *chip, PowerPCCPU *cpu,
     pnv_cpu->intc = obj;
 }
 
+static void pnv_chip_power8_intc_reset(PnvChip *chip, PowerPCCPU *cpu)
+{
+    PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
+
+    icp_reset(ICP(pnv_cpu->intc));
+}
+
 /*
  *    0:48  Reserved - Read as zeroes
  *   49:52  Node ID
@@ -815,6 +822,13 @@ static void pnv_chip_power9_intc_create(PnvChip *chip, PowerPCCPU *cpu,
     pnv_cpu->intc = obj;
 }
 
+static void pnv_chip_power9_intc_reset(PnvChip *chip, PowerPCCPU *cpu)
+{
+    PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
+
+    xive_tctx_reset(XIVE_TCTX(pnv_cpu->intc));
+}
+
 /*
  * Allowed core identifiers on a POWER8 Processor Chip :
  *
@@ -984,6 +998,7 @@ static void pnv_chip_power8e_class_init(ObjectClass *klass, void *data)
     k->cores_mask = POWER8E_CORE_MASK;
     k->core_pir = pnv_chip_core_pir_p8;
     k->intc_create = pnv_chip_power8_intc_create;
+    k->intc_reset = pnv_chip_power8_intc_reset;
     k->isa_create = pnv_chip_power8_isa_create;
     k->dt_populate = pnv_chip_power8_dt_populate;
     k->pic_print_info = pnv_chip_power8_pic_print_info;
@@ -1003,6 +1018,7 @@ static void pnv_chip_power8_class_init(ObjectClass *klass, void *data)
     k->cores_mask = POWER8_CORE_MASK;
     k->core_pir = pnv_chip_core_pir_p8;
     k->intc_create = pnv_chip_power8_intc_create;
+    k->intc_reset = pnv_chip_power8_intc_reset;
     k->isa_create = pnv_chip_power8_isa_create;
     k->dt_populate = pnv_chip_power8_dt_populate;
     k->pic_print_info = pnv_chip_power8_pic_print_info;
@@ -1022,6 +1038,7 @@ static void pnv_chip_power8nvl_class_init(ObjectClass *klass, void *data)
     k->cores_mask = POWER8_CORE_MASK;
     k->core_pir = pnv_chip_core_pir_p8;
     k->intc_create = pnv_chip_power8_intc_create;
+    k->intc_reset = pnv_chip_power8_intc_reset;
     k->isa_create = pnv_chip_power8nvl_isa_create;
     k->dt_populate = pnv_chip_power8_dt_populate;
     k->pic_print_info = pnv_chip_power8_pic_print_info;
@@ -1191,6 +1208,7 @@ static void pnv_chip_power9_class_init(ObjectClass *klass, void *data)
     k->cores_mask = POWER9_CORE_MASK;
     k->core_pir = pnv_chip_core_pir_p9;
     k->intc_create = pnv_chip_power9_intc_create;
+    k->intc_reset = pnv_chip_power9_intc_reset;
     k->isa_create = pnv_chip_power9_isa_create;
     k->dt_populate = pnv_chip_power9_dt_populate;
     k->pic_print_info = pnv_chip_power9_pic_print_info;
diff --git a/hw/ppc/pnv_core.c b/hw/ppc/pnv_core.c
index cc17bbfed8..be0310ac03 100644
--- a/hw/ppc/pnv_core.c
+++ b/hw/ppc/pnv_core.c
@@ -40,10 +40,11 @@ static const char *pnv_core_cpu_typename(PnvCore *pc)
     return cpu_type;
 }
 
-static void pnv_core_cpu_reset(PowerPCCPU *cpu)
+static void pnv_core_cpu_reset(PowerPCCPU *cpu, PnvChip *chip)
 {
     CPUState *cs = CPU(cpu);
     CPUPPCState *env = &cpu->env;
+    PnvChipClass *pcc = PNV_CHIP_GET_CLASS(chip);
 
     cpu_reset(cs);
 
@@ -54,6 +55,8 @@ static void pnv_core_cpu_reset(PowerPCCPU *cpu)
     env->gpr[3] = PNV_FDT_ADDR;
     env->nip = 0x10;
     env->msr |= MSR_HVB; /* Hypervisor mode */
+
+    pcc->intc_reset(chip, cpu);
 }
 
 /*
@@ -200,7 +203,7 @@ static void pnv_core_reset(void *dev)
     int i;
 
     for (i = 0; i < cc->nr_threads; i++) {
-        pnv_core_cpu_reset(pc->threads[i]);
+        pnv_core_cpu_reset(pc->threads[i], pc->chip);
     }
 }
 
diff --git a/hw/ppc/spapr_cpu_core.c b/hw/ppc/spapr_cpu_core.c
index 2e34832d0e..ef7b27a66d 100644
--- a/hw/ppc/spapr_cpu_core.c
+++ b/hw/ppc/spapr_cpu_core.c
@@ -32,6 +32,7 @@ static void spapr_reset_vcpu(PowerPCCPU *cpu)
     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
     SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
     target_ulong lpcr;
+    SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
 
     cpu_reset(cs);
 
@@ -76,9 +77,11 @@ static void spapr_reset_vcpu(PowerPCCPU *cpu)
     spapr_cpu->dtl_addr = 0;
     spapr_cpu->dtl_size = 0;
 
-    spapr_caps_cpu_apply(SPAPR_MACHINE(qdev_get_machine()), cpu);
+    spapr_caps_cpu_apply(spapr, cpu);
 
     kvm_check_mmu(cpu, &error_fatal);
+
+    spapr_irq_cpu_intc_reset(spapr, cpu);
 }
 
 void spapr_cpu_set_entry_state(PowerPCCPU *cpu, target_ulong nip, target_ulong r3)
diff --git a/hw/ppc/spapr_irq.c b/hw/ppc/spapr_irq.c
index 234d1073e5..b941608b69 100644
--- a/hw/ppc/spapr_irq.c
+++ b/hw/ppc/spapr_irq.c
@@ -220,6 +220,20 @@ int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
     return 0;
 }
 
+void spapr_irq_cpu_intc_reset(SpaprMachineState *spapr, PowerPCCPU *cpu)
+{
+    SpaprInterruptController *intcs[] = ALL_INTCS(spapr);
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(intcs); i++) {
+        SpaprInterruptController *intc = intcs[i];
+        if (intc) {
+            SpaprInterruptControllerClass *sicc = SPAPR_INTC_GET_CLASS(intc);
+            sicc->cpu_intc_reset(intc, cpu);
+        }
+    }
+}
+
 static void spapr_set_irq(void *opaque, int irq, int level)
 {
     SpaprMachineState *spapr = SPAPR_MACHINE(opaque);
diff --git a/include/hw/ppc/pnv.h b/include/hw/ppc/pnv.h
index 1cdbe55bf8..2a780e633f 100644
--- a/include/hw/ppc/pnv.h
+++ b/include/hw/ppc/pnv.h
@@ -111,6 +111,7 @@ typedef struct PnvChipClass {
 
     uint32_t (*core_pir)(PnvChip *chip, uint32_t core_id);
     void (*intc_create)(PnvChip *chip, PowerPCCPU *cpu, Error **errp);
+    void (*intc_reset)(PnvChip *chip, PowerPCCPU *cpu);
     ISABus *(*isa_create)(PnvChip *chip, Error **errp);
     void (*dt_populate)(PnvChip *chip, void *fdt);
     void (*pic_print_info)(PnvChip *chip, Monitor *mon);
diff --git a/include/hw/ppc/spapr_irq.h b/include/hw/ppc/spapr_irq.h
index 5e150a6679..09232999b0 100644
--- a/include/hw/ppc/spapr_irq.h
+++ b/include/hw/ppc/spapr_irq.h
@@ -52,6 +52,7 @@ typedef struct SpaprInterruptControllerClass {
      */
     int (*cpu_intc_create)(SpaprInterruptController *intc,
                             PowerPCCPU *cpu, Error **errp);
+    void (*cpu_intc_reset)(SpaprInterruptController *intc, PowerPCCPU *cpu);
     int (*claim_irq)(SpaprInterruptController *intc, int irq, bool lsi,
                      Error **errp);
     void (*free_irq)(SpaprInterruptController *intc, int irq);
@@ -68,6 +69,7 @@ void spapr_irq_update_active_intc(SpaprMachineState *spapr);
 
 int spapr_irq_cpu_intc_create(SpaprMachineState *spapr,
                               PowerPCCPU *cpu, Error **errp);
+void spapr_irq_cpu_intc_reset(SpaprMachineState *spapr, PowerPCCPU *cpu);
 void spapr_irq_print_info(SpaprMachineState *spapr, Monitor *mon);
 void spapr_irq_dt(SpaprMachineState *spapr, uint32_t nr_servers,
                   void *fdt, uint32_t phandle);
diff --git a/include/hw/ppc/xics.h b/include/hw/ppc/xics.h
index 1e6a9300eb..602173c122 100644
--- a/include/hw/ppc/xics.h
+++ b/include/hw/ppc/xics.h
@@ -161,6 +161,7 @@ void icp_set_mfrr(ICPState *icp, uint8_t mfrr);
 uint32_t icp_accept(ICPState *ss);
 uint32_t icp_ipoll(ICPState *ss, uint32_t *mfrr);
 void icp_eoi(ICPState *icp, uint32_t xirr);
+void icp_reset(ICPState *icp);
 
 void ics_write_xive(ICSState *ics, int nr, int server,
                     uint8_t priority, uint8_t saved_priority);
diff --git a/include/hw/ppc/xive.h b/include/hw/ppc/xive.h
index fd3319bd32..99381639f5 100644
--- a/include/hw/ppc/xive.h
+++ b/include/hw/ppc/xive.h
@@ -415,6 +415,7 @@ uint64_t xive_tctx_tm_read(XiveTCTX *tctx, hwaddr offset, unsigned size);
 
 void xive_tctx_pic_print_info(XiveTCTX *tctx, Monitor *mon);
 Object *xive_tctx_create(Object *cpu, XiveRouter *xrtr, Error **errp);
+void xive_tctx_reset(XiveTCTX *tctx);
 
 static inline uint32_t xive_nvt_cam_line(uint8_t nvt_blk, uint32_t nvt_idx)
 {
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 27/28] ppc/pnv: Fix naming of routines realizing the CPUs
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (25 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 26/28] ppc: Reset the interrupt presenter from the CPU reset handler David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24  8:18 ` [PULL 28/28] spapr/xive: Set the OS CAM line at reset David Gibson
  2019-10-24 16:09 ` [PULL 00/28] ppc-for-4.2 queue 20191024 Peter Maydell
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell
  Cc: lvivier, qemu-devel, groug, qemu-ppc, clg,
	Philippe Mathieu-Daudé,
	David Gibson

From: Cédric Le Goater <clg@kaod.org>

The 'vcpu' suffix is inherited from the sPAPR machine. Use better
names for PowerNV.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20191022163812.330-7-clg@kaod.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/ppc/pnv_core.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/hw/ppc/pnv_core.c b/hw/ppc/pnv_core.c
index be0310ac03..e81cd3a3e0 100644
--- a/hw/ppc/pnv_core.c
+++ b/hw/ppc/pnv_core.c
@@ -162,7 +162,7 @@ static const MemoryRegionOps pnv_core_power9_xscom_ops = {
     .endianness = DEVICE_BIG_ENDIAN,
 };
 
-static void pnv_realize_vcpu(PowerPCCPU *cpu, PnvChip *chip, Error **errp)
+static void pnv_core_cpu_realize(PowerPCCPU *cpu, PnvChip *chip, Error **errp)
 {
     CPUPPCState *env = &cpu->env;
     int core_pir;
@@ -247,7 +247,7 @@ static void pnv_core_realize(DeviceState *dev, Error **errp)
     }
 
     for (j = 0; j < cc->nr_threads; j++) {
-        pnv_realize_vcpu(pc->threads[j], pc->chip, &local_err);
+        pnv_core_cpu_realize(pc->threads[j], pc->chip, &local_err);
         if (local_err) {
             goto err;
         }
@@ -269,7 +269,7 @@ err:
     error_propagate(errp, local_err);
 }
 
-static void pnv_unrealize_vcpu(PowerPCCPU *cpu)
+static void pnv_core_cpu_unrealize(PowerPCCPU *cpu)
 {
     PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
 
@@ -289,7 +289,7 @@ static void pnv_core_unrealize(DeviceState *dev, Error **errp)
     qemu_unregister_reset(pnv_core_reset, pc);
 
     for (i = 0; i < cc->nr_threads; i++) {
-        pnv_unrealize_vcpu(pc->threads[i]);
+        pnv_core_cpu_unrealize(pc->threads[i]);
     }
     g_free(pc->threads);
 }
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* [PULL 28/28] spapr/xive: Set the OS CAM line at reset
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (26 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 27/28] ppc/pnv: Fix naming of routines realizing the CPUs David Gibson
@ 2019-10-24  8:18 ` David Gibson
  2019-10-24 16:09 ` [PULL 00/28] ppc-for-4.2 queue 20191024 Peter Maydell
  28 siblings, 0 replies; 34+ messages in thread
From: David Gibson @ 2019-10-24  8:18 UTC (permalink / raw)
  To: peter.maydell; +Cc: lvivier, qemu-devel, groug, qemu-ppc, clg, David Gibson

From: Cédric Le Goater <clg@kaod.org>

When a Virtual Processor is scheduled to run on a HW thread, the
hypervisor pushes its identifier in the OS CAM line. When running with
kernel_irqchip=off, QEMU needs to emulate the same behavior.

Set the OS CAM line when the interrupt presenter of the sPAPR core is
reset. This will also cover the case of hot-plugged CPUs.

This change also has the benefit to remove the use of CPU_FOREACH()
which can be unsafe.

Signed-off-by: Cédric Le Goater <clg@kaod.org>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20191022163812.330-8-clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
 hw/intc/spapr_xive.c        | 48 +++++++++++++------------------------
 include/hw/ppc/spapr_xive.h |  1 -
 2 files changed, 17 insertions(+), 32 deletions(-)

diff --git a/hw/intc/spapr_xive.c b/hw/intc/spapr_xive.c
index 20a8d8285f..d8e1291905 100644
--- a/hw/intc/spapr_xive.c
+++ b/hw/intc/spapr_xive.c
@@ -205,23 +205,6 @@ void spapr_xive_mmio_set_enabled(SpaprXive *xive, bool enable)
     memory_region_set_enabled(&xive->end_source.esb_mmio, false);
 }
 
-/*
- * When a Virtual Processor is scheduled to run on a HW thread, the
- * hypervisor pushes its identifier in the OS CAM line. Emulate the
- * same behavior under QEMU.
- */
-void spapr_xive_set_tctx_os_cam(XiveTCTX *tctx)
-{
-    uint8_t  nvt_blk;
-    uint32_t nvt_idx;
-    uint32_t nvt_cam;
-
-    spapr_xive_cpu_to_nvt(POWERPC_CPU(tctx->cs), &nvt_blk, &nvt_idx);
-
-    nvt_cam = cpu_to_be32(TM_QW1W2_VO | xive_nvt_cam_line(nvt_blk, nvt_idx));
-    memcpy(&tctx->regs[TM_QW1_OS + TM_WORD2], &nvt_cam, 4);
-}
-
 static void spapr_xive_end_reset(XiveEND *end)
 {
     memset(end, 0, sizeof(*end));
@@ -544,21 +527,32 @@ static int spapr_xive_cpu_intc_create(SpaprInterruptController *intc,
     }
 
     spapr_cpu->tctx = XIVE_TCTX(obj);
-
-    /*
-     * (TCG) Early setting the OS CAM line for hotplugged CPUs as they
-     * don't beneficiate from the reset of the XIVE IRQ backend
-     */
-    spapr_xive_set_tctx_os_cam(spapr_cpu->tctx);
     return 0;
 }
 
+static void xive_tctx_set_os_cam(XiveTCTX *tctx, uint32_t os_cam)
+{
+    uint32_t qw1w2 = cpu_to_be32(TM_QW1W2_VO | os_cam);
+    memcpy(&tctx->regs[TM_QW1_OS + TM_WORD2], &qw1w2, 4);
+}
+
 static void spapr_xive_cpu_intc_reset(SpaprInterruptController *intc,
                                      PowerPCCPU *cpu)
 {
     XiveTCTX *tctx = spapr_cpu_state(cpu)->tctx;
+    uint8_t  nvt_blk;
+    uint32_t nvt_idx;
 
     xive_tctx_reset(tctx);
+
+    /*
+     * When a Virtual Processor is scheduled to run on a HW thread,
+     * the hypervisor pushes its identifier in the OS CAM line.
+     * Emulate the same behavior under QEMU.
+     */
+    spapr_xive_cpu_to_nvt(cpu, &nvt_blk, &nvt_idx);
+
+    xive_tctx_set_os_cam(tctx, xive_nvt_cam_line(nvt_blk, nvt_idx));
 }
 
 static void spapr_xive_set_irq(SpaprInterruptController *intc, int irq, int val)
@@ -651,14 +645,6 @@ static void spapr_xive_dt(SpaprInterruptController *intc, uint32_t nr_servers,
 static int spapr_xive_activate(SpaprInterruptController *intc, Error **errp)
 {
     SpaprXive *xive = SPAPR_XIVE(intc);
-    CPUState *cs;
-
-    CPU_FOREACH(cs) {
-        PowerPCCPU *cpu = POWERPC_CPU(cs);
-
-        /* (TCG) Set the OS CAM line of the thread interrupt context. */
-        spapr_xive_set_tctx_os_cam(spapr_cpu_state(cpu)->tctx);
-    }
 
     if (kvm_enabled()) {
         int rc = spapr_irq_init_kvm(kvmppc_xive_connect, intc, errp);
diff --git a/include/hw/ppc/spapr_xive.h b/include/hw/ppc/spapr_xive.h
index d84bd5c229..742b7e834f 100644
--- a/include/hw/ppc/spapr_xive.h
+++ b/include/hw/ppc/spapr_xive.h
@@ -57,7 +57,6 @@ typedef struct SpaprXive {
 void spapr_xive_pic_print_info(SpaprXive *xive, Monitor *mon);
 
 void spapr_xive_hcall_init(SpaprMachineState *spapr);
-void spapr_xive_set_tctx_os_cam(XiveTCTX *tctx);
 void spapr_xive_mmio_set_enabled(SpaprXive *xive, bool enable);
 void spapr_xive_map_mmio(SpaprXive *xive);
 
-- 
2.21.0



^ permalink raw reply	[flat|nested] 34+ messages in thread

* Re: [PULL 00/28] ppc-for-4.2 queue 20191024
  2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
                   ` (27 preceding siblings ...)
  2019-10-24  8:18 ` [PULL 28/28] spapr/xive: Set the OS CAM line at reset David Gibson
@ 2019-10-24 16:09 ` Peter Maydell
  28 siblings, 0 replies; 34+ messages in thread
From: Peter Maydell @ 2019-10-24 16:09 UTC (permalink / raw)
  To: David Gibson
  Cc: Laurent Vivier, Cédric Le Goater, qemu-ppc, QEMU Developers,
	Greg Kurz

On Thu, 24 Oct 2019 at 09:18, David Gibson <david@gibson.dropbear.id.au> wrote:
>
> The following changes since commit f78398bfe544db81a974825b0a2aa826f6576414:
>
>   Merge remote-tracking branch 'remotes/ericb/tags/pull-nbd-2019-10-22' into staging (2019-10-23 16:06:13 +0100)
>
> are available in the Git repository at:
>
>   git://github.com/dgibson/qemu.git tags/ppc-for-4.2-20191024
>
> for you to fetch changes up to 97c00c54449b4ff349f85c6ce409dadd1b935a7d:
>
>   spapr/xive: Set the OS CAM line at reset (2019-10-24 13:34:15 +1100)
>
> ----------------------------------------------------------------
> ppc patch queue 2019-10-24
>
> Last pull request before soft freeze.
>   * Lots of fixes and cleanups for spapr interrupt controllers
>   * More SLOF updates to fix problems with full FDT rendering at CAS
>     time (alas, more yet are to come)
>   * A few other assorted changes
>
> This isn't quite as well tested as I usually try to do before a pull
> request.  But I've been sick and running into some other difficulties,
> and wanted to get this sent out before heading towards KVM forum.
>
> ----------------------------------------------------------------



Applied, thanks.

Please update the changelog at https://wiki.qemu.org/ChangeLog/4.2
for any user-visible changes.

-- PMM


^ permalink raw reply	[flat|nested] 34+ messages in thread

* Re: [PULL 06/28] spapr: Set VSMT to smp_threads by default
  2019-10-24  8:17 ` [PULL 06/28] spapr: Set VSMT to smp_threads by default David Gibson
@ 2019-11-08 13:11   ` Laurent Vivier
  2019-11-08 14:26     ` David Gibson
  0 siblings, 1 reply; 34+ messages in thread
From: Laurent Vivier @ 2019-11-08 13:11 UTC (permalink / raw)
  To: groug
  Cc: peter.maydell, Juan Quintela, qemu-devel, Dr. David Alan Gilbert,
	qemu-ppc, clg, David Gibson

On 24/10/2019 10:17, David Gibson wrote:
> From: Greg Kurz <groug@kaod.org>
> 
> Support for setting VSMT is available in KVM since linux-4.13. Most distros
> that support KVM on POWER already have it. It thus seem reasonable enough
> to have the default machine to set VSMT to smp_threads.
> 
> This brings contiguous VCPU ids and thus brings their upper bound down to
> the machine's max_cpus. This is especially useful for XIVE KVM devices,
> which may thus allocate only one VP descriptor per VCPU.
> 
> Signed-off-by: Greg Kurz <groug@kaod.org>
> Message-Id: <157010411885.246126.12610015369068227139.stgit@bahia.lan>
> Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
> ---
>  hw/ppc/spapr.c         | 7 ++++++-
>  include/hw/ppc/spapr.h | 1 +
>  2 files changed, 7 insertions(+), 1 deletion(-)
> 
> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> index 4eb97d3a9b..428b834f30 100644
> --- a/hw/ppc/spapr.c
> +++ b/hw/ppc/spapr.c
> @@ -2496,6 +2496,7 @@ static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
>  static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>  {
>      MachineState *ms = MACHINE(spapr);
> +    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
>      Error *local_err = NULL;
>      bool vsmt_user = !!spapr->vsmt;
>      int kvm_smt = kvmppc_smt_threads();
> @@ -2522,7 +2523,7 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>              goto out;
>          }
>          /* In this case, spapr->vsmt has been set by the command line */
> -    } else {
> +    } else if (!smc->smp_threads_vsmt) {
>          /*
>           * Default VSMT value is tricky, because we need it to be as
>           * consistent as possible (for migration), but this requires
> @@ -2531,6 +2532,8 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>           * overwhelmingly common case in production systems.
>           */
>          spapr->vsmt = MAX(8, smp_threads);
> +    } else {
> +        spapr->vsmt = smp_threads;
>      }
>  
>      /* KVM: If necessary, set the SMT mode: */
> @@ -4438,6 +4441,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
>      smc->irq = &spapr_irq_dual;
>      smc->dr_phb_enabled = true;
>      smc->linux_pci_probe = true;
> +    smc->smp_threads_vsmt = true;
>  }
>  
>  static const TypeInfo spapr_machine_info = {
> @@ -4505,6 +4509,7 @@ static void spapr_machine_4_1_class_options(MachineClass *mc)
>  
>      spapr_machine_4_2_class_options(mc);
>      smc->linux_pci_probe = false;
> +    smc->smp_threads_vsmt = false;
>      compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
>      compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
>  }
> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> index cbd1a4c9f3..2009eb64f9 100644
> --- a/include/hw/ppc/spapr.h
> +++ b/include/hw/ppc/spapr.h
> @@ -122,6 +122,7 @@ struct SpaprMachineClass {
>      bool broken_host_serial_model; /* present real host info to the guest */
>      bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
>      bool linux_pci_probe;
> +    bool smp_threads_vsmt; /* set VSMT to smp_threads by default */
>  
>      void (*phb_placement)(SpaprMachineState *spapr, uint32_t index,
>                            uint64_t *buid, hwaddr *pio, 
> 

This patch breaks tests/migration-test on P8 host with kernel older than
4.3 because it tries by default to set the VSMT to 1.

qemu-system-ppc64: Failed to set KVM's VSMT mode to 1 (errno -22)
On PPC, a VM with 1 threads/core on a host with 8 threads/core requires
the use of VSMT mode 1.
This KVM seems to be too old to support VSMT.

As this is clearly intentional, is there a way to fix migration-test?

Thanks,
Laurent



^ permalink raw reply	[flat|nested] 34+ messages in thread

* Re: [PULL 06/28] spapr: Set VSMT to smp_threads by default
  2019-11-08 13:11   ` Laurent Vivier
@ 2019-11-08 14:26     ` David Gibson
  2019-11-08 15:34       ` Laurent Vivier
  0 siblings, 1 reply; 34+ messages in thread
From: David Gibson @ 2019-11-08 14:26 UTC (permalink / raw)
  To: Laurent Vivier
  Cc: peter.maydell, Juan Quintela, groug, qemu-devel, qemu-ppc, clg,
	Dr. David Alan Gilbert

[-- Attachment #1: Type: text/plain, Size: 4462 bytes --]

On Fri, Nov 08, 2019 at 02:11:03PM +0100, Laurent Vivier wrote:
> On 24/10/2019 10:17, David Gibson wrote:
> > From: Greg Kurz <groug@kaod.org>
> > 
> > Support for setting VSMT is available in KVM since linux-4.13. Most distros
> > that support KVM on POWER already have it. It thus seem reasonable enough
> > to have the default machine to set VSMT to smp_threads.
> > 
> > This brings contiguous VCPU ids and thus brings their upper bound down to
> > the machine's max_cpus. This is especially useful for XIVE KVM devices,
> > which may thus allocate only one VP descriptor per VCPU.
> > 
> > Signed-off-by: Greg Kurz <groug@kaod.org>
> > Message-Id: <157010411885.246126.12610015369068227139.stgit@bahia.lan>
> > Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
> > ---
> >  hw/ppc/spapr.c         | 7 ++++++-
> >  include/hw/ppc/spapr.h | 1 +
> >  2 files changed, 7 insertions(+), 1 deletion(-)
> > 
> > diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> > index 4eb97d3a9b..428b834f30 100644
> > --- a/hw/ppc/spapr.c
> > +++ b/hw/ppc/spapr.c
> > @@ -2496,6 +2496,7 @@ static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
> >  static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
> >  {
> >      MachineState *ms = MACHINE(spapr);
> > +    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
> >      Error *local_err = NULL;
> >      bool vsmt_user = !!spapr->vsmt;
> >      int kvm_smt = kvmppc_smt_threads();
> > @@ -2522,7 +2523,7 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
> >              goto out;
> >          }
> >          /* In this case, spapr->vsmt has been set by the command line */
> > -    } else {
> > +    } else if (!smc->smp_threads_vsmt) {
> >          /*
> >           * Default VSMT value is tricky, because we need it to be as
> >           * consistent as possible (for migration), but this requires
> > @@ -2531,6 +2532,8 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
> >           * overwhelmingly common case in production systems.
> >           */
> >          spapr->vsmt = MAX(8, smp_threads);
> > +    } else {
> > +        spapr->vsmt = smp_threads;
> >      }
> >  
> >      /* KVM: If necessary, set the SMT mode: */
> > @@ -4438,6 +4441,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
> >      smc->irq = &spapr_irq_dual;
> >      smc->dr_phb_enabled = true;
> >      smc->linux_pci_probe = true;
> > +    smc->smp_threads_vsmt = true;
> >  }
> >  
> >  static const TypeInfo spapr_machine_info = {
> > @@ -4505,6 +4509,7 @@ static void spapr_machine_4_1_class_options(MachineClass *mc)
> >  
> >      spapr_machine_4_2_class_options(mc);
> >      smc->linux_pci_probe = false;
> > +    smc->smp_threads_vsmt = false;
> >      compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
> >      compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
> >  }
> > diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
> > index cbd1a4c9f3..2009eb64f9 100644
> > --- a/include/hw/ppc/spapr.h
> > +++ b/include/hw/ppc/spapr.h
> > @@ -122,6 +122,7 @@ struct SpaprMachineClass {
> >      bool broken_host_serial_model; /* present real host info to the guest */
> >      bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
> >      bool linux_pci_probe;
> > +    bool smp_threads_vsmt; /* set VSMT to smp_threads by default */
> >  
> >      void (*phb_placement)(SpaprMachineState *spapr, uint32_t index,
> >                            uint64_t *buid, hwaddr *pio, 
> > 
> 
> This patch breaks tests/migration-test on P8 host with kernel older than
> 4.3 because it tries by default to set the VSMT to 1.
> 
> qemu-system-ppc64: Failed to set KVM's VSMT mode to 1 (errno -22)
> On PPC, a VM with 1 threads/core on a host with 8 threads/core requires
> the use of VSMT mode 1.
> This KVM seems to be too old to support VSMT.
> 
> As this is clearly intentional, is there a way to fix migration-test?

Hrm.  I believe the argument for this was that the broken kernels were
old enough we didn't care.  What platform are you testing on where
you're hitting this?

-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

^ permalink raw reply	[flat|nested] 34+ messages in thread

* Re: [PULL 06/28] spapr: Set VSMT to smp_threads by default
  2019-11-08 14:26     ` David Gibson
@ 2019-11-08 15:34       ` Laurent Vivier
  2019-11-08 15:42         ` Laurent Vivier
  0 siblings, 1 reply; 34+ messages in thread
From: Laurent Vivier @ 2019-11-08 15:34 UTC (permalink / raw)
  To: David Gibson
  Cc: peter.maydell, Juan Quintela, groug, qemu-devel, qemu-ppc, clg,
	Dr. David Alan Gilbert

On 08/11/2019 15:26, David Gibson wrote:
> On Fri, Nov 08, 2019 at 02:11:03PM +0100, Laurent Vivier wrote:
>> On 24/10/2019 10:17, David Gibson wrote:
>>> From: Greg Kurz <groug@kaod.org>
>>>
>>> Support for setting VSMT is available in KVM since linux-4.13. Most distros
>>> that support KVM on POWER already have it. It thus seem reasonable enough
>>> to have the default machine to set VSMT to smp_threads.
>>>
>>> This brings contiguous VCPU ids and thus brings their upper bound down to
>>> the machine's max_cpus. This is especially useful for XIVE KVM devices,
>>> which may thus allocate only one VP descriptor per VCPU.
>>>
>>> Signed-off-by: Greg Kurz <groug@kaod.org>
>>> Message-Id: <157010411885.246126.12610015369068227139.stgit@bahia.lan>
>>> Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
>>> ---
>>>  hw/ppc/spapr.c         | 7 ++++++-
>>>  include/hw/ppc/spapr.h | 1 +
>>>  2 files changed, 7 insertions(+), 1 deletion(-)
>>>
>>> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
>>> index 4eb97d3a9b..428b834f30 100644
>>> --- a/hw/ppc/spapr.c
>>> +++ b/hw/ppc/spapr.c
>>> @@ -2496,6 +2496,7 @@ static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
>>>  static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>  {
>>>      MachineState *ms = MACHINE(spapr);
>>> +    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
>>>      Error *local_err = NULL;
>>>      bool vsmt_user = !!spapr->vsmt;
>>>      int kvm_smt = kvmppc_smt_threads();
>>> @@ -2522,7 +2523,7 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>              goto out;
>>>          }
>>>          /* In this case, spapr->vsmt has been set by the command line */
>>> -    } else {
>>> +    } else if (!smc->smp_threads_vsmt) {
>>>          /*
>>>           * Default VSMT value is tricky, because we need it to be as
>>>           * consistent as possible (for migration), but this requires
>>> @@ -2531,6 +2532,8 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>           * overwhelmingly common case in production systems.
>>>           */
>>>          spapr->vsmt = MAX(8, smp_threads);
>>> +    } else {
>>> +        spapr->vsmt = smp_threads;
>>>      }
>>>  
>>>      /* KVM: If necessary, set the SMT mode: */
>>> @@ -4438,6 +4441,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
>>>      smc->irq = &spapr_irq_dual;
>>>      smc->dr_phb_enabled = true;
>>>      smc->linux_pci_probe = true;
>>> +    smc->smp_threads_vsmt = true;
>>>  }
>>>  
>>>  static const TypeInfo spapr_machine_info = {
>>> @@ -4505,6 +4509,7 @@ static void spapr_machine_4_1_class_options(MachineClass *mc)
>>>  
>>>      spapr_machine_4_2_class_options(mc);
>>>      smc->linux_pci_probe = false;
>>> +    smc->smp_threads_vsmt = false;
>>>      compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
>>>      compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
>>>  }
>>> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
>>> index cbd1a4c9f3..2009eb64f9 100644
>>> --- a/include/hw/ppc/spapr.h
>>> +++ b/include/hw/ppc/spapr.h
>>> @@ -122,6 +122,7 @@ struct SpaprMachineClass {
>>>      bool broken_host_serial_model; /* present real host info to the guest */
>>>      bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
>>>      bool linux_pci_probe;
>>> +    bool smp_threads_vsmt; /* set VSMT to smp_threads by default */
>>>  
>>>      void (*phb_placement)(SpaprMachineState *spapr, uint32_t index,
>>>                            uint64_t *buid, hwaddr *pio, 
>>>
>>
>> This patch breaks tests/migration-test on P8 host with kernel older than
>> 4.3 because it tries by default to set the VSMT to 1.
>>
>> qemu-system-ppc64: Failed to set KVM's VSMT mode to 1 (errno -22)
>> On PPC, a VM with 1 threads/core on a host with 8 threads/core requires
>> the use of VSMT mode 1.
>> This KVM seems to be too old to support VSMT.
>>
>> As this is clearly intentional, is there a way to fix migration-test?
> 
> Hrm.  I believe the argument for this was that the broken kernels were
> old enough we didn't care.  What platform are you testing on where
> you're hitting this?
> 

I'm going to propose a patch to fix this problem.
(it was on RHEL7)

Thanks,
Laurent



^ permalink raw reply	[flat|nested] 34+ messages in thread

* Re: [PULL 06/28] spapr: Set VSMT to smp_threads by default
  2019-11-08 15:34       ` Laurent Vivier
@ 2019-11-08 15:42         ` Laurent Vivier
  0 siblings, 0 replies; 34+ messages in thread
From: Laurent Vivier @ 2019-11-08 15:42 UTC (permalink / raw)
  To: David Gibson
  Cc: peter.maydell, Juan Quintela, groug, qemu-devel, qemu-ppc, clg,
	Dr. David Alan Gilbert

On 08/11/2019 16:34, Laurent Vivier wrote:
> On 08/11/2019 15:26, David Gibson wrote:
>> On Fri, Nov 08, 2019 at 02:11:03PM +0100, Laurent Vivier wrote:
>>> On 24/10/2019 10:17, David Gibson wrote:
>>>> From: Greg Kurz <groug@kaod.org>
>>>>
>>>> Support for setting VSMT is available in KVM since linux-4.13. Most distros
>>>> that support KVM on POWER already have it. It thus seem reasonable enough
>>>> to have the default machine to set VSMT to smp_threads.
>>>>
>>>> This brings contiguous VCPU ids and thus brings their upper bound down to
>>>> the machine's max_cpus. This is especially useful for XIVE KVM devices,
>>>> which may thus allocate only one VP descriptor per VCPU.
>>>>
>>>> Signed-off-by: Greg Kurz <groug@kaod.org>
>>>> Message-Id: <157010411885.246126.12610015369068227139.stgit@bahia.lan>
>>>> Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
>>>> ---
>>>>  hw/ppc/spapr.c         | 7 ++++++-
>>>>  include/hw/ppc/spapr.h | 1 +
>>>>  2 files changed, 7 insertions(+), 1 deletion(-)
>>>>
>>>> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
>>>> index 4eb97d3a9b..428b834f30 100644
>>>> --- a/hw/ppc/spapr.c
>>>> +++ b/hw/ppc/spapr.c
>>>> @@ -2496,6 +2496,7 @@ static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
>>>>  static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>>  {
>>>>      MachineState *ms = MACHINE(spapr);
>>>> +    SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
>>>>      Error *local_err = NULL;
>>>>      bool vsmt_user = !!spapr->vsmt;
>>>>      int kvm_smt = kvmppc_smt_threads();
>>>> @@ -2522,7 +2523,7 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>>              goto out;
>>>>          }
>>>>          /* In this case, spapr->vsmt has been set by the command line */
>>>> -    } else {
>>>> +    } else if (!smc->smp_threads_vsmt) {
>>>>          /*
>>>>           * Default VSMT value is tricky, because we need it to be as
>>>>           * consistent as possible (for migration), but this requires
>>>> @@ -2531,6 +2532,8 @@ static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
>>>>           * overwhelmingly common case in production systems.
>>>>           */
>>>>          spapr->vsmt = MAX(8, smp_threads);
>>>> +    } else {
>>>> +        spapr->vsmt = smp_threads;
>>>>      }
>>>>  
>>>>      /* KVM: If necessary, set the SMT mode: */
>>>> @@ -4438,6 +4441,7 @@ static void spapr_machine_class_init(ObjectClass *oc, void *data)
>>>>      smc->irq = &spapr_irq_dual;
>>>>      smc->dr_phb_enabled = true;
>>>>      smc->linux_pci_probe = true;
>>>> +    smc->smp_threads_vsmt = true;
>>>>  }
>>>>  
>>>>  static const TypeInfo spapr_machine_info = {
>>>> @@ -4505,6 +4509,7 @@ static void spapr_machine_4_1_class_options(MachineClass *mc)
>>>>  
>>>>      spapr_machine_4_2_class_options(mc);
>>>>      smc->linux_pci_probe = false;
>>>> +    smc->smp_threads_vsmt = false;
>>>>      compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
>>>>      compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
>>>>  }
>>>> diff --git a/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h
>>>> index cbd1a4c9f3..2009eb64f9 100644
>>>> --- a/include/hw/ppc/spapr.h
>>>> +++ b/include/hw/ppc/spapr.h
>>>> @@ -122,6 +122,7 @@ struct SpaprMachineClass {
>>>>      bool broken_host_serial_model; /* present real host info to the guest */
>>>>      bool pre_4_1_migration; /* don't migrate hpt-max-page-size */
>>>>      bool linux_pci_probe;
>>>> +    bool smp_threads_vsmt; /* set VSMT to smp_threads by default */
>>>>  
>>>>      void (*phb_placement)(SpaprMachineState *spapr, uint32_t index,
>>>>                            uint64_t *buid, hwaddr *pio, 
>>>>
>>>
>>> This patch breaks tests/migration-test on P8 host with kernel older than
>>> 4.3 because it tries by default to set the VSMT to 1.
>>>
>>> qemu-system-ppc64: Failed to set KVM's VSMT mode to 1 (errno -22)
>>> On PPC, a VM with 1 threads/core on a host with 8 threads/core requires
>>> the use of VSMT mode 1.
>>> This KVM seems to be too old to support VSMT.
>>>
>>> As this is clearly intentional, is there a way to fix migration-test?
>>
>> Hrm.  I believe the argument for this was that the broken kernels were
>> old enough we didn't care.  What platform are you testing on where
>> you're hitting this?
>>
> 
> I'm going to propose a patch to fix this problem.
> (it was on RHEL7)

Patch sent:
[PATCH] spapr: Fix VSMT mode when it is not supported by the kernel
Message-Id: <20191108154035.12913-1-lvivier@redhat.com>

Thanks,
Laurent



^ permalink raw reply	[flat|nested] 34+ messages in thread

end of thread, back to index

Thread overview: 34+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-10-24  8:17 [PULL 00/28] ppc-for-4.2 queue 20191024 David Gibson
2019-10-24  8:17 ` [PULL 01/28] xive: Make some device types not user creatable David Gibson
2019-10-24  8:17 ` [PULL 02/28] xics: " David Gibson
2019-10-24  8:17 ` [PULL 03/28] target/ppc: Fix for optimized vsl/vsr instructions David Gibson
2019-10-24  8:17 ` [PULL 04/28] ppc/pnv: Improve trigger data definition David Gibson
2019-10-24  8:17 ` [PULL 05/28] ppc/pnv: Use address_space_stq_be() when triggering an interrupt from PSI David Gibson
2019-10-24  8:17 ` [PULL 06/28] spapr: Set VSMT to smp_threads by default David Gibson
2019-11-08 13:11   ` Laurent Vivier
2019-11-08 14:26     ` David Gibson
2019-11-08 15:34       ` Laurent Vivier
2019-11-08 15:42         ` Laurent Vivier
2019-10-24  8:17 ` [PULL 07/28] spapr, xics, xive: Introduce SpaprInterruptController QOM interface David Gibson
2019-10-24  8:17 ` [PULL 08/28] spapr, xics, xive: Move cpu_intc_create from SpaprIrq to SpaprInterruptController David Gibson
2019-10-24  8:17 ` [PULL 09/28] spapr, xics, xive: Move irq claim and free " David Gibson
2019-10-24  8:17 ` [PULL 10/28] spapr: Formalize notion of active interrupt controller David Gibson
2019-10-24  8:17 ` [PULL 11/28] spapr, xics, xive: Move set_irq from SpaprIrq to SpaprInterruptController David Gibson
2019-10-24  8:17 ` [PULL 12/28] spapr, xics, xive: Move print_info " David Gibson
2019-10-24  8:17 ` [PULL 13/28] spapr, xics, xive: Move dt_populate " David Gibson
2019-10-24  8:17 ` [PULL 14/28] spapr, xics, xive: Match signatures for XICS and XIVE KVM connect routines David Gibson
2019-10-24  8:18 ` [PULL 15/28] spapr: Remove SpaprIrq::init_kvm hook David Gibson
2019-10-24  8:18 ` [PULL 16/28] spapr, xics, xive: Move SpaprIrq::reset hook logic into activate/deactivate David Gibson
2019-10-24  8:18 ` [PULL 17/28] spapr, xics, xive: Move SpaprIrq::post_load hook to backends David Gibson
2019-10-24  8:18 ` [PULL 18/28] spapr: Remove SpaprIrq::nr_msis David Gibson
2019-10-24  8:18 ` [PULL 19/28] spapr: Move SpaprIrq::nr_xirqs to SpaprMachineClass David Gibson
2019-10-24  8:18 ` [PULL 20/28] pseries: Update SLOF firmware image David Gibson
2019-10-24  8:18 ` [PULL 21/28] spapr: Don't request to unplug the same core twice David Gibson
2019-10-24  8:18 ` [PULL 22/28] spapr: move CPU reset after presenter creation David Gibson
2019-10-24  8:18 ` [PULL 23/28] spapr_cpu_core: Implement DeviceClass::reset David Gibson
2019-10-24  8:18 ` [PULL 24/28] ppc/pnv: Introduce a PnvCore reset handler David Gibson
2019-10-24  8:18 ` [PULL 25/28] ppc/pnv: Add a PnvChip pointer to PnvCore David Gibson
2019-10-24  8:18 ` [PULL 26/28] ppc: Reset the interrupt presenter from the CPU reset handler David Gibson
2019-10-24  8:18 ` [PULL 27/28] ppc/pnv: Fix naming of routines realizing the CPUs David Gibson
2019-10-24  8:18 ` [PULL 28/28] spapr/xive: Set the OS CAM line at reset David Gibson
2019-10-24 16:09 ` [PULL 00/28] ppc-for-4.2 queue 20191024 Peter Maydell

QEMU-Devel Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/qemu-devel/0 qemu-devel/git/0.git
	git clone --mirror https://lore.kernel.org/qemu-devel/1 qemu-devel/git/1.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 qemu-devel qemu-devel/ https://lore.kernel.org/qemu-devel \
		qemu-devel@nongnu.org
	public-inbox-index qemu-devel

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.nongnu.qemu-devel


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git