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
25 #include "qemu/osdep.h"
26 #include "qemu/error-report.h"
27 #include "qapi/error.h"
28 #include "qapi/visitor.h"
29 #include "sysemu/hw_accel.h"
30 #include "exec/ram_addr.h"
31 #include "target/ppc/cpu.h"
32 #include "target/ppc/mmu-hash64.h"
33 #include "cpu-models.h"
35 #include "migration/vmstate.h"
36 #include "sysemu/qtest.h"
37 #include "sysemu/tcg.h"
39 #include "hw/ppc/spapr.h"
41 typedef struct SpaprCapPossible
{
42 int num
; /* size of vals array below */
43 const char *help
; /* help text for vals */
46 * - because of the way compatibility is determined vals MUST be ordered
47 * such that later options are a superset of all preceding options.
48 * - the order of vals must be preserved, that is their index is important,
49 * however vals may be added to the end of the list so long as the above
55 typedef struct SpaprCapabilityInfo
{
57 const char *description
;
60 /* Getter and Setter Function Pointers */
61 ObjectPropertyAccessor
*get
;
62 ObjectPropertyAccessor
*set
;
64 /* Possible values if this is a custom string type */
65 SpaprCapPossible
*possible
;
66 /* Make sure the virtual hardware can support this capability */
67 void (*apply
)(SpaprMachineState
*spapr
, uint8_t val
, Error
**errp
);
68 void (*cpu_apply
)(SpaprMachineState
*spapr
, PowerPCCPU
*cpu
,
69 uint8_t val
, Error
**errp
);
70 bool (*migrate_needed
)(void *opaque
);
71 } SpaprCapabilityInfo
;
73 static void spapr_cap_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
74 void *opaque
, Error
**errp
)
76 SpaprCapabilityInfo
*cap
= opaque
;
77 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
78 bool value
= spapr_get_cap(spapr
, cap
->index
) == SPAPR_CAP_ON
;
80 visit_type_bool(v
, name
, &value
, errp
);
83 static void spapr_cap_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
84 void *opaque
, Error
**errp
)
86 SpaprCapabilityInfo
*cap
= opaque
;
87 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
89 Error
*local_err
= NULL
;
91 visit_type_bool(v
, name
, &value
, &local_err
);
93 error_propagate(errp
, local_err
);
97 spapr
->cmd_line_caps
[cap
->index
] = true;
98 spapr
->eff
.caps
[cap
->index
] = value
? SPAPR_CAP_ON
: SPAPR_CAP_OFF
;
102 static void spapr_cap_get_string(Object
*obj
, Visitor
*v
, const char *name
,
103 void *opaque
, Error
**errp
)
105 SpaprCapabilityInfo
*cap
= opaque
;
106 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
108 uint8_t value
= spapr_get_cap(spapr
, cap
->index
);
110 if (value
>= cap
->possible
->num
) {
111 error_setg(errp
, "Invalid value (%d) for cap-%s", value
, cap
->name
);
115 val
= g_strdup(cap
->possible
->vals
[value
]);
117 visit_type_str(v
, name
, &val
, errp
);
121 static void spapr_cap_set_string(Object
*obj
, Visitor
*v
, const char *name
,
122 void *opaque
, Error
**errp
)
124 SpaprCapabilityInfo
*cap
= opaque
;
125 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
126 Error
*local_err
= NULL
;
130 visit_type_str(v
, name
, &val
, &local_err
);
132 error_propagate(errp
, local_err
);
136 if (!strcmp(val
, "?")) {
137 error_setg(errp
, "%s", cap
->possible
->help
);
140 for (i
= 0; i
< cap
->possible
->num
; i
++) {
141 if (!strcasecmp(val
, cap
->possible
->vals
[i
])) {
142 spapr
->cmd_line_caps
[cap
->index
] = true;
143 spapr
->eff
.caps
[cap
->index
] = i
;
148 error_setg(errp
, "Invalid capability mode \"%s\" for cap-%s", val
,
154 static void spapr_cap_get_pagesize(Object
*obj
, Visitor
*v
, const char *name
,
155 void *opaque
, Error
**errp
)
157 SpaprCapabilityInfo
*cap
= opaque
;
158 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
159 uint8_t val
= spapr_get_cap(spapr
, cap
->index
);
160 uint64_t pagesize
= (1ULL << val
);
162 visit_type_size(v
, name
, &pagesize
, errp
);
165 static void spapr_cap_set_pagesize(Object
*obj
, Visitor
*v
, const char *name
,
166 void *opaque
, Error
**errp
)
168 SpaprCapabilityInfo
*cap
= opaque
;
169 SpaprMachineState
*spapr
= SPAPR_MACHINE(obj
);
172 Error
*local_err
= NULL
;
174 visit_type_size(v
, name
, &pagesize
, &local_err
);
176 error_propagate(errp
, local_err
);
180 if (!is_power_of_2(pagesize
)) {
181 error_setg(errp
, "cap-%s must be a power of 2", cap
->name
);
185 val
= ctz64(pagesize
);
186 spapr
->cmd_line_caps
[cap
->index
] = true;
187 spapr
->eff
.caps
[cap
->index
] = val
;
190 static void cap_htm_apply(SpaprMachineState
*spapr
, uint8_t val
, Error
**errp
)
193 /* TODO: We don't support disabling htm yet */
198 "No Transactional Memory support in TCG,"
199 " try appending -machine cap-htm=off");
200 } else if (kvm_enabled() && !kvmppc_has_cap_htm()) {
202 "KVM implementation does not support Transactional Memory,"
203 " try appending -machine cap-htm=off"
208 static void cap_vsx_apply(SpaprMachineState
*spapr
, uint8_t val
, Error
**errp
)
210 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
211 CPUPPCState
*env
= &cpu
->env
;
214 /* TODO: We don't support disabling vsx yet */
217 /* Allowable CPUs in spapr_cpu_core.c should already have gotten
218 * rid of anything that doesn't do VMX */
219 g_assert(env
->insns_flags
& PPC_ALTIVEC
);
220 if (!(env
->insns_flags2
& PPC2_VSX
)) {
221 error_setg(errp
, "VSX support not available,"
222 " try appending -machine cap-vsx=off");
226 static void cap_dfp_apply(SpaprMachineState
*spapr
, uint8_t val
, Error
**errp
)
228 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
229 CPUPPCState
*env
= &cpu
->env
;
232 /* TODO: We don't support disabling dfp yet */
235 if (!(env
->insns_flags2
& PPC2_DFP
)) {
236 error_setg(errp
, "DFP support not available,"
237 " try appending -machine cap-dfp=off");
241 SpaprCapPossible cap_cfpc_possible
= {
243 .vals
= {"broken", "workaround", "fixed"},
244 .help
= "broken - no protection, workaround - workaround available,"
245 " fixed - fixed in hardware",
248 static void cap_safe_cache_apply(SpaprMachineState
*spapr
, uint8_t val
,
251 Error
*local_err
= NULL
;
252 uint8_t kvm_val
= kvmppc_get_cap_safe_cache();
254 if (tcg_enabled() && val
) {
255 /* TCG only supports broken, allow other values and print a warning */
256 error_setg(&local_err
,
257 "TCG doesn't support requested feature, cap-cfpc=%s",
258 cap_cfpc_possible
.vals
[val
]);
259 } else if (kvm_enabled() && (val
> kvm_val
)) {
261 "Requested safe cache capability level not supported by kvm,"
262 " try appending -machine cap-cfpc=%s",
263 cap_cfpc_possible
.vals
[kvm_val
]);
266 if (local_err
!= NULL
)
267 warn_report_err(local_err
);
270 SpaprCapPossible cap_sbbc_possible
= {
272 .vals
= {"broken", "workaround", "fixed"},
273 .help
= "broken - no protection, workaround - workaround available,"
274 " fixed - fixed in hardware",
277 static void cap_safe_bounds_check_apply(SpaprMachineState
*spapr
, uint8_t val
,
280 Error
*local_err
= NULL
;
281 uint8_t kvm_val
= kvmppc_get_cap_safe_bounds_check();
283 if (tcg_enabled() && val
) {
284 /* TCG only supports broken, allow other values and print a warning */
285 error_setg(&local_err
,
286 "TCG doesn't support requested feature, cap-sbbc=%s",
287 cap_sbbc_possible
.vals
[val
]);
288 } else if (kvm_enabled() && (val
> kvm_val
)) {
290 "Requested safe bounds check capability level not supported by kvm,"
291 " try appending -machine cap-sbbc=%s",
292 cap_sbbc_possible
.vals
[kvm_val
]);
295 if (local_err
!= NULL
)
296 warn_report_err(local_err
);
299 SpaprCapPossible cap_ibs_possible
= {
301 /* Note workaround only maintained for compatibility */
302 .vals
= {"broken", "workaround", "fixed-ibs", "fixed-ccd", "fixed-na"},
303 .help
= "broken - no protection, workaround - count cache flush"
304 ", fixed-ibs - indirect branch serialisation,"
305 " fixed-ccd - cache count disabled,"
306 " fixed-na - fixed in hardware (no longer applicable)",
309 static void cap_safe_indirect_branch_apply(SpaprMachineState
*spapr
,
310 uint8_t val
, Error
**errp
)
312 Error
*local_err
= NULL
;
313 uint8_t kvm_val
= kvmppc_get_cap_safe_indirect_branch();
315 if (tcg_enabled() && val
) {
316 /* TCG only supports broken, allow other values and print a warning */
317 error_setg(&local_err
,
318 "TCG doesn't support requested feature, cap-ibs=%s",
319 cap_ibs_possible
.vals
[val
]);
320 } else if (kvm_enabled() && (val
> kvm_val
)) {
322 "Requested safe indirect branch capability level not supported by kvm,"
323 " try appending -machine cap-ibs=%s",
324 cap_ibs_possible
.vals
[kvm_val
]);
327 if (local_err
!= NULL
) {
328 warn_report_err(local_err
);
332 #define VALUE_DESC_TRISTATE " (broken, workaround, fixed)"
334 void spapr_check_pagesize(SpaprMachineState
*spapr
, hwaddr pagesize
,
337 hwaddr maxpagesize
= (1ULL << spapr
->eff
.caps
[SPAPR_CAP_HPT_MAXPAGESIZE
]);
339 if (!kvmppc_hpt_needs_host_contiguous_pages()) {
343 if (maxpagesize
> pagesize
) {
345 "Can't support %"HWADDR_PRIu
" kiB guest pages with %"
346 HWADDR_PRIu
" kiB host pages with this KVM implementation",
347 maxpagesize
>> 10, pagesize
>> 10);
351 static void cap_hpt_maxpagesize_apply(SpaprMachineState
*spapr
,
352 uint8_t val
, Error
**errp
)
355 error_setg(errp
, "Require at least 4kiB hpt-max-page-size");
357 } else if (val
< 16) {
358 warn_report("Many guests require at least 64kiB hpt-max-page-size");
361 spapr_check_pagesize(spapr
, qemu_minrampagesize(), errp
);
364 static bool cap_hpt_maxpagesize_migrate_needed(void *opaque
)
366 return !SPAPR_MACHINE_GET_CLASS(opaque
)->pre_4_1_migration
;
369 static bool spapr_pagesize_cb(void *opaque
, uint32_t seg_pshift
,
372 unsigned maxshift
= *((unsigned *)opaque
);
374 assert(pshift
>= seg_pshift
);
376 /* Don't allow the guest to use pages bigger than the configured
378 if (pshift
> maxshift
) {
382 /* For whatever reason, KVM doesn't allow multiple pagesizes
383 * within a segment, *except* for the case of 16M pages in a 4k or
384 * 64k segment. Always exclude other cases, so that TCG and KVM
385 * guests see a consistent environment */
386 if ((pshift
!= seg_pshift
) && (pshift
!= 24)) {
393 static void cap_hpt_maxpagesize_cpu_apply(SpaprMachineState
*spapr
,
395 uint8_t val
, Error
**errp
)
397 unsigned maxshift
= val
;
399 ppc_hash64_filter_pagesizes(cpu
, spapr_pagesize_cb
, &maxshift
);
402 static void cap_nested_kvm_hv_apply(SpaprMachineState
*spapr
,
403 uint8_t val
, Error
**errp
)
406 /* capability disabled by default */
412 "No Nested KVM-HV support in tcg,"
413 " try appending -machine cap-nested-hv=off");
414 } else if (kvm_enabled()) {
415 if (!kvmppc_has_cap_nested_kvm_hv()) {
417 "KVM implementation does not support Nested KVM-HV,"
418 " try appending -machine cap-nested-hv=off");
419 } else if (kvmppc_set_cap_nested_kvm_hv(val
) < 0) {
421 "Error enabling cap-nested-hv with KVM, try cap-nested-hv=off");
426 static void cap_large_decr_apply(SpaprMachineState
*spapr
,
427 uint8_t val
, Error
**errp
)
429 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
430 PowerPCCPUClass
*pcc
= POWERPC_CPU_GET_CLASS(cpu
);
433 return; /* Disabled by default */
437 if (!ppc_check_compat(cpu
, CPU_POWERPC_LOGICAL_3_00
, 0,
438 spapr
->max_compat_pvr
)) {
440 "Large decrementer only supported on POWER9, try -cpu POWER9");
443 } else if (kvm_enabled()) {
444 int kvm_nr_bits
= kvmppc_get_cap_large_decr();
448 "No large decrementer support,"
449 " try appending -machine cap-large-decr=off");
450 } else if (pcc
->lrg_decr_bits
!= kvm_nr_bits
) {
452 "KVM large decrementer size (%d) differs to model (%d),"
453 " try appending -machine cap-large-decr=off",
454 kvm_nr_bits
, pcc
->lrg_decr_bits
);
459 static void cap_large_decr_cpu_apply(SpaprMachineState
*spapr
,
461 uint8_t val
, Error
**errp
)
463 CPUPPCState
*env
= &cpu
->env
;
464 target_ulong lpcr
= env
->spr
[SPR_LPCR
];
467 if (kvmppc_enable_cap_large_decr(cpu
, val
)) {
469 "No large decrementer support,"
470 " try appending -machine cap-large-decr=off");
479 ppc_store_lpcr(cpu
, lpcr
);
482 static void cap_ccf_assist_apply(SpaprMachineState
*spapr
, uint8_t val
,
485 uint8_t kvm_val
= kvmppc_get_cap_count_cache_flush_assist();
487 if (tcg_enabled() && val
) {
488 /* TCG doesn't implement anything here, but allow with a warning */
489 warn_report("TCG doesn't support requested feature, cap-ccf-assist=on");
490 } else if (kvm_enabled() && (val
> kvm_val
)) {
491 uint8_t kvm_ibs
= kvmppc_get_cap_safe_indirect_branch();
493 if (kvm_ibs
== SPAPR_CAP_FIXED_CCD
) {
495 * If we don't have CCF assist on the host, the assist
496 * instruction is a harmless no-op. It won't correctly
497 * implement the cache count flush *but* if we have
498 * count-cache-disabled in the host, that flush is
499 * unnnecessary. So, specifically allow this case. This
500 * allows us to have better performance on POWER9 DD2.3,
501 * while still working on POWER9 DD2.2 and POWER8 host
507 "Requested count cache flush assist capability level not supported by kvm,"
508 " try appending -machine cap-ccf-assist=off");
512 static void cap_fwnmi_mce_apply(SpaprMachineState
*spapr
, uint8_t val
,
516 return; /* Disabled by default */
520 warn_report("Firmware Assisted Non-Maskable Interrupts(FWNMI) not "
522 } else if (kvm_enabled()) {
523 if (kvmppc_set_fwnmi() < 0) {
524 error_setg(errp
, "Firmware Assisted Non-Maskable Interrupts(FWNMI) "
525 "not supported by KVM");
530 SpaprCapabilityInfo capability_table
[SPAPR_CAP_NUM
] = {
533 .description
= "Allow Hardware Transactional Memory (HTM)",
534 .index
= SPAPR_CAP_HTM
,
535 .get
= spapr_cap_get_bool
,
536 .set
= spapr_cap_set_bool
,
538 .apply
= cap_htm_apply
,
542 .description
= "Allow Vector Scalar Extensions (VSX)",
543 .index
= SPAPR_CAP_VSX
,
544 .get
= spapr_cap_get_bool
,
545 .set
= spapr_cap_set_bool
,
547 .apply
= cap_vsx_apply
,
551 .description
= "Allow Decimal Floating Point (DFP)",
552 .index
= SPAPR_CAP_DFP
,
553 .get
= spapr_cap_get_bool
,
554 .set
= spapr_cap_set_bool
,
556 .apply
= cap_dfp_apply
,
560 .description
= "Cache Flush on Privilege Change" VALUE_DESC_TRISTATE
,
561 .index
= SPAPR_CAP_CFPC
,
562 .get
= spapr_cap_get_string
,
563 .set
= spapr_cap_set_string
,
565 .possible
= &cap_cfpc_possible
,
566 .apply
= cap_safe_cache_apply
,
570 .description
= "Speculation Barrier Bounds Checking" VALUE_DESC_TRISTATE
,
571 .index
= SPAPR_CAP_SBBC
,
572 .get
= spapr_cap_get_string
,
573 .set
= spapr_cap_set_string
,
575 .possible
= &cap_sbbc_possible
,
576 .apply
= cap_safe_bounds_check_apply
,
581 "Indirect Branch Speculation (broken, workaround, fixed-ibs,"
582 "fixed-ccd, fixed-na)",
583 .index
= SPAPR_CAP_IBS
,
584 .get
= spapr_cap_get_string
,
585 .set
= spapr_cap_set_string
,
587 .possible
= &cap_ibs_possible
,
588 .apply
= cap_safe_indirect_branch_apply
,
590 [SPAPR_CAP_HPT_MAXPAGESIZE
] = {
591 .name
= "hpt-max-page-size",
592 .description
= "Maximum page size for Hash Page Table guests",
593 .index
= SPAPR_CAP_HPT_MAXPAGESIZE
,
594 .get
= spapr_cap_get_pagesize
,
595 .set
= spapr_cap_set_pagesize
,
597 .apply
= cap_hpt_maxpagesize_apply
,
598 .cpu_apply
= cap_hpt_maxpagesize_cpu_apply
,
599 .migrate_needed
= cap_hpt_maxpagesize_migrate_needed
,
601 [SPAPR_CAP_NESTED_KVM_HV
] = {
603 .description
= "Allow Nested KVM-HV",
604 .index
= SPAPR_CAP_NESTED_KVM_HV
,
605 .get
= spapr_cap_get_bool
,
606 .set
= spapr_cap_set_bool
,
608 .apply
= cap_nested_kvm_hv_apply
,
610 [SPAPR_CAP_LARGE_DECREMENTER
] = {
611 .name
= "large-decr",
612 .description
= "Allow Large Decrementer",
613 .index
= SPAPR_CAP_LARGE_DECREMENTER
,
614 .get
= spapr_cap_get_bool
,
615 .set
= spapr_cap_set_bool
,
617 .apply
= cap_large_decr_apply
,
618 .cpu_apply
= cap_large_decr_cpu_apply
,
620 [SPAPR_CAP_CCF_ASSIST
] = {
621 .name
= "ccf-assist",
622 .description
= "Count Cache Flush Assist via HW Instruction",
623 .index
= SPAPR_CAP_CCF_ASSIST
,
624 .get
= spapr_cap_get_bool
,
625 .set
= spapr_cap_set_bool
,
627 .apply
= cap_ccf_assist_apply
,
629 [SPAPR_CAP_FWNMI_MCE
] = {
631 .description
= "Handle fwnmi machine check exceptions",
632 .index
= SPAPR_CAP_FWNMI_MCE
,
633 .get
= spapr_cap_get_bool
,
634 .set
= spapr_cap_set_bool
,
636 .apply
= cap_fwnmi_mce_apply
,
640 static SpaprCapabilities
default_caps_with_cpu(SpaprMachineState
*spapr
,
643 SpaprMachineClass
*smc
= SPAPR_MACHINE_GET_CLASS(spapr
);
644 SpaprCapabilities caps
;
646 caps
= smc
->default_caps
;
648 if (!ppc_type_check_compat(cputype
, CPU_POWERPC_LOGICAL_3_00
,
649 0, spapr
->max_compat_pvr
)) {
650 caps
.caps
[SPAPR_CAP_LARGE_DECREMENTER
] = SPAPR_CAP_OFF
;
653 if (!ppc_type_check_compat(cputype
, CPU_POWERPC_LOGICAL_2_07
,
654 0, spapr
->max_compat_pvr
)) {
655 caps
.caps
[SPAPR_CAP_HTM
] = SPAPR_CAP_OFF
;
656 caps
.caps
[SPAPR_CAP_CFPC
] = SPAPR_CAP_BROKEN
;
659 if (!ppc_type_check_compat(cputype
, CPU_POWERPC_LOGICAL_2_06_PLUS
,
660 0, spapr
->max_compat_pvr
)) {
661 caps
.caps
[SPAPR_CAP_SBBC
] = SPAPR_CAP_BROKEN
;
664 if (!ppc_type_check_compat(cputype
, CPU_POWERPC_LOGICAL_2_06
,
665 0, spapr
->max_compat_pvr
)) {
666 caps
.caps
[SPAPR_CAP_VSX
] = SPAPR_CAP_OFF
;
667 caps
.caps
[SPAPR_CAP_DFP
] = SPAPR_CAP_OFF
;
668 caps
.caps
[SPAPR_CAP_IBS
] = SPAPR_CAP_BROKEN
;
671 /* This is for pseries-2.12 and older */
672 if (smc
->default_caps
.caps
[SPAPR_CAP_HPT_MAXPAGESIZE
] == 0) {
675 if (kvmppc_hpt_needs_host_contiguous_pages()) {
676 mps
= ctz64(qemu_minrampagesize());
678 mps
= 34; /* allow everything up to 16GiB, i.e. everything */
681 caps
.caps
[SPAPR_CAP_HPT_MAXPAGESIZE
] = mps
;
687 int spapr_caps_pre_load(void *opaque
)
689 SpaprMachineState
*spapr
= opaque
;
691 /* Set to default so we can tell if this came in with the migration */
692 spapr
->mig
= spapr
->def
;
696 int spapr_caps_pre_save(void *opaque
)
698 SpaprMachineState
*spapr
= opaque
;
700 spapr
->mig
= spapr
->eff
;
704 /* This has to be called from the top-level spapr post_load, not the
705 * caps specific one. Otherwise it wouldn't be called when the source
706 * caps are all defaults, which could still conflict with overridden
707 * caps on the destination */
708 int spapr_caps_post_migration(SpaprMachineState
*spapr
)
712 SpaprCapabilities dstcaps
= spapr
->eff
;
713 SpaprCapabilities srccaps
;
715 srccaps
= default_caps_with_cpu(spapr
, MACHINE(spapr
)->cpu_type
);
716 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
717 /* If not default value then assume came in with the migration */
718 if (spapr
->mig
.caps
[i
] != spapr
->def
.caps
[i
]) {
719 srccaps
.caps
[i
] = spapr
->mig
.caps
[i
];
723 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
724 SpaprCapabilityInfo
*info
= &capability_table
[i
];
726 if (srccaps
.caps
[i
] > dstcaps
.caps
[i
]) {
727 error_report("cap-%s higher level (%d) in incoming stream than on destination (%d)",
728 info
->name
, srccaps
.caps
[i
], dstcaps
.caps
[i
]);
732 if (srccaps
.caps
[i
] < dstcaps
.caps
[i
]) {
733 warn_report("cap-%s lower level (%d) in incoming stream than on destination (%d)",
734 info
->name
, srccaps
.caps
[i
], dstcaps
.caps
[i
]);
738 return ok
? 0 : -EINVAL
;
741 /* Used to generate the migration field and needed function for a spapr cap */
742 #define SPAPR_CAP_MIG_STATE(sname, cap) \
743 static bool spapr_cap_##sname##_needed(void *opaque) \
745 SpaprMachineState *spapr = opaque; \
746 bool (*needed)(void *opaque) = \
747 capability_table[cap].migrate_needed; \
749 return needed ? needed(opaque) : true && \
750 spapr->cmd_line_caps[cap] && \
751 (spapr->eff.caps[cap] != \
752 spapr->def.caps[cap]); \
755 const VMStateDescription vmstate_spapr_cap_##sname = { \
756 .name = "spapr/cap/" #sname, \
758 .minimum_version_id = 1, \
759 .needed = spapr_cap_##sname##_needed, \
760 .fields = (VMStateField[]) { \
761 VMSTATE_UINT8(mig.caps[cap], \
762 SpaprMachineState), \
763 VMSTATE_END_OF_LIST() \
767 SPAPR_CAP_MIG_STATE(htm
, SPAPR_CAP_HTM
);
768 SPAPR_CAP_MIG_STATE(vsx
, SPAPR_CAP_VSX
);
769 SPAPR_CAP_MIG_STATE(dfp
, SPAPR_CAP_DFP
);
770 SPAPR_CAP_MIG_STATE(cfpc
, SPAPR_CAP_CFPC
);
771 SPAPR_CAP_MIG_STATE(sbbc
, SPAPR_CAP_SBBC
);
772 SPAPR_CAP_MIG_STATE(ibs
, SPAPR_CAP_IBS
);
773 SPAPR_CAP_MIG_STATE(hpt_maxpagesize
, SPAPR_CAP_HPT_MAXPAGESIZE
);
774 SPAPR_CAP_MIG_STATE(nested_kvm_hv
, SPAPR_CAP_NESTED_KVM_HV
);
775 SPAPR_CAP_MIG_STATE(large_decr
, SPAPR_CAP_LARGE_DECREMENTER
);
776 SPAPR_CAP_MIG_STATE(ccf_assist
, SPAPR_CAP_CCF_ASSIST
);
777 SPAPR_CAP_MIG_STATE(fwnmi
, SPAPR_CAP_FWNMI_MCE
);
779 void spapr_caps_init(SpaprMachineState
*spapr
)
781 SpaprCapabilities default_caps
;
784 /* Compute the actual set of caps we should run with */
785 default_caps
= default_caps_with_cpu(spapr
, MACHINE(spapr
)->cpu_type
);
787 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
788 /* Store the defaults */
789 spapr
->def
.caps
[i
] = default_caps
.caps
[i
];
790 /* If not set on the command line then apply the default value */
791 if (!spapr
->cmd_line_caps
[i
]) {
792 spapr
->eff
.caps
[i
] = default_caps
.caps
[i
];
797 void spapr_caps_apply(SpaprMachineState
*spapr
)
801 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
802 SpaprCapabilityInfo
*info
= &capability_table
[i
];
805 * If the apply function can't set the desired level and thinks it's
806 * fatal, it should cause that.
808 info
->apply(spapr
, spapr
->eff
.caps
[i
], &error_fatal
);
812 void spapr_caps_cpu_apply(SpaprMachineState
*spapr
, PowerPCCPU
*cpu
)
816 for (i
= 0; i
< SPAPR_CAP_NUM
; i
++) {
817 SpaprCapabilityInfo
*info
= &capability_table
[i
];
820 * If the apply function can't set the desired level and thinks it's
821 * fatal, it should cause that.
823 if (info
->cpu_apply
) {
824 info
->cpu_apply(spapr
, cpu
, spapr
->eff
.caps
[i
], &error_fatal
);
829 void spapr_caps_add_properties(SpaprMachineClass
*smc
, Error
**errp
)
831 Error
*local_err
= NULL
;
832 ObjectClass
*klass
= OBJECT_CLASS(smc
);
835 for (i
= 0; i
< ARRAY_SIZE(capability_table
); i
++) {
836 SpaprCapabilityInfo
*cap
= &capability_table
[i
];
837 char *name
= g_strdup_printf("cap-%s", cap
->name
);
840 object_class_property_add(klass
, name
, cap
->type
,
842 NULL
, cap
, &local_err
);
844 error_propagate(errp
, local_err
);
849 desc
= g_strdup_printf("%s", cap
->description
);
850 object_class_property_set_description(klass
, name
, desc
, &local_err
);
854 error_propagate(errp
, local_err
);