2 * sPAPR CPU core device, acts as container of CPU thread devices.
4 * Copyright (C) 2016 Bharata B Rao <bharata@linux.vnet.ibm.com>
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
9 #include "hw/cpu/core.h"
10 #include "hw/ppc/spapr_cpu_core.h"
11 #include "target/ppc/cpu.h"
12 #include "hw/ppc/spapr.h"
13 #include "hw/boards.h"
14 #include "qapi/error.h"
15 #include "sysemu/cpus.h"
16 #include "sysemu/kvm.h"
17 #include "target/ppc/kvm_ppc.h"
18 #include "hw/ppc/ppc.h"
19 #include "target/ppc/mmu-hash64.h"
20 #include "sysemu/numa.h"
21 #include "qemu/error-report.h"
23 void spapr_cpu_parse_features(sPAPRMachineState
*spapr
)
26 * Backwards compatibility hack:
28 * CPUs had a "compat=" property which didn't make sense for
29 * anything except pseries. It was replaced by "max-cpu-compat"
30 * machine option. This supports old command lines like
31 * -cpu POWER8,compat=power7
32 * By stripping the compat option and applying it to the machine
33 * before passing it on to the cpu level parser.
37 gchar
*compat_str
= NULL
;
39 inpieces
= g_strsplit(MACHINE(spapr
)->cpu_model
, ",", 0);
41 /* inpieces[0] is the actual model string */
45 if (g_str_has_prefix(inpieces
[i
], "compat=")) {
46 /* in case of multiple compat= options */
48 compat_str
= inpieces
[i
];
54 /* Excise compat options from list */
55 inpieces
[j
] = inpieces
[i
];
59 char *val
= compat_str
+ strlen("compat=");
60 gchar
*newprops
= g_strjoinv(",", inpieces
);
62 object_property_set_str(OBJECT(spapr
), val
, "max-cpu-compat",
65 ppc_cpu_parse_features(newprops
);
68 ppc_cpu_parse_features(MACHINE(spapr
)->cpu_model
);
74 static void spapr_cpu_reset(void *opaque
)
76 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
77 PowerPCCPU
*cpu
= opaque
;
78 CPUState
*cs
= CPU(cpu
);
79 CPUPPCState
*env
= &cpu
->env
;
83 /* All CPUs start halted. CPU0 is unhalted from the machine level
84 * reset code and the rest are explicitly started up by the guest
85 * using an RTAS call */
88 env
->spr
[SPR_HIOR
] = 0;
91 * This is a hack for the benefit of KVM PR - it abuses the SDR1
92 * slot in kvm_sregs to communicate the userspace address of the
96 env
->spr
[SPR_SDR1
] = (target_ulong
)(uintptr_t)spapr
->htab
97 | (spapr
->htab_shift
- 18);
98 if (kvmppc_put_books_sregs(cpu
) < 0) {
99 error_report("Unable to update SDR1 in KVM");
105 static void spapr_cpu_destroy(PowerPCCPU
*cpu
)
107 qemu_unregister_reset(spapr_cpu_reset
, cpu
);
110 static void spapr_cpu_init(sPAPRMachineState
*spapr
, PowerPCCPU
*cpu
,
113 CPUPPCState
*env
= &cpu
->env
;
115 /* Set time-base frequency to 512 MHz */
116 cpu_ppc_tb_init(env
, SPAPR_TIMEBASE_FREQ
);
118 /* Enable PAPR mode in TCG or KVM */
119 cpu_ppc_set_papr(cpu
, PPC_VIRTUAL_HYPERVISOR(spapr
));
121 qemu_register_reset(spapr_cpu_reset
, cpu
);
122 spapr_cpu_reset(cpu
);
126 * Return the sPAPR CPU core type for @model which essentially is the CPU
127 * model specified with -cpu cmdline option.
129 char *spapr_get_cpu_core_type(const char *model
)
132 gchar
**model_pieces
= g_strsplit(model
, ",", 2);
133 gchar
*cpu_model
= g_ascii_strdown(model_pieces
[0], -1);
134 g_strfreev(model_pieces
);
136 core_type
= g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE
, cpu_model
);
138 /* Check whether it exists or whether we have to look up an alias name */
139 if (!object_class_by_name(core_type
)) {
140 const char *realmodel
;
144 realmodel
= ppc_cpu_lookup_alias(cpu_model
);
146 core_type
= spapr_get_cpu_core_type(realmodel
);
154 static void spapr_cpu_core_unrealizefn(DeviceState
*dev
, Error
**errp
)
156 sPAPRCPUCore
*sc
= SPAPR_CPU_CORE(OBJECT(dev
));
157 sPAPRCPUCoreClass
*scc
= SPAPR_CPU_CORE_GET_CLASS(OBJECT(dev
));
158 const char *typename
= object_class_get_name(scc
->cpu_class
);
159 size_t size
= object_type_get_instance_size(typename
);
160 CPUCore
*cc
= CPU_CORE(dev
);
163 for (i
= 0; i
< cc
->nr_threads
; i
++) {
164 void *obj
= sc
->threads
+ i
* size
;
165 DeviceState
*dev
= DEVICE(obj
);
166 CPUState
*cs
= CPU(dev
);
167 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
169 spapr_cpu_destroy(cpu
);
170 object_unparent(cpu
->intc
);
172 object_unparent(obj
);
177 static void spapr_cpu_core_realize_child(Object
*child
,
178 sPAPRMachineState
*spapr
, Error
**errp
)
180 Error
*local_err
= NULL
;
181 CPUState
*cs
= CPU(child
);
182 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
185 object_property_set_bool(child
, true, "realized", &local_err
);
190 spapr_cpu_init(spapr
, cpu
, &local_err
);
195 obj
= object_new(spapr
->icp_type
);
196 object_property_add_child(child
, "icp", obj
, &error_abort
);
198 object_property_add_const_link(obj
, ICP_PROP_XICS
, OBJECT(spapr
),
200 object_property_add_const_link(obj
, ICP_PROP_CPU
, child
, &error_abort
);
201 object_property_set_bool(obj
, true, "realized", &local_err
);
209 object_unparent(obj
);
211 error_propagate(errp
, local_err
);
214 static void spapr_cpu_core_realize(DeviceState
*dev
, Error
**errp
)
216 sPAPRMachineState
*spapr
;
217 sPAPRCPUCore
*sc
= SPAPR_CPU_CORE(OBJECT(dev
));
218 sPAPRCPUCoreClass
*scc
= SPAPR_CPU_CORE_GET_CLASS(OBJECT(dev
));
219 CPUCore
*cc
= CPU_CORE(OBJECT(dev
));
220 const char *typename
= object_class_get_name(scc
->cpu_class
);
221 size_t size
= object_type_get_instance_size(typename
);
222 Error
*local_err
= NULL
;
226 spapr
= (sPAPRMachineState
*) qdev_get_machine();
227 if (!object_dynamic_cast((Object
*) spapr
, TYPE_SPAPR_MACHINE
)) {
228 error_setg(errp
, "spapr-cpu-core needs a pseries machine");
232 sc
->threads
= g_malloc0(size
* cc
->nr_threads
);
233 for (i
= 0; i
< cc
->nr_threads
; i
++) {
238 obj
= sc
->threads
+ i
* size
;
240 object_initialize(obj
, size
, typename
);
242 cpu
= POWERPC_CPU(cs
);
243 cs
->cpu_index
= cc
->core_id
+ i
;
244 cpu
->vcpu_id
= (cc
->core_id
* spapr
->vsmt
/ smp_threads
) + i
;
245 if (kvm_enabled() && !kvm_vcpu_id_is_valid(cpu
->vcpu_id
)) {
246 error_setg(&local_err
, "Can't create CPU with id %d in KVM",
248 error_append_hint(&local_err
, "Adjust the number of cpus to %d "
249 "or try to raise the number of threads per core\n",
250 cpu
->vcpu_id
* smp_threads
/ spapr
->vsmt
);
255 /* Set NUMA node for the threads belonged to core */
256 cpu
->node_id
= sc
->node_id
;
258 snprintf(id
, sizeof(id
), "thread[%d]", i
);
259 object_property_add_child(OBJECT(sc
), id
, obj
, &local_err
);
266 for (j
= 0; j
< cc
->nr_threads
; j
++) {
267 obj
= sc
->threads
+ j
* size
;
269 spapr_cpu_core_realize_child(obj
, spapr
, &local_err
);
278 obj
= sc
->threads
+ i
* size
;
279 object_unparent(obj
);
282 error_propagate(errp
, local_err
);
285 static const char *spapr_core_models
[] = {
315 static Property spapr_cpu_core_properties
[] = {
316 DEFINE_PROP_INT32("node-id", sPAPRCPUCore
, node_id
, CPU_UNSET_NUMA_NODE_ID
),
317 DEFINE_PROP_END_OF_LIST()
320 void spapr_cpu_core_class_init(ObjectClass
*oc
, void *data
)
322 DeviceClass
*dc
= DEVICE_CLASS(oc
);
323 sPAPRCPUCoreClass
*scc
= SPAPR_CPU_CORE_CLASS(oc
);
325 dc
->realize
= spapr_cpu_core_realize
;
326 dc
->unrealize
= spapr_cpu_core_unrealizefn
;
327 dc
->props
= spapr_cpu_core_properties
;
328 scc
->cpu_class
= cpu_class_by_name(TYPE_POWERPC_CPU
, data
);
329 g_assert(scc
->cpu_class
);
332 static const TypeInfo spapr_cpu_core_type_info
= {
333 .name
= TYPE_SPAPR_CPU_CORE
,
334 .parent
= TYPE_CPU_CORE
,
336 .instance_size
= sizeof(sPAPRCPUCore
),
337 .class_size
= sizeof(sPAPRCPUCoreClass
),
340 static void spapr_cpu_core_register_types(void)
344 type_register_static(&spapr_cpu_core_type_info
);
346 for (i
= 0; i
< ARRAY_SIZE(spapr_core_models
); i
++) {
347 TypeInfo type_info
= {
348 .parent
= TYPE_SPAPR_CPU_CORE
,
349 .instance_size
= sizeof(sPAPRCPUCore
),
350 .class_init
= spapr_cpu_core_class_init
,
351 .class_data
= (void *) spapr_core_models
[i
],
354 type_info
.name
= g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE
,
355 spapr_core_models
[i
]);
356 type_register(&type_info
);
357 g_free((void *)type_info
.name
);
361 type_init(spapr_cpu_core_register_types
)