2 * QEMU PowerPC pSeries Logical Partition capabilities handling
4 * Copyright (c) 2017 David Gibson, Red Hat Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qemu/error-report.h"
26 #include "qapi/error.h"
27 #include "qapi/visitor.h"
28 #include "sysemu/hw_accel.h"
29 #include "target/ppc/cpu.h"
30 #include "cpu-models.h"
33 #include "hw/ppc/spapr.h"
35 typedef struct sPAPRCapabilityInfo
{
37 const char *description
;
40 /* Getter and Setter Function Pointers */
41 ObjectPropertyAccessor
*get
;
42 ObjectPropertyAccessor
*set
;
44 /* Make sure the virtual hardware can support this capability */
45 void (*apply
)(sPAPRMachineState
*spapr
, uint8_t val
, Error
**errp
);
46 } sPAPRCapabilityInfo
;
48 static void spapr_cap_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
49 void *opaque
, Error
**errp
)
51 sPAPRCapabilityInfo
*cap
= opaque
;
52 sPAPRMachineState
*spapr
= SPAPR_MACHINE(obj
);
53 bool value
= spapr_get_cap(spapr
, cap
->index
) == SPAPR_CAP_ON
;
55 visit_type_bool(v
, name
, &value
, errp
);
58 static void spapr_cap_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
59 void *opaque
, Error
**errp
)
61 sPAPRCapabilityInfo
*cap
= opaque
;
62 sPAPRMachineState
*spapr
= SPAPR_MACHINE(obj
);
64 Error
*local_err
= NULL
;
66 visit_type_bool(v
, name
, &value
, &local_err
);
68 error_propagate(errp
, local_err
);
72 spapr
->cmd_line_caps
[cap
->index
] = true;
73 spapr
->eff
.caps
[cap
->index
] = value
? SPAPR_CAP_ON
: SPAPR_CAP_OFF
;
76 static void spapr_cap_get_tristate(Object
*obj
, Visitor
*v
, const char *name
,
77 void *opaque
, Error
**errp
)
79 sPAPRCapabilityInfo
*cap
= opaque
;
80 sPAPRMachineState
*spapr
= SPAPR_MACHINE(obj
);
82 uint8_t value
= spapr_get_cap(spapr
, cap
->index
);
85 case SPAPR_CAP_BROKEN
:
86 val
= g_strdup("broken");
88 case SPAPR_CAP_WORKAROUND
:
89 val
= g_strdup("workaround");
92 val
= g_strdup("fixed");
95 error_setg(errp
, "Invalid value (%d) for cap-%s", value
, cap
->name
);
99 visit_type_str(v
, name
, &val
, errp
);
103 static void spapr_cap_set_tristate(Object
*obj
, Visitor
*v
, const char *name
,
104 void *opaque
, Error
**errp
)
106 sPAPRCapabilityInfo
*cap
= opaque
;
107 sPAPRMachineState
*spapr
= SPAPR_MACHINE(obj
);
109 Error
*local_err
= NULL
;
112 visit_type_str(v
, name
, &val
, &local_err
);
114 error_propagate(errp
, local_err
);
118 if (!strcasecmp(val
, "broken")) {
119 value
= SPAPR_CAP_BROKEN
;
120 } else if (!strcasecmp(val
, "workaround")) {
121 value
= SPAPR_CAP_WORKAROUND
;
122 } else if (!strcasecmp(val
, "fixed")) {
123 value
= SPAPR_CAP_FIXED
;
125 error_setg(errp
, "Invalid capability mode \"%s\" for cap-%s", val
,
130 spapr
->cmd_line_caps
[cap
->index
] = true;
131 spapr
->eff
.caps
[cap
->index
] = value
;
136 static void cap_htm_apply(sPAPRMachineState
*spapr
, uint8_t val
, Error
**errp
)
139 /* TODO: We don't support disabling htm yet */
144 "No Transactional Memory support in TCG, try cap-htm=off");
145 } else if (kvm_enabled() && !kvmppc_has_cap_htm()) {
147 "KVM implementation does not support Transactional Memory, try cap-htm=off"
152 static void cap_vsx_apply(sPAPRMachineState
*spapr
, uint8_t val
, Error
**errp
)
154 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
155 CPUPPCState
*env
= &cpu
->env
;
158 /* TODO: We don't support disabling vsx yet */
161 /* Allowable CPUs in spapr_cpu_core.c should already have gotten
162 * rid of anything that doesn't do VMX */
163 g_assert(env
->insns_flags
& PPC_ALTIVEC
);
164 if (!(env
->insns_flags2
& PPC2_VSX
)) {
165 error_setg(errp
, "VSX support not available, try cap-vsx=off");
169 static void cap_dfp_apply(sPAPRMachineState
*spapr
, uint8_t val
, Error
**errp
)
171 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
172 CPUPPCState
*env
= &cpu
->env
;
175 /* TODO: We don't support disabling dfp yet */
178 if (!(env
->insns_flags2
& PPC2_DFP
)) {
179 error_setg(errp
, "DFP support not available, try cap-dfp=off");
183 static void cap_safe_cache_apply(sPAPRMachineState
*spapr
, uint8_t val
,
186 if (tcg_enabled() && val
) {
187 /* TODO - for now only allow broken for TCG */
188 error_setg(errp
, "Requested safe cache capability level not supported by tcg, try a different value for cap-cfpc");
189 } else if (kvm_enabled() && (val
> kvmppc_get_cap_safe_cache())) {
190 error_setg(errp
, "Requested safe cache capability level not supported by kvm, try a different value for cap-cfpc");
194 static void cap_safe_bounds_check_apply(sPAPRMachineState
*spapr
, uint8_t val
,
197 if (tcg_enabled() && val
) {
198 /* TODO - for now only allow broken for TCG */
199 error_setg(errp
, "Requested safe bounds check capability level not supported by tcg, try a different value for cap-sbbc");
200 } else if (kvm_enabled() && (val
> kvmppc_get_cap_safe_bounds_check())) {
201 error_setg(errp
, "Requested safe bounds check capability level not supported by kvm, try a different value for cap-sbbc");
205 static void cap_safe_indirect_branch_apply(sPAPRMachineState
*spapr
,
206 uint8_t val
, Error
**errp
)
208 if (tcg_enabled() && val
) {
209 /* TODO - for now only allow broken for TCG */
210 error_setg(errp
, "Requested safe indirect branch capability level not supported by tcg, try a different value for cap-ibs");
211 } else if (kvm_enabled() && (val
> kvmppc_get_cap_safe_indirect_branch())) {
212 error_setg(errp
, "Requested safe indirect branch capability level not supported by kvm, try a different value for cap-ibs");
216 #define VALUE_DESC_TRISTATE " (broken, workaround, fixed)"
218 sPAPRCapabilityInfo capability_table
[SPAPR_CAP_NUM
] = {
221 .description
= "Allow Hardware Transactional Memory (HTM)",
222 .index
= SPAPR_CAP_HTM
,
223 .get
= spapr_cap_get_bool
,
224 .set
= spapr_cap_set_bool
,
226 .apply
= cap_htm_apply
,
230 .description
= "Allow Vector Scalar Extensions (VSX)",
231 .index
= SPAPR_CAP_VSX
,
232 .get
= spapr_cap_get_bool
,
233 .set
= spapr_cap_set_bool
,
235 .apply
= cap_vsx_apply
,
239 .description
= "Allow Decimal Floating Point (DFP)",
240 .index
= SPAPR_CAP_DFP
,
241 .get
= spapr_cap_get_bool
,
242 .set
= spapr_cap_set_bool
,
244 .apply
= cap_dfp_apply
,
248 .description
= "Cache Flush on Privilege Change" VALUE_DESC_TRISTATE
,
249 .index
= SPAPR_CAP_CFPC
,
250 .get
= spapr_cap_get_tristate
,
251 .set
= spapr_cap_set_tristate
,
253 .apply
= cap_safe_cache_apply
,
257 .description
= "Speculation Barrier Bounds Checking" VALUE_DESC_TRISTATE
,
258 .index
= SPAPR_CAP_SBBC
,
259 .get
= spapr_cap_get_tristate
,
260 .set
= spapr_cap_set_tristate
,
262 .apply
= cap_safe_bounds_check_apply
,
266 .description
= "Indirect Branch Serialisation" VALUE_DESC_TRISTATE
,
267 .index
= SPAPR_CAP_IBS
,
268 .get
= spapr_cap_get_tristate
,
269 .set
= spapr_cap_set_tristate
,
271 .apply
= cap_safe_indirect_branch_apply
,
275 static sPAPRCapabilities
default_caps_with_cpu(sPAPRMachineState
*spapr
,
278 sPAPRMachineClass
*smc
= SPAPR_MACHINE_GET_CLASS(spapr
);
279 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
280 sPAPRCapabilities caps
;
282 caps
= smc
->default_caps
;
284 if (!ppc_check_compat(cpu
, CPU_POWERPC_LOGICAL_2_07
,
285 0, spapr
->max_compat_pvr
)) {
286 caps
.caps
[SPAPR_CAP_HTM
] = SPAPR_CAP_OFF
;
289 if (!ppc_check_compat(cpu
, CPU_POWERPC_LOGICAL_2_06
,
290 0, spapr
->max_compat_pvr
)) {
291 caps
.caps
[SPAPR_CAP_VSX
] = SPAPR_CAP_OFF
;
292 caps
.caps
[SPAPR_CAP_DFP
] = SPAPR_CAP_OFF
;
298 int spapr_caps_pre_load(void *opaque
)
300 sPAPRMachineState
*spapr
= opaque
;
302 /* Set to default so we can tell if this came in with the migration */
303 spapr
->mig
= spapr
->def
;
307 int spapr_caps_pre_save(void *opaque
)
309 sPAPRMachineState
*spapr
= opaque
;
311 spapr
->mig
= spapr
->eff
;
315 /* This has to be called from the top-level spapr post_load, not the
316 * caps specific one. Otherwise it wouldn't be called when the source
317 * caps are all defaults, which could still conflict with overridden
318 * caps on the destination */
319 int spapr_caps_post_migration(sPAPRMachineState
*spapr
)
323 sPAPRCapabilities dstcaps
= spapr
->eff
;
324 sPAPRCapabilities srccaps
;
326 srccaps
= default_caps_with_cpu(spapr
, first_cpu
);
327 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
328 /* If not default value then assume came in with the migration */
329 if (spapr
->mig
.caps
[i
] != spapr
->def
.caps
[i
]) {
330 srccaps
.caps
[i
] = spapr
->mig
.caps
[i
];
334 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
335 sPAPRCapabilityInfo
*info
= &capability_table
[i
];
337 if (srccaps
.caps
[i
] > dstcaps
.caps
[i
]) {
338 error_report("cap-%s higher level (%d) in incoming stream than on destination (%d)",
339 info
->name
, srccaps
.caps
[i
], dstcaps
.caps
[i
]);
343 if (srccaps
.caps
[i
] < dstcaps
.caps
[i
]) {
344 warn_report("cap-%s lower level (%d) in incoming stream than on destination (%d)",
345 info
->name
, srccaps
.caps
[i
], dstcaps
.caps
[i
]);
349 return ok
? 0 : -EINVAL
;
352 /* Used to generate the migration field and needed function for a spapr cap */
353 #define SPAPR_CAP_MIG_STATE(cap, ccap) \
354 static bool spapr_cap_##cap##_needed(void *opaque) \
356 sPAPRMachineState *spapr = opaque; \
358 return spapr->cmd_line_caps[SPAPR_CAP_##ccap] && \
359 (spapr->eff.caps[SPAPR_CAP_##ccap] != \
360 spapr->def.caps[SPAPR_CAP_##ccap]); \
363 const VMStateDescription vmstate_spapr_cap_##cap = { \
364 .name = "spapr/cap/" #cap, \
366 .minimum_version_id = 1, \
367 .needed = spapr_cap_##cap##_needed, \
368 .fields = (VMStateField[]) { \
369 VMSTATE_UINT8(mig.caps[SPAPR_CAP_##ccap], \
370 sPAPRMachineState), \
371 VMSTATE_END_OF_LIST() \
375 SPAPR_CAP_MIG_STATE(htm
, HTM
);
376 SPAPR_CAP_MIG_STATE(vsx
, VSX
);
377 SPAPR_CAP_MIG_STATE(dfp
, DFP
);
378 SPAPR_CAP_MIG_STATE(cfpc
, CFPC
);
379 SPAPR_CAP_MIG_STATE(sbbc
, SBBC
);
380 SPAPR_CAP_MIG_STATE(ibs
, IBS
);
382 void spapr_caps_reset(sPAPRMachineState
*spapr
)
384 sPAPRCapabilities default_caps
;
387 /* First compute the actual set of caps we're running with.. */
388 default_caps
= default_caps_with_cpu(spapr
, first_cpu
);
390 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
391 /* Store the defaults */
392 spapr
->def
.caps
[i
] = default_caps
.caps
[i
];
393 /* If not set on the command line then apply the default value */
394 if (!spapr
->cmd_line_caps
[i
]) {
395 spapr
->eff
.caps
[i
] = default_caps
.caps
[i
];
399 /* .. then apply those caps to the virtual hardware */
401 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
402 sPAPRCapabilityInfo
*info
= &capability_table
[i
];
405 * If the apply function can't set the desired level and thinks it's
406 * fatal, it should cause that.
408 info
->apply(spapr
, spapr
->eff
.caps
[i
], &error_fatal
);
412 void spapr_caps_add_properties(sPAPRMachineClass
*smc
, Error
**errp
)
414 Error
*local_err
= NULL
;
415 ObjectClass
*klass
= OBJECT_CLASS(smc
);
418 for (i
= 0; i
< ARRAY_SIZE(capability_table
); i
++) {
419 sPAPRCapabilityInfo
*cap
= &capability_table
[i
];
420 const char *name
= g_strdup_printf("cap-%s", cap
->name
);
423 object_class_property_add(klass
, name
, cap
->type
,
425 NULL
, cap
, &local_err
);
427 error_propagate(errp
, local_err
);
431 desc
= g_strdup_printf("%s", cap
->description
);
432 object_class_property_set_description(klass
, name
, desc
, &local_err
);
435 error_propagate(errp
, local_err
);