1 package PVE
::QemuServer
::CPUConfig
;
7 use PVE
::Cluster
qw(cfs_register_file cfs_read_file);
8 use PVE
::QemuServer
::Helpers
qw(min_version);
10 use base
qw(PVE::SectionConfig Exporter);
17 # under certain race-conditions, this module might be loaded before pve-cluster
18 # has started completely, so ensure we don't prevent the FUSE mount with our dir
19 if (PVE
::Cluster
::check_cfs_is_mounted
(1)) {
20 mkdir "/etc/pve/virtual-guest";
23 my $default_filename = "virtual-guest/cpu-models.conf";
24 cfs_register_file
($default_filename,
25 sub { PVE
::QemuServer
::CPUConfig-
>parse_config(@_); },
26 sub { PVE
::QemuServer
::CPUConfig-
>write_config(@_); });
28 sub load_custom_model_conf
{
29 return cfs_read_file
($default_filename);
32 my $cpu_vendor_list = {
34 486 => 'GenuineIntel',
35 pentium
=> 'GenuineIntel',
36 pentium2
=> 'GenuineIntel',
37 pentium3
=> 'GenuineIntel',
38 coreduo
=> 'GenuineIntel',
39 core2duo
=> 'GenuineIntel',
40 Conroe
=> 'GenuineIntel',
41 Penryn
=> 'GenuineIntel',
42 Nehalem
=> 'GenuineIntel',
43 'Nehalem-IBRS' => 'GenuineIntel',
44 Westmere
=> 'GenuineIntel',
45 'Westmere-IBRS' => 'GenuineIntel',
46 SandyBridge
=> 'GenuineIntel',
47 'SandyBridge-IBRS' => 'GenuineIntel',
48 IvyBridge
=> 'GenuineIntel',
49 'IvyBridge-IBRS' => 'GenuineIntel',
50 Haswell
=> 'GenuineIntel',
51 'Haswell-IBRS' => 'GenuineIntel',
52 'Haswell-noTSX' => 'GenuineIntel',
53 'Haswell-noTSX-IBRS' => 'GenuineIntel',
54 Broadwell
=> 'GenuineIntel',
55 'Broadwell-IBRS' => 'GenuineIntel',
56 'Broadwell-noTSX' => 'GenuineIntel',
57 'Broadwell-noTSX-IBRS' => 'GenuineIntel',
58 'Skylake-Client' => 'GenuineIntel',
59 'Skylake-Client-IBRS' => 'GenuineIntel',
60 'Skylake-Client-noTSX-IBRS' => 'GenuineIntel',
61 'Skylake-Server' => 'GenuineIntel',
62 'Skylake-Server-IBRS' => 'GenuineIntel',
63 'Skylake-Server-noTSX-IBRS' => 'GenuineIntel',
64 'Cascadelake-Server' => 'GenuineIntel',
65 'Cascadelake-Server-noTSX' => 'GenuineIntel',
66 KnightsMill
=> 'GenuineIntel',
67 'Icelake-Client' => 'GenuineIntel',
68 'Icelake-Client-noTSX' => 'GenuineIntel',
69 'Icelake-Server' => 'GenuineIntel',
70 'Icelake-Server-noTSX' => 'GenuineIntel',
73 athlon
=> 'AuthenticAMD',
74 phenom
=> 'AuthenticAMD',
75 Opteron_G1
=> 'AuthenticAMD',
76 Opteron_G2
=> 'AuthenticAMD',
77 Opteron_G3
=> 'AuthenticAMD',
78 Opteron_G4
=> 'AuthenticAMD',
79 Opteron_G5
=> 'AuthenticAMD',
80 EPYC
=> 'AuthenticAMD',
81 'EPYC-IBPB' => 'AuthenticAMD',
82 'EPYC-Rome' => 'AuthenticAMD',
84 # generic types, use vendor from host node
93 my @supported_cpu_flags = (
107 my $cpu_flag_supported_re = qr/([+-])(@{[join('|', @supported_cpu_flags)]})/;
108 my $cpu_flag_any_re = qr/([+-])([a-zA-Z0-9\-_\.]+)/;
110 our $qemu_cmdline_cpu_re = qr/^((?>[+-]?[\w\-\._=]+,?)+)$/;
114 description
=> "Emulated CPU type. Can be default or custom name (custom model names must be prefixed with 'custom-').",
116 format_description
=> 'string',
121 'reported-model' => {
122 description
=> "CPU model and vendor to report to the guest. Must be a QEMU/KVM supported model."
123 ." Only valid for custom CPU model definitions, default models will always report themselves to the guest OS.",
125 enum
=> [ sort { lc("$a") cmp lc("$b") } keys %$cpu_vendor_list ],
130 description
=> "Do not identify as a KVM virtual machine.",
137 pattern
=> qr/[a-zA-Z0-9]{1,12}/,
138 format_description
=> 'vendor-id',
139 description
=> 'The Hyper-V vendor ID. Some drivers or programs inside Windows guests need a specific ID.',
143 description
=> "List of additional CPU flags separated by ';'. Use '+FLAG' to enable,"
144 ." '-FLAG' to disable a flag. Custom CPU models can specify any flag supported by"
145 ." QEMU/KVM, VM-specific flags must be from the following set for security reasons: "
146 . join(', ', @supported_cpu_flags),
147 format_description
=> '+FLAG[;-FLAG...]',
149 pattern
=> qr/$cpu_flag_any_re(;$cpu_flag_any_re)*/,
154 format
=> 'pve-phys-bits',
155 format_description
=> '8-64|host',
156 description
=> "The physical memory address bits that are reported to the guest OS. Should"
157 ." be smaller or equal to the host's. Set to 'host' to use value from host CPU, but"
158 ." note that doing so will break live migration to CPUs with other values.",
163 PVE
::JSONSchema
::register_format
('pve-phys-bits', \
&parse_phys_bits
);
164 sub parse_phys_bits
{
165 my ($str, $noerr) = @_;
167 my $err_msg = "value must be an integer between 8 and 64 or 'host'\n";
169 if ($str !~ m/^(host|\d{1,2})$/) {
170 die $err_msg if !$noerr;
174 if ($str =~ m/^\d+$/ && (int($str) < 8 || int($str) > 64)) {
175 die $err_msg if !$noerr;
182 # $cpu_fmt describes both the CPU config passed as part of a VM config, as well
183 # as the definition of a custom CPU model. There are some slight differences
184 # though, which we catch in the custom validation functions below.
185 PVE
::JSONSchema
::register_format
('pve-cpu-conf', $cpu_fmt, \
&validate_cpu_conf
);
186 sub validate_cpu_conf
{
189 # required, but can't be forced in schema since it's encoded in section
190 # header for custom models
191 die "CPU is missing cputype\n" if !$cpu->{cputype
};
195 PVE
::JSONSchema
::register_format
('pve-vm-cpu-conf', $cpu_fmt, \
&validate_vm_cpu_conf
);
196 sub validate_vm_cpu_conf
{
199 validate_cpu_conf
($cpu);
201 my $cputype = $cpu->{cputype
};
203 # a VM-specific config is only valid if the cputype exists
204 if (is_custom_model
($cputype)) {
205 # dies on unknown model
206 get_custom_model
($cputype);
208 die "Built-in cputype '$cputype' is not defined (missing 'custom-' prefix?)\n"
209 if !defined($cpu_vendor_list->{$cputype});
212 # in a VM-specific config, certain properties are limited/forbidden
214 die "VM-specific CPU flags must be a subset of: @{[join(', ', @supported_cpu_flags)]}\n"
215 if ($cpu->{flags
} && $cpu->{flags
} !~ m/^$cpu_flag_supported_re(;$cpu_flag_supported_re)*$/);
217 die "Property 'reported-model' not allowed in VM-specific CPU config.\n"
218 if defined($cpu->{'reported-model'});
223 # Section config settings
225 # shallow copy, since SectionConfig modifies propertyList internally
226 propertyList
=> { %$cpu_fmt },
234 return { %$cpu_fmt };
241 sub parse_section_header
{
242 my ($class, $line) = @_;
244 my ($type, $sectionId, $errmsg, $config) =
245 $class->SUPER::parse_section_header
($line);
248 return ($type, $sectionId, $errmsg, {
249 # name is given by section header, and we can always prepend 'custom-'
250 # since we're reading the custom CPU file
251 cputype
=> "custom-$sectionId",
256 my ($class, $filename, $cfg) = @_;
258 mkdir "/etc/pve/virtual-guest";
260 for my $model (keys %{$cfg->{ids
}}) {
261 my $model_conf = $cfg->{ids
}->{$model};
263 die "internal error: tried saving built-in CPU model (or missing prefix): $model_conf->{cputype}\n"
264 if !is_custom_model
($model_conf->{cputype
});
266 die "internal error: tried saving custom cpumodel with cputype (ignoring prefix: $model_conf->{cputype}) not equal to \$cfg->ids entry ($model)\n"
267 if "custom-$model" ne $model_conf->{cputype
};
269 # saved in section header
270 delete $model_conf->{cputype
};
273 $class->SUPER::write_config
($filename, $cfg);
276 sub add_cpu_json_properties
{
279 foreach my $opt (keys %$cpu_fmt) {
280 $prop->{$opt} = $cpu_fmt->{$opt};
287 my ($include_custom) = @_;
291 for my $default_model (keys %{$cpu_vendor_list}) {
293 name
=> $default_model,
295 vendor
=> $cpu_vendor_list->{$default_model},
299 return $models if !$include_custom;
301 my $conf = load_custom_model_conf
();
302 for my $custom_model (keys %{$conf->{ids
}}) {
303 my $reported_model = $conf->{ids
}->{$custom_model}->{'reported-model'};
304 $reported_model //= $cpu_fmt->{'reported-model'}->{default};
305 my $vendor = $cpu_vendor_list->{$reported_model};
307 name
=> "custom-$custom_model",
316 sub is_custom_model
{
318 return $cputype =~ m/^custom-/;
321 # Use this to get a single model in the format described by $cpu_fmt.
322 # Allows names with and without custom- prefix.
323 sub get_custom_model
{
324 my ($name, $noerr) = @_;
326 $name =~ s/^custom-//;
327 my $conf = load_custom_model_conf
();
329 my $entry = $conf->{ids
}->{$name};
330 if (!defined($entry)) {
331 die "Custom cputype '$name' not found\n" if !$noerr;
336 for my $property (keys %$cpu_fmt) {
337 if (my $value = $entry->{$property}) {
338 $model->{$property} = $value;
345 # Print a QEMU device node for a given VM configuration for hotplugging CPUs
346 sub print_cpu_device
{
347 my ($conf, $id) = @_;
349 my $kvm = $conf->{kvm
} // 1;
350 my $cpu = $kvm ?
"kvm64" : "qemu64";
351 if (my $cputype = $conf->{cpu
}) {
352 my $cpuconf = PVE
::JSONSchema
::parse_property_string
('pve-vm-cpu-conf', $cputype)
353 or die "Cannot parse cpu description: $cputype\n";
354 $cpu = $cpuconf->{cputype
};
356 if (is_custom_model
($cpu)) {
357 my $custom_cpu = get_custom_model
($cpu);
359 $cpu = $custom_cpu->{'reported-model'} //
360 $cpu_fmt->{'reported-model'}->{default};
364 my $cores = $conf->{cores
} || 1;
366 my $current_core = ($id - 1) % $cores;
367 my $current_socket = int(($id - 1 - $current_core)/$cores);
369 return "$cpu-x86_64-cpu,id=cpu$id,socket-id=$current_socket,core-id=$current_core,thread-id=0";
372 # Resolves multiple arrays of hashes representing CPU flags with metadata to a
373 # single string in QEMU "-cpu" compatible format. Later arrays have higher
376 # Hashes take the following format:
379 # op => "+", # defaults to "" if undefined
380 # reason => "to support AES acceleration", # for override warnings
381 # value => "" # needed for kvm=off (value: off) etc...
385 sub resolve_cpu_flags
{
389 for my $flag_name (keys %$hash) {
390 my $flag = $hash->{$flag_name};
391 my $old_flag = $flags->{$flag_name};
394 $flag->{reason
} //= "unknown origin";
397 my $value_changed = (defined($flag->{value
}) != defined($old_flag->{value
})) ||
398 (defined($flag->{value
}) && $flag->{value
} ne $old_flag->{value
});
400 if ($old_flag->{op
} eq $flag->{op
} && !$value_changed) {
401 $flags->{$flag_name}->{reason
} .= " & $flag->{reason}";
405 my $old = print_cpuflag_hash
($flag_name, $flags->{$flag_name});
406 my $new = print_cpuflag_hash
($flag_name, $flag);
407 warn "warning: CPU flag/setting $new overwrites $old\n";
410 $flags->{$flag_name} = $flag;
415 # sort for command line stability
416 for my $flag_name (sort keys %$flags) {
418 $flag_str .= $flags->{$flag_name}->{op
};
419 $flag_str .= $flag_name;
420 $flag_str .= "=$flags->{$flag_name}->{value}"
421 if $flags->{$flag_name}->{value
};
427 sub print_cpuflag_hash
{
428 my ($flag_name, $flag) = @_;
429 my $formatted = "'$flag->{op}$flag_name";
430 $formatted .= "=$flag->{value}" if defined($flag->{value
});
432 $formatted .= " ($flag->{reason})" if defined($flag->{reason
});
436 sub parse_cpuflag_list
{
437 my ($re, $reason, $flaglist) = @_;
440 return $res if !$flaglist;
442 foreach my $flag (split(";", $flaglist)) {
443 if ($flag =~ m/^$re$/) {
444 $res->{$2} = { op
=> $1, reason
=> $reason };
451 # Calculate QEMU's '-cpu' argument from a given VM configuration
452 sub get_cpu_options
{
453 my ($conf, $arch, $kvm, $kvm_off, $machine_version, $winversion, $gpu_passthrough) = @_;
455 my $cputype = $kvm ?
"kvm64" : "qemu64";
456 if ($arch eq 'aarch64') {
457 $cputype = 'cortex-a57';
463 if (my $cpu_prop_str = $conf->{cpu
}) {
464 $cpu = PVE
::JSONSchema
::parse_property_string
('pve-vm-cpu-conf', $cpu_prop_str)
465 or die "Cannot parse cpu description: $cpu_prop_str\n";
467 $cputype = $cpu->{cputype
};
469 if (is_custom_model
($cputype)) {
470 $custom_cpu = get_custom_model
($cputype);
472 $cputype = $custom_cpu->{'reported-model'} //
473 $cpu_fmt->{'reported-model'}->{default};
474 $kvm_off = $custom_cpu->{hidden
}
475 if defined($custom_cpu->{hidden
});
476 $hv_vendor_id = $custom_cpu->{'hv-vendor-id'};
479 # VM-specific settings override custom CPU config
480 $kvm_off = $cpu->{hidden
}
481 if defined($cpu->{hidden
});
482 $hv_vendor_id = $cpu->{'hv-vendor-id'}
483 if defined($cpu->{'hv-vendor-id'});
486 my $pve_flags = get_pve_cpu_flags
($conf, $kvm, $cputype, $arch, $machine_version);
489 ? get_hyperv_enlightenments
(
498 my $custom_cputype_flags = parse_cpuflag_list
(
499 $cpu_flag_any_re, "set by custom CPU model", $custom_cpu->{flags
});
501 my $vm_flags = parse_cpuflag_list
(
502 $cpu_flag_supported_re, "manually set for VM", $cpu->{flags
});
504 my $pve_forced_flags = {};
505 $pve_forced_flags->{'enforce'} = {
506 reason
=> "error if requested CPU settings not available",
507 } if $cputype ne 'host' && $kvm && $arch eq 'x86_64';
508 $pve_forced_flags->{'kvm'} = {
510 reason
=> "hide KVM virtualization from guest",
513 # $cputype is the "reported-model" for custom types, so we can just look up
514 # the vendor in the default list
515 my $cpu_vendor = $cpu_vendor_list->{$cputype};
517 $pve_forced_flags->{'vendor'} = {
518 value
=> $cpu_vendor,
519 } if $cpu_vendor ne 'default';
520 } elsif ($arch ne 'aarch64') {
521 die "internal error"; # should not happen
524 my $cpu_str = $cputype;
526 # will be resolved in parameter order
527 $cpu_str .= resolve_cpu_flags
(
528 $pve_flags, $hv_flags, $custom_cputype_flags, $vm_flags, $pve_forced_flags);
531 foreach my $conf ($custom_cpu, $cpu) {
532 next if !defined($conf);
533 my $conf_val = $conf->{'phys-bits'};
535 if ($conf_val eq 'host') {
536 $phys_bits = ",host-phys-bits=true";
538 $phys_bits = ",phys-bits=$conf_val";
541 $cpu_str .= $phys_bits;
543 return ('-cpu', $cpu_str);
546 # Some hardcoded flags required by certain configurations
547 sub get_pve_cpu_flags
{
548 my ($conf, $kvm, $cputype, $arch, $machine_version) = @_;
551 my $pve_msg = "set by PVE;";
553 $pve_flags->{'lahf_lm'} = {
555 reason
=> "$pve_msg to support Windows 8.1+",
556 } if $cputype eq 'kvm64' && $arch eq 'x86_64';
558 $pve_flags->{'x2apic'} = {
560 reason
=> "$pve_msg incompatible with Solaris",
561 } if $conf->{ostype
} && $conf->{ostype
} eq 'solaris';
563 $pve_flags->{'sep'} = {
565 reason
=> "$pve_msg to support Windows 8+ and improve Windows XP+",
566 } if $cputype eq 'kvm64' || $cputype eq 'kvm32';
568 $pve_flags->{'rdtscp'} = {
570 reason
=> "$pve_msg broken on AMD Opteron",
571 } if $cputype =~ m/^Opteron/;
573 if (min_version
($machine_version, 2, 3) && $kvm && $arch eq 'x86_64') {
574 $pve_flags->{'kvm_pv_unhalt'} = {
576 reason
=> "$pve_msg to improve Linux guest spinlock performance",
578 $pve_flags->{'kvm_pv_eoi'} = {
580 reason
=> "$pve_msg to improve Linux guest interrupt performance",
587 sub get_hyperv_enlightenments
{
588 my ($winversion, $machine_version, $bios, $gpu_passthrough, $hv_vendor_id) = @_;
590 return if $winversion < 6;
591 return if $bios && $bios eq 'ovmf' && $winversion < 8;
594 my $default_reason = "automatic Hyper-V enlightenment for Windows";
596 my ($flag, $value, $reason) = @_;
598 reason
=> $reason // $default_reason,
603 my $hv_vendor_set = defined($hv_vendor_id);
604 if ($gpu_passthrough || $hv_vendor_set) {
605 $hv_vendor_id //= 'proxmox';
606 $flagfn->('hv_vendor_id', $hv_vendor_id, $hv_vendor_set ?
607 "custom hv_vendor_id set" : "NVIDIA workaround for GPU passthrough");
610 if (min_version
($machine_version, 2, 3)) {
611 $flagfn->('hv_spinlocks', '0x1fff');
612 $flagfn->('hv_vapic');
613 $flagfn->('hv_time');
615 $flagfn->('hv_spinlocks', '0xffff');
618 if (min_version
($machine_version, 2, 6)) {
619 $flagfn->('hv_reset');
620 $flagfn->('hv_vpindex');
621 $flagfn->('hv_runtime');
624 if ($winversion >= 7) {
625 my $win7_reason = $default_reason . " 7 and higher";
626 $flagfn->('hv_relaxed', undef, $win7_reason);
628 if (min_version
($machine_version, 2, 12)) {
629 $flagfn->('hv_synic', undef, $win7_reason);
630 $flagfn->('hv_stimer', undef, $win7_reason);
633 if (min_version
($machine_version, 3, 1)) {
634 $flagfn->('hv_ipi', undef, $win7_reason);
641 sub get_cpu_from_running_vm
{
644 my $cmdline = PVE
::QemuServer
::Helpers
::parse_cmdline
($pid);
645 die "could not read commandline of running machine\n"
646 if !$cmdline->{cpu
}->{value
};
648 # sanitize and untaint value
649 $cmdline->{cpu
}->{value
} =~ $qemu_cmdline_cpu_re;
653 __PACKAGE__-
>register();