| Message ID | 1448024079-20808-9-git-send-email-bharata@linux.vnet.ibm.com |
|---|---|
| State | New |
| Headers | show |
On Fri, Nov 20, 2015 at 06:24:37PM +0530, Bharata B Rao wrote: > Support CPU hotplug via device-add command. Set up device tree > entries for the hotplugged CPU core and use the exising EPOW event > infrastructure to send CPU hotplug notification to the guest. > > Create only cores explicitly from boot path as well as hotplug path > and let the ->plug() handler of the core create the threads of the core. > > Also support cold plugged CPUs that are specified by -device option > on cmdline. > > Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com> > --- > hw/ppc/spapr.c | 156 +++++++++++++++++++++++++++++++++++++++++++- > hw/ppc/spapr_events.c | 3 + > hw/ppc/spapr_rtas.c | 24 +++++++ > target-ppc/translate_init.c | 8 +++ > 4 files changed, 189 insertions(+), 2 deletions(-) > > diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c > index 814b0a6..4434d45 100644 > --- a/hw/ppc/spapr.c > +++ b/hw/ppc/spapr.c > @@ -596,6 +596,18 @@ static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, > size_t page_sizes_prop_size; > uint32_t vcpus_per_socket = smp_threads * smp_cores; > uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; > + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > + sPAPRDRConnector *drc; > + sPAPRDRConnectorClass *drck; > + int drc_index; > + > + if (smc->dr_cpu_enabled) { > + drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); > + g_assert(drc); > + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + drc_index = drck->get_index(drc); > + _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); > + } > > /* Note: we keep CI large pages off for now because a 64K capable guest > * provisioned with large pages might otherwise try to map a qemu > @@ -1739,6 +1751,7 @@ static void ppc_spapr_init(MachineState *machine) > char *filename; > int smt = kvmppc_smt_threads(); > int smp_max_cores = DIV_ROUND_UP(max_cpus, smp_threads); > + int spapr_smp_cores = DIV_ROUND_UP(smp_cpus, smp_threads); > > msi_supported = true; > > @@ -1818,7 +1831,7 @@ static void ppc_spapr_init(MachineState *machine) > if (machine->cpu_model == NULL) { > machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; > } > - for (i = 0; i < smp_cpus; i++) { > + for (i = 0; i < spapr_smp_cores; i++) { > cpu = cpu_ppc_init(machine->cpu_model); > if (cpu == NULL) { > fprintf(stderr, "Unable to find PowerPC CPU definition\n"); > @@ -2207,10 +2220,135 @@ out: > error_propagate(errp, local_err); > } > > +static void *spapr_populate_hotplug_cpu_dt(DeviceState *dev, CPUState *cs, > + int *fdt_offset, > + sPAPRMachineState *spapr) > +{ > + PowerPCCPU *cpu = POWERPC_CPU(cs); > + DeviceClass *dc = DEVICE_GET_CLASS(cs); > + int id = ppc_get_vcpu_dt_id(cpu); > + void *fdt; > + int offset, fdt_size; > + char *nodename; > + > + fdt = create_device_tree(&fdt_size); > + nodename = g_strdup_printf("%s@%x", dc->fw_name, id); > + offset = fdt_add_subnode(fdt, 0, nodename); > + > + spapr_populate_cpu_dt(cs, fdt, offset, spapr); > + g_free(nodename); > + > + *fdt_offset = offset; > + return fdt; > +} > + > +static void spapr_cpu_plug(HotplugHandler *hotplug_dev, DeviceState *dev, > + Error **errp) > +{ > + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > + sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); > + CPUState *cs = CPU(dev); > + PowerPCCPU *cpu = POWERPC_CPU(cs); > + int id = ppc_get_vcpu_dt_id(cpu); > + sPAPRDRConnector *drc = > + spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, id); > + sPAPRDRConnectorClass *drck; > + int smt = kvmppc_smt_threads(); > + Error *local_err = NULL; > + void *fdt = NULL; > + int i, fdt_offset = 0; > + > + /* Set NUMA node for the added CPUs */ > + for (i = 0; i < nb_numa_nodes; i++) { > + if (test_bit(cs->cpu_index, numa_info[i].node_cpu)) { > + cs->numa_node = i; > + break; > + } > + } > + > + /* > + * Currently CPU core and threads of a core aren't really different > + * from QEMU point of view since all of them are just CPU devices. Hence > + * there is no separate realize routines for cores and threads. > + * We use the id check below to do things differently for cores and threads. > + * > + * SMT threads return from here, only main thread (core) will > + * continue, create threads and signal hotplug event to the guest. > + */ > + if ((id % smt) != 0) { > + return; > + } Hmm. It seems odd to me to have thread 0 of a core handle the initialization of the other threads, rather than creating an explicit Core QOM object and have that construct the cpu objects for all threads under it. It also causes a rather weird recursion of cpu_ppc_init() into cpu_ppc_init(), if I'm following the logic correctly. > + > + /* Create SMT threads of the core. */ > + for (i = 1; i < smp_threads; i++) { > + cpu = cpu_ppc_init(current_machine->cpu_model); > + if (!cpu) { > + error_report("Unable to find PowerPC CPU definition: %s", > + current_machine->cpu_model); > + exit(EXIT_FAILURE); > + } > + } > + > + if (!smc->dr_cpu_enabled) { > + /* > + * This is a cold plugged CPU but the machine doesn't support > + * DR. So skip the hotplug path ensuring that the CPU is brought > + * up online with out an associated DR connector. > + */ > + return; > + } > + > + g_assert(drc); > + > + /* > + * Setup CPU DT entries only for hotplugged CPUs. For boot time or > + * coldplugged CPUs DT entries are setup in spapr_finalize_fdt(). > + */ > + if (dev->hotplugged) { > + fdt = spapr_populate_hotplug_cpu_dt(dev, cs, &fdt_offset, ms); > + } > + > + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); > + if (local_err) { > + g_free(fdt); > + error_propagate(errp, local_err); > + return; > + } > + > + /* > + * We send hotplug notification interrupt to the guest only in case > + * of hotplugged CPUs. > + */ > + if (dev->hotplugged) { > + spapr_hotplug_req_add_by_index(drc); > + } else { > + /* > + * HACK to support removal of hotplugged CPU after VM migration: > + * > + * Since we want to be able to hot-remove those coldplugged CPUs > + * started at boot time using -device option at the target VM, we set > + * the right allocation_state and isolation_state for them, which for > + * the hotplugged CPUs would be set via RTAS calls done from the > + * guest during hotplug. > + * > + * This allows the coldplugged CPUs started using -device option to > + * have the right isolation and allocation states as expected by the > + * CPU hot removal code. > + * > + * This hack will be removed once we have DRC states migrated as part > + * of VM migration. > + */ > + drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); > + drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); > + } > +} > + > static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, > DeviceState *dev, Error **errp) > { > sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > + sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); > > if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { > int node; > @@ -2247,6 +2385,19 @@ static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, > } > > spapr_memory_plug(hotplug_dev, dev, node, errp); > + } else if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { > + CPUState *cs = CPU(dev); > + PowerPCCPU *cpu = POWERPC_CPU(cs); > + > + if (!smc->dr_cpu_enabled && dev->hotplugged) { > + error_setg(errp, "CPU hotplug not supported for this machine"); > + cpu_remove_sync(cs); > + return; > + } > + > + spapr_cpu_init(ms, cpu); > + spapr_cpu_reset(cpu); > + spapr_cpu_plug(hotplug_dev, dev, errp); > } > } > > @@ -2261,7 +2412,8 @@ static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, > static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, > DeviceState *dev) > { > - if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { > + if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || > + object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { > return HOTPLUG_HANDLER(machine); > } > return NULL; > diff --git a/hw/ppc/spapr_events.c b/hw/ppc/spapr_events.c > index 744ea62..1063036 100644 > --- a/hw/ppc/spapr_events.c > +++ b/hw/ppc/spapr_events.c > @@ -436,6 +436,9 @@ static void spapr_hotplug_req_event(uint8_t hp_id, uint8_t hp_action, > case SPAPR_DR_CONNECTOR_TYPE_LMB: > hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_MEMORY; > break; > + case SPAPR_DR_CONNECTOR_TYPE_CPU: > + hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_CPU; > + break; > default: > /* we shouldn't be signaling hotplug events for resources > * that don't support them > diff --git a/hw/ppc/spapr_rtas.c b/hw/ppc/spapr_rtas.c > index 34b12a3..7baa862 100644 > --- a/hw/ppc/spapr_rtas.c > +++ b/hw/ppc/spapr_rtas.c > @@ -33,6 +33,7 @@ > > #include "hw/ppc/spapr.h" > #include "hw/ppc/spapr_vio.h" > +#include "hw/ppc/ppc.h" > #include "qapi-event.h" > #include "hw/boards.h" > > @@ -159,6 +160,27 @@ static void rtas_query_cpu_stopped_state(PowerPCCPU *cpu_, > rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); > } > > +/* > + * Set the timebase offset of the CPU to that of first CPU. > + * This helps hotplugged CPU to have the correct timebase offset. > + */ > +static void spapr_cpu_update_tb_offset(PowerPCCPU *cpu) > +{ > + PowerPCCPU *fcpu = POWERPC_CPU(first_cpu); > + > + cpu->env.tb_env->tb_offset = fcpu->env.tb_env->tb_offset; > +} > + > +static void spapr_cpu_set_endianness(PowerPCCPU *cpu) > +{ > + PowerPCCPU *fcpu = POWERPC_CPU(first_cpu); > + PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(fcpu); > + > + if (!pcc->interrupts_big_endian(fcpu)) { > + cpu->env.spr[SPR_LPCR] |= LPCR_ILE; > + } > +} > + > static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr, > uint32_t token, uint32_t nargs, > target_ulong args, > @@ -195,6 +217,8 @@ static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr, > env->nip = start; > env->gpr[3] = r3; > cs->halted = 0; > + spapr_cpu_set_endianness(cpu); > + spapr_cpu_update_tb_offset(cpu); > > qemu_cpu_kick(cs); > > diff --git a/target-ppc/translate_init.c b/target-ppc/translate_init.c > index e88dc7f..245d73a 100644 > --- a/target-ppc/translate_init.c > +++ b/target-ppc/translate_init.c > @@ -30,6 +30,9 @@ > #include "qemu/error-report.h" > #include "qapi/visitor.h" > #include "hw/qdev-properties.h" > +#if !defined(CONFIG_USER_ONLY) > +#include "sysemu/sysemu.h" > +#endif > > //#define PPC_DUMP_CPU > //#define PPC_DEBUG_SPR > @@ -8933,6 +8936,11 @@ static void ppc_cpu_realizefn(DeviceState *dev, Error **errp) > } > > #if !defined(CONFIG_USER_ONLY) > + if (cs->cpu_index >= max_cpus) { > + error_setg(errp, "Cannot have more than %d CPUs", max_cpus); > + return; > + } > + > cpu->cpu_dt_id = (cs->cpu_index / smp_threads) * max_smt > + (cs->cpu_index % smp_threads); > #endif
On Tue, Dec 01, 2015 at 12:30:12PM +1100, David Gibson wrote: > On Fri, Nov 20, 2015 at 06:24:37PM +0530, Bharata B Rao wrote: > > Support CPU hotplug via device-add command. Set up device tree > > entries for the hotplugged CPU core and use the exising EPOW event > > infrastructure to send CPU hotplug notification to the guest. > > > > Create only cores explicitly from boot path as well as hotplug path > > and let the ->plug() handler of the core create the threads of the core. > > > > Also support cold plugged CPUs that are specified by -device option > > on cmdline. > > > > Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com> > > --- > > hw/ppc/spapr.c | 156 +++++++++++++++++++++++++++++++++++++++++++- > > hw/ppc/spapr_events.c | 3 + > > hw/ppc/spapr_rtas.c | 24 +++++++ > > target-ppc/translate_init.c | 8 +++ > > 4 files changed, 189 insertions(+), 2 deletions(-) > > > > diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c > > index 814b0a6..4434d45 100644 > > --- a/hw/ppc/spapr.c > > +++ b/hw/ppc/spapr.c > > @@ -596,6 +596,18 @@ static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, > > size_t page_sizes_prop_size; > > uint32_t vcpus_per_socket = smp_threads * smp_cores; > > uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; > > + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > > + sPAPRDRConnector *drc; > > + sPAPRDRConnectorClass *drck; > > + int drc_index; > > + > > + if (smc->dr_cpu_enabled) { > > + drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); > > + g_assert(drc); > > + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + drc_index = drck->get_index(drc); > > + _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); > > + } > > > > /* Note: we keep CI large pages off for now because a 64K capable guest > > * provisioned with large pages might otherwise try to map a qemu > > @@ -1739,6 +1751,7 @@ static void ppc_spapr_init(MachineState *machine) > > char *filename; > > int smt = kvmppc_smt_threads(); > > int smp_max_cores = DIV_ROUND_UP(max_cpus, smp_threads); > > + int spapr_smp_cores = DIV_ROUND_UP(smp_cpus, smp_threads); > > > > msi_supported = true; > > > > @@ -1818,7 +1831,7 @@ static void ppc_spapr_init(MachineState *machine) > > if (machine->cpu_model == NULL) { > > machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; > > } > > - for (i = 0; i < smp_cpus; i++) { > > + for (i = 0; i < spapr_smp_cores; i++) { > > cpu = cpu_ppc_init(machine->cpu_model); > > if (cpu == NULL) { > > fprintf(stderr, "Unable to find PowerPC CPU definition\n"); > > @@ -2207,10 +2220,135 @@ out: > > error_propagate(errp, local_err); > > } > > > > +static void *spapr_populate_hotplug_cpu_dt(DeviceState *dev, CPUState *cs, > > + int *fdt_offset, > > + sPAPRMachineState *spapr) > > +{ > > + PowerPCCPU *cpu = POWERPC_CPU(cs); > > + DeviceClass *dc = DEVICE_GET_CLASS(cs); > > + int id = ppc_get_vcpu_dt_id(cpu); > > + void *fdt; > > + int offset, fdt_size; > > + char *nodename; > > + > > + fdt = create_device_tree(&fdt_size); > > + nodename = g_strdup_printf("%s@%x", dc->fw_name, id); > > + offset = fdt_add_subnode(fdt, 0, nodename); > > + > > + spapr_populate_cpu_dt(cs, fdt, offset, spapr); > > + g_free(nodename); > > + > > + *fdt_offset = offset; > > + return fdt; > > +} > > + > > +static void spapr_cpu_plug(HotplugHandler *hotplug_dev, DeviceState *dev, > > + Error **errp) > > +{ > > + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > > + sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); > > + CPUState *cs = CPU(dev); > > + PowerPCCPU *cpu = POWERPC_CPU(cs); > > + int id = ppc_get_vcpu_dt_id(cpu); > > + sPAPRDRConnector *drc = > > + spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, id); > > + sPAPRDRConnectorClass *drck; > > + int smt = kvmppc_smt_threads(); > > + Error *local_err = NULL; > > + void *fdt = NULL; > > + int i, fdt_offset = 0; > > + > > + /* Set NUMA node for the added CPUs */ > > + for (i = 0; i < nb_numa_nodes; i++) { > > + if (test_bit(cs->cpu_index, numa_info[i].node_cpu)) { > > + cs->numa_node = i; > > + break; > > + } > > + } > > + > > + /* > > + * Currently CPU core and threads of a core aren't really different > > + * from QEMU point of view since all of them are just CPU devices. Hence > > + * there is no separate realize routines for cores and threads. > > + * We use the id check below to do things differently for cores and threads. > > + * > > + * SMT threads return from here, only main thread (core) will > > + * continue, create threads and signal hotplug event to the guest. > > + */ > > + if ((id % smt) != 0) { > > + return; > > + } > > Hmm. It seems odd to me to have thread 0 of a core handle the > initialization of the other threads, rather than creating an explicit > Core QOM object and have that construct the cpu objects for all > threads under it. All the threads will go through realize call and hence ->plug() call. So they all come here and we need the above check to ensure that we raise the EPOW interrupt to the guest only once. Having said that, I agree that it is not good to have main thread of the core creating other threads as is being done here. I am experimenting with an approach based on bits of what was discussed here earlier http://lists.nongnu.org/archive/html/qemu-devel/2015-04/msg00620.html In my current WIP patchset, I do have a core device that will result in CPU thread QOM objects getting created as children. I am experimenting to see if it will be possible to specify CPU as a generic device (for both boot time as well as hotplug) that works for all archs, will post something by early next week. Regards, Bharata.
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c index 814b0a6..4434d45 100644 --- a/hw/ppc/spapr.c +++ b/hw/ppc/spapr.c @@ -596,6 +596,18 @@ static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset, size_t page_sizes_prop_size; uint32_t vcpus_per_socket = smp_threads * smp_cores; uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)}; + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); + sPAPRDRConnector *drc; + sPAPRDRConnectorClass *drck; + int drc_index; + + if (smc->dr_cpu_enabled) { + drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index); + g_assert(drc); + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + drc_index = drck->get_index(drc); + _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index))); + } /* Note: we keep CI large pages off for now because a 64K capable guest * provisioned with large pages might otherwise try to map a qemu @@ -1739,6 +1751,7 @@ static void ppc_spapr_init(MachineState *machine) char *filename; int smt = kvmppc_smt_threads(); int smp_max_cores = DIV_ROUND_UP(max_cpus, smp_threads); + int spapr_smp_cores = DIV_ROUND_UP(smp_cpus, smp_threads); msi_supported = true; @@ -1818,7 +1831,7 @@ static void ppc_spapr_init(MachineState *machine) if (machine->cpu_model == NULL) { machine->cpu_model = kvm_enabled() ? "host" : "POWER7"; } - for (i = 0; i < smp_cpus; i++) { + for (i = 0; i < spapr_smp_cores; i++) { cpu = cpu_ppc_init(machine->cpu_model); if (cpu == NULL) { fprintf(stderr, "Unable to find PowerPC CPU definition\n"); @@ -2207,10 +2220,135 @@ out: error_propagate(errp, local_err); } +static void *spapr_populate_hotplug_cpu_dt(DeviceState *dev, CPUState *cs, + int *fdt_offset, + sPAPRMachineState *spapr) +{ + PowerPCCPU *cpu = POWERPC_CPU(cs); + DeviceClass *dc = DEVICE_GET_CLASS(cs); + int id = ppc_get_vcpu_dt_id(cpu); + void *fdt; + int offset, fdt_size; + char *nodename; + + fdt = create_device_tree(&fdt_size); + nodename = g_strdup_printf("%s@%x", dc->fw_name, id); + offset = fdt_add_subnode(fdt, 0, nodename); + + spapr_populate_cpu_dt(cs, fdt, offset, spapr); + g_free(nodename); + + *fdt_offset = offset; + return fdt; +} + +static void spapr_cpu_plug(HotplugHandler *hotplug_dev, DeviceState *dev, + Error **errp) +{ + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); + sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); + CPUState *cs = CPU(dev); + PowerPCCPU *cpu = POWERPC_CPU(cs); + int id = ppc_get_vcpu_dt_id(cpu); + sPAPRDRConnector *drc = + spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, id); + sPAPRDRConnectorClass *drck; + int smt = kvmppc_smt_threads(); + Error *local_err = NULL; + void *fdt = NULL; + int i, fdt_offset = 0; + + /* Set NUMA node for the added CPUs */ + for (i = 0; i < nb_numa_nodes; i++) { + if (test_bit(cs->cpu_index, numa_info[i].node_cpu)) { + cs->numa_node = i; + break; + } + } + + /* + * Currently CPU core and threads of a core aren't really different + * from QEMU point of view since all of them are just CPU devices. Hence + * there is no separate realize routines for cores and threads. + * We use the id check below to do things differently for cores and threads. + * + * SMT threads return from here, only main thread (core) will + * continue, create threads and signal hotplug event to the guest. + */ + if ((id % smt) != 0) { + return; + } + + /* Create SMT threads of the core. */ + for (i = 1; i < smp_threads; i++) { + cpu = cpu_ppc_init(current_machine->cpu_model); + if (!cpu) { + error_report("Unable to find PowerPC CPU definition: %s", + current_machine->cpu_model); + exit(EXIT_FAILURE); + } + } + + if (!smc->dr_cpu_enabled) { + /* + * This is a cold plugged CPU but the machine doesn't support + * DR. So skip the hotplug path ensuring that the CPU is brought + * up online with out an associated DR connector. + */ + return; + } + + g_assert(drc); + + /* + * Setup CPU DT entries only for hotplugged CPUs. For boot time or + * coldplugged CPUs DT entries are setup in spapr_finalize_fdt(). + */ + if (dev->hotplugged) { + fdt = spapr_populate_hotplug_cpu_dt(dev, cs, &fdt_offset, ms); + } + + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); + if (local_err) { + g_free(fdt); + error_propagate(errp, local_err); + return; + } + + /* + * We send hotplug notification interrupt to the guest only in case + * of hotplugged CPUs. + */ + if (dev->hotplugged) { + spapr_hotplug_req_add_by_index(drc); + } else { + /* + * HACK to support removal of hotplugged CPU after VM migration: + * + * Since we want to be able to hot-remove those coldplugged CPUs + * started at boot time using -device option at the target VM, we set + * the right allocation_state and isolation_state for them, which for + * the hotplugged CPUs would be set via RTAS calls done from the + * guest during hotplug. + * + * This allows the coldplugged CPUs started using -device option to + * have the right isolation and allocation states as expected by the + * CPU hot removal code. + * + * This hack will be removed once we have DRC states migrated as part + * of VM migration. + */ + drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); + drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_UNISOLATED); + } +} + static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp) { sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); + sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { int node; @@ -2247,6 +2385,19 @@ static void spapr_machine_device_plug(HotplugHandler *hotplug_dev, } spapr_memory_plug(hotplug_dev, dev, node, errp); + } else if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { + CPUState *cs = CPU(dev); + PowerPCCPU *cpu = POWERPC_CPU(cs); + + if (!smc->dr_cpu_enabled && dev->hotplugged) { + error_setg(errp, "CPU hotplug not supported for this machine"); + cpu_remove_sync(cs); + return; + } + + spapr_cpu_init(ms, cpu); + spapr_cpu_reset(cpu); + spapr_cpu_plug(hotplug_dev, dev, errp); } } @@ -2261,7 +2412,8 @@ static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev, static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine, DeviceState *dev) { - if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { + if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) || + object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { return HOTPLUG_HANDLER(machine); } return NULL; diff --git a/hw/ppc/spapr_events.c b/hw/ppc/spapr_events.c index 744ea62..1063036 100644 --- a/hw/ppc/spapr_events.c +++ b/hw/ppc/spapr_events.c @@ -436,6 +436,9 @@ static void spapr_hotplug_req_event(uint8_t hp_id, uint8_t hp_action, case SPAPR_DR_CONNECTOR_TYPE_LMB: hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_MEMORY; break; + case SPAPR_DR_CONNECTOR_TYPE_CPU: + hp->hotplug_type = RTAS_LOG_V6_HP_TYPE_CPU; + break; default: /* we shouldn't be signaling hotplug events for resources * that don't support them diff --git a/hw/ppc/spapr_rtas.c b/hw/ppc/spapr_rtas.c index 34b12a3..7baa862 100644 --- a/hw/ppc/spapr_rtas.c +++ b/hw/ppc/spapr_rtas.c @@ -33,6 +33,7 @@ #include "hw/ppc/spapr.h" #include "hw/ppc/spapr_vio.h" +#include "hw/ppc/ppc.h" #include "qapi-event.h" #include "hw/boards.h" @@ -159,6 +160,27 @@ static void rtas_query_cpu_stopped_state(PowerPCCPU *cpu_, rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); } +/* + * Set the timebase offset of the CPU to that of first CPU. + * This helps hotplugged CPU to have the correct timebase offset. + */ +static void spapr_cpu_update_tb_offset(PowerPCCPU *cpu) +{ + PowerPCCPU *fcpu = POWERPC_CPU(first_cpu); + + cpu->env.tb_env->tb_offset = fcpu->env.tb_env->tb_offset; +} + +static void spapr_cpu_set_endianness(PowerPCCPU *cpu) +{ + PowerPCCPU *fcpu = POWERPC_CPU(first_cpu); + PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(fcpu); + + if (!pcc->interrupts_big_endian(fcpu)) { + cpu->env.spr[SPR_LPCR] |= LPCR_ILE; + } +} + static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, @@ -195,6 +217,8 @@ static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr, env->nip = start; env->gpr[3] = r3; cs->halted = 0; + spapr_cpu_set_endianness(cpu); + spapr_cpu_update_tb_offset(cpu); qemu_cpu_kick(cs); diff --git a/target-ppc/translate_init.c b/target-ppc/translate_init.c index e88dc7f..245d73a 100644 --- a/target-ppc/translate_init.c +++ b/target-ppc/translate_init.c @@ -30,6 +30,9 @@ #include "qemu/error-report.h" #include "qapi/visitor.h" #include "hw/qdev-properties.h" +#if !defined(CONFIG_USER_ONLY) +#include "sysemu/sysemu.h" +#endif //#define PPC_DUMP_CPU //#define PPC_DEBUG_SPR @@ -8933,6 +8936,11 @@ static void ppc_cpu_realizefn(DeviceState *dev, Error **errp) } #if !defined(CONFIG_USER_ONLY) + if (cs->cpu_index >= max_cpus) { + error_setg(errp, "Cannot have more than %d CPUs", max_cpus); + return; + } + cpu->cpu_dt_id = (cs->cpu_index / smp_threads) * max_smt + (cs->cpu_index % smp_threads); #endif
Support CPU hotplug via device-add command. Set up device tree entries for the hotplugged CPU core and use the exising EPOW event infrastructure to send CPU hotplug notification to the guest. Create only cores explicitly from boot path as well as hotplug path and let the ->plug() handler of the core create the threads of the core. Also support cold plugged CPUs that are specified by -device option on cmdline. Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com> --- hw/ppc/spapr.c | 156 +++++++++++++++++++++++++++++++++++++++++++- hw/ppc/spapr_events.c | 3 + hw/ppc/spapr_rtas.c | 24 +++++++ target-ppc/translate_init.c | 8 +++ 4 files changed, 189 insertions(+), 2 deletions(-)