On Wed, 16 Mar 2016 16:19:33 +1100 David Gibson <da...@gibson.dropbear.id.au> wrote:
> On Fri, Mar 11, 2016 at 10:24:36AM +0530, Bharata B Rao wrote: > > Set up device tree entries for the hotplugged CPU core and use the > > exising RTAS event logging infrastructure to send CPU hotplug notification > > to the guest. > > > > Signed-off-by: Bharata B Rao <bhar...@linux.vnet.ibm.com> > > --- > > hw/ppc/spapr.c | 64 ++++++++++++++++++++++++++++++++++++++ > > hw/ppc/spapr_cpu_core.c | 69 > > +++++++++++++++++++++++++++++++++++++++++ > > hw/ppc/spapr_events.c | 3 ++ > > hw/ppc/spapr_rtas.c | 24 ++++++++++++++ > > include/hw/ppc/spapr.h | 2 ++ > > include/hw/ppc/spapr_cpu_core.h | 2 ++ > > 6 files changed, 164 insertions(+) > > > > diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c > > index cffe8c8..822c87d 100644 > > --- a/hw/ppc/spapr.c > > +++ b/hw/ppc/spapr.c > > @@ -603,6 +603,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); > > Small nit: rather than asserting here it might be simpler to just > check for drc != NULL instead of checking smc->dr_cpu_enabled. That > should have the same effect for now, and will be correct if we ever > have some pluggable and some non-pluggable CPUs... > > > + 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 > > @@ -987,6 +999,16 @@ static void spapr_finalize_fdt(sPAPRMachineState > > *spapr, > > _FDT(spapr_drc_populate_dt(fdt, 0, NULL, > > SPAPR_DR_CONNECTOR_TYPE_LMB)); > > } > > > > + if (smc->dr_cpu_enabled) { > > + int offset = fdt_path_offset(fdt, "/cpus"); > > + ret = spapr_drc_populate_dt(fdt, offset, NULL, > > + SPAPR_DR_CONNECTOR_TYPE_CPU); > > + if (ret < 0) { > > + error_report("Couldn't set up CPU DR device tree properties"); > > + exit(1); > > + } > > + } > > + > > _FDT((fdt_pack(fdt))); > > > > if (fdt_totalsize(fdt) > FDT_MAX_SIZE) { > > @@ -1622,6 +1644,8 @@ static void spapr_boot_set(void *opaque, const char > > *boot_device, > > void spapr_cpu_init(sPAPRMachineState *spapr, PowerPCCPU *cpu, Error > > **errp) > > { > > CPUPPCState *env = &cpu->env; > > + CPUState *cs = CPU(cpu); > > + int i; > > > > /* Set time-base frequency to 512 MHz */ > > cpu_ppc_tb_init(env, TIMEBASE_FREQ); > > @@ -1646,6 +1670,14 @@ void spapr_cpu_init(sPAPRMachineState *spapr, > > PowerPCCPU *cpu, Error **errp) > > } > > } > > > > + /* 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; > > + } > > + } > > + > > xics_cpu_setup(spapr->icp, cpu); > > > > qemu_register_reset(spapr_cpu_reset, cpu); > > @@ -1824,6 +1856,11 @@ static void ppc_spapr_init(MachineState *machine) > > > > for (i = 0; i < spapr_max_cores; i++) { > > int core_dt_id = i * smt; > > + sPAPRDRConnector *drc = > > + spapr_dr_connector_new(OBJECT(spapr), > > + SPAPR_DR_CONNECTOR_TYPE_CPU, > > core_dt_id); > > + > > + qemu_register_reset(spapr_drc_reset, drc); > > ...at least it will be if you make construction of the DRC object > conditional on dr_cpu_enabled. > > > if (i < spapr_cores) { > > Object *core = object_new(TYPE_SPAPR_CPU_CORE); > > @@ -2246,6 +2283,27 @@ out: > > error_propagate(errp, local_err); > > } > > > > +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_machine_device_plug(HotplugHandler *hotplug_dev, > > DeviceState *dev, Error **errp) > > { > > @@ -2286,6 +2344,12 @@ 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_SPAPR_CPU_CORE)) { > > + if (!smc->dr_cpu_enabled && dev->hotplugged) { > > + error_setg(errp, "CPU hotplug not supported for this machine"); > > + return; > > + } > > + spapr_core_plug(hotplug_dev, dev, errp); > > } > > } > > > > diff --git a/hw/ppc/spapr_cpu_core.c b/hw/ppc/spapr_cpu_core.c > > index 8c6d71d..db8de32 100644 > > --- a/hw/ppc/spapr_cpu_core.c > > +++ b/hw/ppc/spapr_cpu_core.c > > @@ -15,6 +15,75 @@ > > #include <sysemu/cpus.h> > > #include "target-ppc/kvm_ppc.h" > > > > +void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, > > + Error **errp) > > +{ > > + sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine()); > > + sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); > > + sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); > > + CPUState *cs = CPU(&core->threads[0]); > > + sPAPRDRConnector *drc; > > + sPAPRDRConnectorClass *drck; > > + Error *local_err = NULL; > > + void *fdt = NULL; > > + int fdt_offset = 0; > > + int core_id, core_dt_id; > > + int smt = kvmppc_smt_threads(); > > + > > + /* TODO: Should we cache core_id in sPAPRCPUCore ? */ > > + core_dt_id = object_property_get_int(OBJECT(dev), "core", > > &local_err); > > As Igor pointed out elsewhere you should just be able to do > CPU_CORE(dev)->core. not exactly like this, from what I know that's not approved style, it should be something like this: CPUCore *cc = CPU_CORE(dev); ... cc->core ... > > > + if (local_err) { > > + error_propagate(errp, local_err); > > + return; > > + } > > + drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, > > core_dt_id); > > + core_id = core_dt_id / smt; > > + spapr->cores[core_id] = OBJECT(dev); > > + > > + if (!smc->dr_cpu_enabled) { > > + /* > > + * This is a cold plugged CPU core but the machine doesn't support > > + * DR. So skip the hotplug path ensuring that the core 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, spapr); > > + dev->hotplugged = true; > > + } > > + > > + drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, &local_err); > > + if (local_err) { > > + g_free(fdt); > > + spapr->cores[core_id] = NULL; > > + error_propagate(errp, local_err); > > + return; > > + } > > + > > + if (dev->hotplugged) { > > + /* > > + * Send hotplug notification interrupt to the guest only in case > > + * of hotplugged CPUs. > > + */ > > + spapr_hotplug_req_add_by_index(drc); > > + } else { > > + /* > > + * Set the right DRC states for cold plugged CPU. > > + */ > > + drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_USABLE); > > + drck->set_isolation_state(drc, > > SPAPR_DR_ISOLATION_STATE_UNISOLATED); > > + } > > +} > > + > > static void spapr_cpu_core_create_threads(sPAPRCPUCore *core, int threads, > > Error **errp) > > { > > diff --git a/hw/ppc/spapr_events.c b/hw/ppc/spapr_events.c > > index 39f4682..10340e1 100644 > > --- a/hw/ppc/spapr_events.c > > +++ b/hw/ppc/spapr_events.c > > @@ -437,6 +437,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 b7c5ebd..cc0369e 100644 > > --- a/hw/ppc/spapr_rtas.c > > +++ b/hw/ppc/spapr_rtas.c > > @@ -34,6 +34,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" > > > > @@ -161,6 +162,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, > > @@ -197,6 +219,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/include/hw/ppc/spapr.h b/include/hw/ppc/spapr.h > > index c099c3c..8957072 100644 > > --- a/include/hw/ppc/spapr.h > > +++ b/include/hw/ppc/spapr.h > > @@ -589,6 +589,8 @@ void > > spapr_hotplug_req_remove_by_count(sPAPRDRConnectorType drc_type, > > uint32_t count); > > void spapr_cpu_init(sPAPRMachineState *spapr, PowerPCCPU *cpu, Error > > **errp); > > void spapr_cpu_reset(void *opaque); > > +void *spapr_populate_hotplug_cpu_dt(DeviceState *dev, CPUState *cs, > > + int *fdt_offset, sPAPRMachineState > > *spapr); > > > > /* rtas-configure-connector state */ > > struct sPAPRConfigureConnectorState { > > diff --git a/include/hw/ppc/spapr_cpu_core.h > > b/include/hw/ppc/spapr_cpu_core.h > > index 48fb76a..980d8ae 100644 > > --- a/include/hw/ppc/spapr_cpu_core.h > > +++ b/include/hw/ppc/spapr_cpu_core.h > > @@ -25,4 +25,6 @@ typedef struct sPAPRCPUCore { > > PowerPCCPU *threads; > > } sPAPRCPUCore; > > > > +void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, > > + Error **errp); > > #endif >