1 package PVE
::QemuServer
;
23 use Storable
qw(dclone);
25 use PVE
::Exception
qw(raise raise_param_exc);
27 use PVE
::Tools
qw(run_command lock_file lock_file_full file_read_firstline dir_glob_foreach $IPV6RE);
28 use PVE
::JSONSchema
qw(get_standard_option);
29 use PVE
::Cluster
qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
34 use PVE
::RPCEnvironment
;
35 use PVE
::GuestHelpers
;
36 use PVE
::QemuServer
::PCI
qw(print_pci_addr print_pcie_addr print_pcie_root_port);
37 use PVE
::QemuServer
::Memory
;
38 use PVE
::QemuServer
::USB
qw(parse_usb_device);
39 use PVE
::QemuServer
::Cloudinit
;
42 use Time
::HiRes
qw(gettimeofday);
43 use File
::Copy
qw(copy);
46 my $EDK2_FW_BASE = '/usr/share/pve-edk2-firmware/';
49 "$EDK2_FW_BASE/OVMF_CODE.fd",
50 "$EDK2_FW_BASE/OVMF_VARS.fd"
53 "$EDK2_FW_BASE/AAVMF_CODE.fd",
54 "$EDK2_FW_BASE/AAVMF_VARS.fd"
58 my $qemu_snap_storage = { rbd
=> 1 };
60 my $cpuinfo = PVE
::ProcFSTools
::read_cpuinfo
();
62 my $QEMU_FORMAT_RE = qr/raw|cow|qcow|qcow2|qed|vmdk|cloop/;
64 # Note about locking: we use flock on the config file protect
65 # against concurent actions.
66 # Aditionaly, we have a 'lock' setting in the config file. This
67 # can be set to 'migrate', 'backup', 'snapshot' or 'rollback'. Most actions are not
68 # allowed when such lock is set. But you can ignore this kind of
69 # lock with the --skiplock flag.
71 cfs_register_file
('/qemu-server/',
75 PVE
::JSONSchema
::register_standard_option
('pve-qm-stateuri', {
76 description
=> "Some command save/restore state from this location.",
82 PVE
::JSONSchema
::register_standard_option
('pve-qm-image-format', {
84 enum
=> [qw(raw cow qcow qed qcow2 vmdk cloop)],
85 description
=> "The drive's backing file's data format.",
89 PVE
::JSONSchema
::register_standard_option
('pve-qemu-machine', {
90 description
=> "Specifies the Qemu machine type.",
92 pattern
=> '(pc|pc(-i440fx)?-\d+\.\d+(\.pxe)?|q35|pc-q35-\d+\.\d+(\.pxe)?|virt(?:-\d+\.\d+)?)',
97 #no warnings 'redefine';
100 my ($controller, $vmid, $option, $value) = @_;
102 my $path = "/sys/fs/cgroup/$controller/qemu.slice/$vmid.scope/$option";
103 PVE
::ProcFSTools
::write_proc_entry
($path, $value);
107 my $nodename = PVE
::INotify
::nodename
();
109 mkdir "/etc/pve/nodes/$nodename";
110 my $confdir = "/etc/pve/nodes/$nodename/qemu-server";
113 my $var_run_tmpdir = "/var/run/qemu-server";
114 mkdir $var_run_tmpdir;
116 my $lock_dir = "/var/lock/qemu-server";
119 my $cpu_vendor_list = {
121 486 => 'GenuineIntel',
122 pentium
=> 'GenuineIntel',
123 pentium2
=> 'GenuineIntel',
124 pentium3
=> 'GenuineIntel',
125 coreduo
=> 'GenuineIntel',
126 core2duo
=> 'GenuineIntel',
127 Conroe
=> 'GenuineIntel',
128 Penryn
=> 'GenuineIntel',
129 Nehalem
=> 'GenuineIntel',
130 'Nehalem-IBRS' => 'GenuineIntel',
131 Westmere
=> 'GenuineIntel',
132 'Westmere-IBRS' => 'GenuineIntel',
133 SandyBridge
=> 'GenuineIntel',
134 'SandyBridge-IBRS' => 'GenuineIntel',
135 IvyBridge
=> 'GenuineIntel',
136 'IvyBridge-IBRS' => 'GenuineIntel',
137 Haswell
=> 'GenuineIntel',
138 'Haswell-IBRS' => 'GenuineIntel',
139 'Haswell-noTSX' => 'GenuineIntel',
140 'Haswell-noTSX-IBRS' => 'GenuineIntel',
141 Broadwell
=> 'GenuineIntel',
142 'Broadwell-IBRS' => 'GenuineIntel',
143 'Broadwell-noTSX' => 'GenuineIntel',
144 'Broadwell-noTSX-IBRS' => 'GenuineIntel',
145 'Skylake-Client' => 'GenuineIntel',
146 'Skylake-Client-IBRS' => 'GenuineIntel',
147 'Skylake-Server' => 'GenuineIntel',
148 'Skylake-Server-IBRS' => 'GenuineIntel',
151 athlon
=> 'AuthenticAMD',
152 phenom
=> 'AuthenticAMD',
153 Opteron_G1
=> 'AuthenticAMD',
154 Opteron_G2
=> 'AuthenticAMD',
155 Opteron_G3
=> 'AuthenticAMD',
156 Opteron_G4
=> 'AuthenticAMD',
157 Opteron_G5
=> 'AuthenticAMD',
158 EPYC
=> 'AuthenticAMD',
159 'EPYC-IBPB' => 'AuthenticAMD',
161 # generic types, use vendor from host node
170 my @supported_cpu_flags = (
184 my $cpu_flag = qr/[+-](@{[join('|', @supported_cpu_flags)]})/;
188 description
=> "Emulated CPU type.",
190 enum
=> [ sort { "\L$a" cmp "\L$b" } keys %$cpu_vendor_list ],
195 description
=> "Do not identify as a KVM virtual machine.",
202 pattern
=> qr/[a-zA-Z0-9]{1,12}/,
203 format_description
=> 'vendor-id',
204 description
=> 'The Hyper-V vendor ID. Some drivers or programs inside Windows guests need a specific ID.',
208 description
=> "List of additional CPU flags separated by ';'."
209 . " Use '+FLAG' to enable, '-FLAG' to disable a flag."
210 . " Currently supported flags: @{[join(', ', @supported_cpu_flags)]}.",
211 format_description
=> '+FLAG[;-FLAG...]',
213 pattern
=> qr/$cpu_flag(;$cpu_flag)*/,
222 enum
=> [qw(i6300esb ib700)],
223 description
=> "Watchdog type to emulate.",
224 default => 'i6300esb',
229 enum
=> [qw(reset shutdown poweroff pause debug none)],
230 description
=> "The action to perform if after activation the guest fails to poll the watchdog in time.",
234 PVE
::JSONSchema
::register_format
('pve-qm-watchdog', $watchdog_fmt);
238 description
=> "Enable/disable Qemu GuestAgent.",
243 fstrim_cloned_disks
=> {
244 description
=> "Run fstrim after cloning/moving a disk.",
253 description
=> "Select the VGA type.",
258 enum
=> [qw(cirrus qxl qxl2 qxl3 qxl4 none serial0 serial1 serial2 serial3 std virtio vmware)],
261 description
=> "Sets the VGA memory (in MiB). Has no effect with serial display.",
273 description
=> "The size of the file in MB.",
277 pattern
=> '[a-zA-Z0-9\-]+',
279 format_description
=> 'string',
280 description
=> "The name of the file. Will be prefixed with 'pve-shm-'. Default is the VMID. Will be deleted when the VM is stopped.",
287 enum
=> [qw(ich9-intel-hda intel-hda AC97)],
288 description
=> "Configure an audio device."
295 description
=> "Driver backend for the audio device."
299 my $spice_enhancements_fmt = {
304 description
=> "Enable folder sharing via SPICE. Needs Spice-WebDAV daemon installed in the VM."
308 enum
=> ['off', 'all', 'filter'],
311 description
=> "Enable video streaming. Uses compression for detected video streams."
319 description
=> "Specifies whether a VM will be started during system bootup.",
325 description
=> "Automatic restart after crash (currently ignored).",
330 type
=> 'string', format
=> 'pve-hotplug-features',
331 description
=> "Selectively enable hotplug features. This is a comma separated list of hotplug features: 'network', 'disk', 'cpu', 'memory' and 'usb'. Use '0' to disable hotplug completely. Value '1' is an alias for the default 'network,disk,usb'.",
332 default => 'network,disk,usb',
337 description
=> "Allow reboot. If set to '0' the VM exit on reboot.",
343 description
=> "Lock/unlock the VM.",
344 enum
=> [qw(backup clone create migrate rollback snapshot snapshot-delete suspending suspended)],
349 description
=> "Limit of CPU usage.",
350 verbose_description
=> "Limit of CPU usage.\n\nNOTE: If the computer has 2 CPUs, it has total of '2' CPU time. Value '0' indicates no CPU limit.",
358 description
=> "CPU weight for a VM.",
359 verbose_description
=> "CPU weight for a VM. Argument is used in the kernel fair scheduler. The larger the number is, the more CPU time this VM gets. Number is relative to weights of all the other running VMs.",
367 description
=> "Amount of RAM for the VM in MB. This is the maximum available memory when you use the balloon device.",
374 description
=> "Amount of target RAM for the VM in MB. Using zero disables the ballon driver.",
380 description
=> "Amount of memory shares for auto-ballooning. The larger the number is, the more memory this VM gets. Number is relative to weights of all other running VMs. Using zero disables auto-ballooning. Auto-ballooning is done by pvestatd.",
388 description
=> "Keybord layout for vnc server. Default is read from the '/etc/pve/datacenter.cfg' configuration file.".
389 "It should not be necessary to set it.",
390 enum
=> PVE
::Tools
::kvmkeymaplist
(),
395 type
=> 'string', format
=> 'dns-name',
396 description
=> "Set a name for the VM. Only used on the configuration web interface.",
401 description
=> "SCSI controller model",
402 enum
=> [qw(lsi lsi53c810 virtio-scsi-pci virtio-scsi-single megasas pvscsi)],
408 description
=> "Description for the VM. Only used on the configuration web interface. This is saved as comment inside the configuration file.",
413 enum
=> [qw(other wxp w2k w2k3 w2k8 wvista win7 win8 win10 l24 l26 solaris)],
414 description
=> "Specify guest operating system.",
415 verbose_description
=> <<EODESC,
416 Specify guest operating system. This is used to enable special
417 optimization/features for specific operating systems:
420 other;; unspecified OS
421 wxp;; Microsoft Windows XP
422 w2k;; Microsoft Windows 2000
423 w2k3;; Microsoft Windows 2003
424 w2k8;; Microsoft Windows 2008
425 wvista;; Microsoft Windows Vista
426 win7;; Microsoft Windows 7
427 win8;; Microsoft Windows 8/2012/2012r2
428 win10;; Microsoft Windows 10/2016
429 l24;; Linux 2.4 Kernel
430 l26;; Linux 2.6/3.X Kernel
431 solaris;; Solaris/OpenSolaris/OpenIndiania kernel
437 description
=> "Boot on floppy (a), hard disk (c), CD-ROM (d), or network (n).",
438 pattern
=> '[acdn]{1,4}',
443 type
=> 'string', format
=> 'pve-qm-bootdisk',
444 description
=> "Enable booting from specified disk.",
445 pattern
=> '(ide|sata|scsi|virtio)\d+',
450 description
=> "The number of CPUs. Please use option -sockets instead.",
457 description
=> "The number of CPU sockets.",
464 description
=> "The number of cores per socket.",
471 description
=> "Enable/disable NUMA.",
477 description
=> "Enable/disable hugepages memory.",
478 enum
=> [qw(any 2 1024)],
483 description
=> "Number of hotplugged vcpus.",
490 description
=> "Enable/disable ACPI.",
495 description
=> "Enable/disable Qemu GuestAgent and its properties.",
497 format
=> $agent_fmt,
502 description
=> "Enable/disable KVM hardware virtualization.",
508 description
=> "Enable/disable time drift fix.",
514 description
=> "Set the real time clock to local time. This is enabled by default if ostype indicates a Microsoft OS.",
519 description
=> "Freeze CPU at startup (use 'c' monitor command to start execution).",
523 type
=> 'string', format
=> $vga_fmt,
524 description
=> "Configure the VGA hardware.",
525 verbose_description
=> "Configure the VGA Hardware. If you want to use ".
526 "high resolution modes (>= 1280x1024x16) you may need to increase " .
527 "the vga memory option. Since QEMU 2.9 the default VGA display type " .
528 "is 'std' for all OS types besides some Windows versions (XP and " .
529 "older) which use 'cirrus'. The 'qxl' option enables the SPICE " .
530 "display server. For win* OS you can select how many independent " .
531 "displays you want, Linux guests can add displays them self.\n".
532 "You can also run without any graphic card, using a serial device as terminal.",
536 type
=> 'string', format
=> 'pve-qm-watchdog',
537 description
=> "Create a virtual hardware watchdog device.",
538 verbose_description
=> "Create a virtual hardware watchdog device. Once enabled" .
539 " (by a guest action), the watchdog must be periodically polled " .
540 "by an agent inside the guest or else the watchdog will reset " .
541 "the guest (or execute the respective action specified)",
546 typetext
=> "(now | YYYY-MM-DD | YYYY-MM-DDTHH:MM:SS)",
547 description
=> "Set the initial date of the real time clock. Valid format for date are: 'now' or '2006-06-17T16:01:21' or '2006-06-17'.",
548 pattern
=> '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
551 startup
=> get_standard_option
('pve-startup-order'),
555 description
=> "Enable/disable Template.",
561 description
=> "Arbitrary arguments passed to kvm.",
562 verbose_description
=> <<EODESCR,
563 Arbitrary arguments passed to kvm, for example:
565 args: -no-reboot -no-hpet
567 NOTE: this option is for experts only.
574 description
=> "Enable/disable the USB tablet device.",
575 verbose_description
=> "Enable/disable the USB tablet device. This device is " .
576 "usually needed to allow absolute mouse positioning with VNC. " .
577 "Else the mouse runs out of sync with normal VNC clients. " .
578 "If you're running lots of console-only guests on one host, " .
579 "you may consider disabling this to save some context switches. " .
580 "This is turned off by default if you use spice (-vga=qxl).",
585 description
=> "Set maximum speed (in MB/s) for migrations. Value 0 is no limit.",
589 migrate_downtime
=> {
592 description
=> "Set maximum tolerated downtime (in seconds) for migrations.",
598 type
=> 'string', format
=> 'pve-qm-ide',
599 typetext
=> '<volume>',
600 description
=> "This is an alias for option -ide2",
604 description
=> "Emulated CPU type.",
608 parent
=> get_standard_option
('pve-snapshot-name', {
610 description
=> "Parent snapshot name. This is used internally, and should not be modified.",
614 description
=> "Timestamp for snapshots.",
620 type
=> 'string', format
=> 'pve-volume-id',
621 description
=> "Reference to a volume which stores the VM state. This is used internally for snapshots.",
623 vmstatestorage
=> get_standard_option
('pve-storage-id', {
624 description
=> "Default storage for VM state volumes/files.",
627 runningmachine
=> get_standard_option
('pve-qemu-machine', {
628 description
=> "Specifies the Qemu machine type of the running vm. This is used internally for snapshots.",
630 machine
=> get_standard_option
('pve-qemu-machine'),
632 description
=> "Virtual processor architecture. Defaults to the host.",
635 enum
=> [qw(x86_64 aarch64)],
638 description
=> "Specify SMBIOS type 1 fields.",
639 type
=> 'string', format
=> 'pve-qm-smbios1',
646 description
=> "Sets the protection flag of the VM. This will disable the remove VM and remove disk operations.",
652 enum
=> [ qw(seabios ovmf) ],
653 description
=> "Select BIOS implementation.",
654 default => 'seabios',
658 pattern
=> '(?:[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}|[01])',
659 format_description
=> 'UUID',
660 description
=> "Set VM Generation ID. Use '1' to autogenerate on create or update, pass '0' to disable explicitly.",
661 verbose_description
=> "The VM generation ID (vmgenid) device exposes a".
662 " 128-bit integer value identifier to the guest OS. This allows to".
663 " notify the guest operating system when the virtual machine is".
664 " executed with a different configuration (e.g. snapshot execution".
665 " or creation from a template). The guest operating system notices".
666 " the change, and is then able to react as appropriate by marking".
667 " its copies of distributed databases as dirty, re-initializing its".
668 " random number generator, etc.\n".
669 "Note that auto-creation only works when done throug API/CLI create".
670 " or update methods, but not when manually editing the config file.",
671 default => "1 (autogenerated)",
676 format
=> 'pve-volume-id',
678 description
=> "Script that will be executed during various steps in the vms lifetime.",
682 format
=> $ivshmem_fmt,
683 description
=> "Inter-VM shared memory. Useful for direct communication between VMs, or to the host.",
688 format
=> $audio_fmt,
689 description
=> "Configure a audio device, useful in combination with QXL/Spice.",
692 spice_enhancements
=> {
694 format
=> $spice_enhancements_fmt,
695 description
=> "Configure additional enhancements for SPICE.",
704 description
=> 'Specify a custom file containing all meta data passed to the VM via cloud-init. This is provider specific meaning configdrive2 and nocloud differ.',
705 format
=> 'pve-volume-id',
706 format_description
=> 'volume',
711 description
=> 'Specify a custom file containing all network data passed to the VM via cloud-init.',
712 format
=> 'pve-volume-id',
713 format_description
=> 'volume',
718 description
=> 'Specify a custom file containing all user data passed to the VM via cloud-init.',
719 format
=> 'pve-volume-id',
720 format_description
=> 'volume',
723 PVE
::JSONSchema
::register_format
('pve-qm-cicustom', $cicustom_fmt);
725 my $confdesc_cloudinit = {
729 description
=> 'Specifies the cloud-init configuration format. The default depends on the configured operating system type (`ostype`. We use the `nocloud` format for Linux, and `configdrive2` for windows.',
730 enum
=> ['configdrive2', 'nocloud'],
735 description
=> "cloud-init: User name to change ssh keys and password for instead of the image's configured default user.",
740 description
=> 'cloud-init: Password to assign the user. Using this is generally not recommended. Use ssh keys instead. Also note that older cloud-init versions do not support hashed passwords.',
745 description
=> 'cloud-init: Specify custom files to replace the automatically generated ones at start.',
746 format
=> 'pve-qm-cicustom',
751 description
=> "cloud-init: Sets DNS search domains for a container. Create will automatically use the setting from the host if neither searchdomain nor nameserver are set.",
755 type
=> 'string', format
=> 'address-list',
756 description
=> "cloud-init: Sets DNS server IP address for a container. Create will automatically use the setting from the host if neither searchdomain nor nameserver are set.",
761 format
=> 'urlencoded',
762 description
=> "cloud-init: Setup public SSH keys (one key per line, OpenSSH format).",
766 # what about other qemu settings ?
768 #machine => 'string',
781 ##soundhw => 'string',
783 while (my ($k, $v) = each %$confdesc) {
784 PVE
::JSONSchema
::register_standard_option
("pve-qm-$k", $v);
787 my $MAX_IDE_DISKS = 4;
788 my $MAX_SCSI_DISKS = 14;
789 my $MAX_VIRTIO_DISKS = 16;
790 my $MAX_SATA_DISKS = 6;
791 my $MAX_USB_DEVICES = 5;
793 my $MAX_UNUSED_DISKS = 256;
794 my $MAX_HOSTPCI_DEVICES = 16;
795 my $MAX_SERIAL_PORTS = 4;
796 my $MAX_PARALLEL_PORTS = 3;
802 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
803 description
=> "CPUs accessing this NUMA node.",
804 format_description
=> "id[-id];...",
808 description
=> "Amount of memory this NUMA node provides.",
813 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
814 description
=> "Host NUMA nodes to use.",
815 format_description
=> "id[-id];...",
820 enum
=> [qw(preferred bind interleave)],
821 description
=> "NUMA allocation policy.",
825 PVE
::JSONSchema
::register_format
('pve-qm-numanode', $numa_fmt);
828 type
=> 'string', format
=> $numa_fmt,
829 description
=> "NUMA topology.",
831 PVE
::JSONSchema
::register_standard_option
("pve-qm-numanode", $numadesc);
833 for (my $i = 0; $i < $MAX_NUMA; $i++) {
834 $confdesc->{"numa$i"} = $numadesc;
837 my $nic_model_list = ['rtl8139', 'ne2k_pci', 'e1000', 'pcnet', 'virtio',
838 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3',
839 'e1000-82540em', 'e1000-82544gc', 'e1000-82545em'];
840 my $nic_model_list_txt = join(' ', sort @$nic_model_list);
842 my $net_fmt_bridge_descr = <<__EOD__;
843 Bridge to attach the network device to. The Proxmox VE standard bridge
846 If you do not specify a bridge, we create a kvm user (NATed) network
847 device, which provides DHCP and DNS services. The following addresses
854 The DHCP server assign addresses to the guest starting from 10.0.2.15.
858 macaddr
=> get_standard_option
('mac-addr', {
859 description
=> "MAC address. That address must be unique withing your network. This is automatically generated if not specified.",
863 description
=> "Network Card Model. The 'virtio' model provides the best performance with very low CPU overhead. If your guest does not support this driver, it is usually best to use 'e1000'.",
864 enum
=> $nic_model_list,
867 (map { $_ => { keyAlias
=> 'model', alias
=> 'macaddr' }} @$nic_model_list),
870 description
=> $net_fmt_bridge_descr,
871 format_description
=> 'bridge',
876 minimum
=> 0, maximum
=> 16,
877 description
=> 'Number of packet queues to be used on the device.',
883 description
=> "Rate limit in mbps (megabytes per second) as floating point number.",
888 minimum
=> 1, maximum
=> 4094,
889 description
=> 'VLAN tag to apply to packets on this interface.',
894 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
895 description
=> 'VLAN trunks to pass through this interface.',
896 format_description
=> 'vlanid[;vlanid...]',
901 description
=> 'Whether this interface should be protected by the firewall.',
906 description
=> 'Whether this interface should be disconnected (like pulling the plug).',
913 type
=> 'string', format
=> $net_fmt,
914 description
=> "Specify network devices.",
917 PVE
::JSONSchema
::register_standard_option
("pve-qm-net", $netdesc);
922 format
=> 'pve-ipv4-config',
923 format_description
=> 'IPv4Format/CIDR',
924 description
=> 'IPv4 address in CIDR format.',
931 format_description
=> 'GatewayIPv4',
932 description
=> 'Default gateway for IPv4 traffic.',
938 format
=> 'pve-ipv6-config',
939 format_description
=> 'IPv6Format/CIDR',
940 description
=> 'IPv6 address in CIDR format.',
947 format_description
=> 'GatewayIPv6',
948 description
=> 'Default gateway for IPv6 traffic.',
953 PVE
::JSONSchema
::register_format
('pve-qm-ipconfig', $ipconfig_fmt);
956 type
=> 'string', format
=> 'pve-qm-ipconfig',
957 description
=> <<'EODESCR',
958 cloud-init: Specify IP addresses and gateways for the corresponding interface.
960 IP addresses use CIDR notation, gateways are optional but need an IP of the same type specified.
962 The special string 'dhcp' can be used for IP addresses to use DHCP, in which case no explicit gateway should be provided.
963 For IPv6 the special string 'auto' can be used to use stateless autoconfiguration.
965 If cloud-init is enabled and neither an IPv4 nor an IPv6 address is specified, it defaults to using dhcp on IPv4.
968 PVE
::JSONSchema
::register_standard_option
("pve-qm-ipconfig", $netdesc);
970 for (my $i = 0; $i < $MAX_NETS; $i++) {
971 $confdesc->{"net$i"} = $netdesc;
972 $confdesc_cloudinit->{"ipconfig$i"} = $ipconfigdesc;
975 foreach my $key (keys %$confdesc_cloudinit) {
976 $confdesc->{$key} = $confdesc_cloudinit->{$key};
979 PVE
::JSONSchema
::register_format
('pve-volume-id-or-qm-path', \
&verify_volume_id_or_qm_path
);
980 sub verify_volume_id_or_qm_path
{
981 my ($volid, $noerr) = @_;
983 if ($volid eq 'none' || $volid eq 'cdrom' || $volid =~ m
|^/|) {
987 # if its neither 'none' nor 'cdrom' nor a path, check if its a volume-id
988 $volid = eval { PVE
::JSONSchema
::check_format
('pve-volume-id', $volid, '') };
990 return undef if $noerr;
998 my %drivedesc_base = (
999 volume
=> { alias
=> 'file' },
1002 format
=> 'pve-volume-id-or-qm-path',
1004 format_description
=> 'volume',
1005 description
=> "The drive's backing volume.",
1009 enum
=> [qw(cdrom disk)],
1010 description
=> "The drive's media type.",
1016 description
=> "Force the drive's physical geometry to have a specific cylinder count.",
1021 description
=> "Force the drive's physical geometry to have a specific head count.",
1026 description
=> "Force the drive's physical geometry to have a specific sector count.",
1031 enum
=> [qw(none lba auto)],
1032 description
=> "Force disk geometry bios translation mode.",
1037 description
=> "Controls qemu's snapshot mode feature."
1038 . " If activated, changes made to the disk are temporary and will"
1039 . " be discarded when the VM is shutdown.",
1044 enum
=> [qw(none writethrough writeback unsafe directsync)],
1045 description
=> "The drive's cache mode",
1048 format
=> get_standard_option
('pve-qm-image-format'),
1051 format
=> 'disk-size',
1052 format_description
=> 'DiskSize',
1053 description
=> "Disk size. This is purely informational and has no effect.",
1058 description
=> "Whether the drive should be included when making backups.",
1063 description
=> 'Whether the drive should considered for replication jobs.',
1069 enum
=> [qw(ignore report stop)],
1070 description
=> 'Read error action.',
1075 enum
=> [qw(enospc ignore report stop)],
1076 description
=> 'Write error action.',
1081 enum
=> [qw(native threads)],
1082 description
=> 'AIO type to use.',
1087 enum
=> [qw(ignore on)],
1088 description
=> 'Controls whether to pass discard/trim requests to the underlying storage.',
1093 description
=> 'Controls whether to detect and try to optimize writes of zeroes.',
1098 format
=> 'urlencoded',
1099 format_description
=> 'serial',
1100 maxLength
=> 20*3, # *3 since it's %xx url enoded
1101 description
=> "The drive's reported serial number, url-encoded, up to 20 bytes long.",
1106 description
=> 'Mark this locally-managed volume as available on all nodes',
1107 verbose_description
=> "Mark this locally-managed volume as available on all nodes.\n\nWARNING: This option does not share the volume automatically, it assumes it is shared already!",
1113 my %iothread_fmt = ( iothread
=> {
1115 description
=> "Whether to use iothreads for this drive",
1122 format
=> 'urlencoded',
1123 format_description
=> 'model',
1124 maxLength
=> 40*3, # *3 since it's %xx url enoded
1125 description
=> "The drive's reported model name, url-encoded, up to 40 bytes long.",
1133 description
=> "Number of queues.",
1139 my %scsiblock_fmt = (
1142 description
=> "whether to use scsi-block for full passthrough of host block device\n\nWARNING: can lead to I/O errors in combination with low memory or high memory fragmentation on host",
1151 description
=> "Whether to expose this drive as an SSD, rather than a rotational hard disk.",
1159 pattern
=> qr/^(0x)[0-9a-fA-F]{16}/,
1160 format_description
=> 'wwn',
1161 description
=> "The drive's worldwide name, encoded as 16 bytes hex string, prefixed by '0x'.",
1166 my $add_throttle_desc = sub {
1167 my ($key, $type, $what, $unit, $longunit, $minimum) = @_;
1170 format_description
=> $unit,
1171 description
=> "Maximum $what in $longunit.",
1174 $d->{minimum
} = $minimum if defined($minimum);
1175 $drivedesc_base{$key} = $d;
1177 # throughput: (leaky bucket)
1178 $add_throttle_desc->('bps', 'integer', 'r/w speed', 'bps', 'bytes per second');
1179 $add_throttle_desc->('bps_rd', 'integer', 'read speed', 'bps', 'bytes per second');
1180 $add_throttle_desc->('bps_wr', 'integer', 'write speed', 'bps', 'bytes per second');
1181 $add_throttle_desc->('mbps', 'number', 'r/w speed', 'mbps', 'megabytes per second');
1182 $add_throttle_desc->('mbps_rd', 'number', 'read speed', 'mbps', 'megabytes per second');
1183 $add_throttle_desc->('mbps_wr', 'number', 'write speed', 'mbps', 'megabytes per second');
1184 $add_throttle_desc->('iops', 'integer', 'r/w I/O', 'iops', 'operations per second');
1185 $add_throttle_desc->('iops_rd', 'integer', 'read I/O', 'iops', 'operations per second');
1186 $add_throttle_desc->('iops_wr', 'integer', 'write I/O', 'iops', 'operations per second');
1188 # pools: (pool of IO before throttling starts taking effect)
1189 $add_throttle_desc->('mbps_max', 'number', 'unthrottled r/w pool', 'mbps', 'megabytes per second');
1190 $add_throttle_desc->('mbps_rd_max', 'number', 'unthrottled read pool', 'mbps', 'megabytes per second');
1191 $add_throttle_desc->('mbps_wr_max', 'number', 'unthrottled write pool', 'mbps', 'megabytes per second');
1192 $add_throttle_desc->('iops_max', 'integer', 'unthrottled r/w I/O pool', 'iops', 'operations per second');
1193 $add_throttle_desc->('iops_rd_max', 'integer', 'unthrottled read I/O pool', 'iops', 'operations per second');
1194 $add_throttle_desc->('iops_wr_max', 'integer', 'unthrottled write I/O pool', 'iops', 'operations per second');
1197 $add_throttle_desc->('bps_max_length', 'integer', 'length of I/O bursts', 'seconds', 'seconds', 1);
1198 $add_throttle_desc->('bps_rd_max_length', 'integer', 'length of read I/O bursts', 'seconds', 'seconds', 1);
1199 $add_throttle_desc->('bps_wr_max_length', 'integer', 'length of write I/O bursts', 'seconds', 'seconds', 1);
1200 $add_throttle_desc->('iops_max_length', 'integer', 'length of I/O bursts', 'seconds', 'seconds', 1);
1201 $add_throttle_desc->('iops_rd_max_length', 'integer', 'length of read I/O bursts', 'seconds', 'seconds', 1);
1202 $add_throttle_desc->('iops_wr_max_length', 'integer', 'length of write I/O bursts', 'seconds', 'seconds', 1);
1205 $drivedesc_base{'bps_rd_length'} = { alias
=> 'bps_rd_max_length' };
1206 $drivedesc_base{'bps_wr_length'} = { alias
=> 'bps_wr_max_length' };
1207 $drivedesc_base{'iops_rd_length'} = { alias
=> 'iops_rd_max_length' };
1208 $drivedesc_base{'iops_wr_length'} = { alias
=> 'iops_wr_max_length' };
1216 PVE
::JSONSchema
::register_format
("pve-qm-ide", $ide_fmt);
1220 type
=> 'string', format
=> $ide_fmt,
1221 description
=> "Use volume as IDE hard disk or CD-ROM (n is 0 to " .($MAX_IDE_DISKS -1) . ").",
1223 PVE
::JSONSchema
::register_standard_option
("pve-qm-ide", $idedesc);
1235 type
=> 'string', format
=> $scsi_fmt,
1236 description
=> "Use volume as SCSI hard disk or CD-ROM (n is 0 to " . ($MAX_SCSI_DISKS - 1) . ").",
1238 PVE
::JSONSchema
::register_standard_option
("pve-qm-scsi", $scsidesc);
1247 type
=> 'string', format
=> $sata_fmt,
1248 description
=> "Use volume as SATA hard disk or CD-ROM (n is 0 to " . ($MAX_SATA_DISKS - 1). ").",
1250 PVE
::JSONSchema
::register_standard_option
("pve-qm-sata", $satadesc);
1258 type
=> 'string', format
=> $virtio_fmt,
1259 description
=> "Use volume as VIRTIO hard disk (n is 0 to " . ($MAX_VIRTIO_DISKS - 1) . ").",
1261 PVE
::JSONSchema
::register_standard_option
("pve-qm-virtio", $virtiodesc);
1263 my $alldrive_fmt = {
1274 volume
=> { alias
=> 'file' },
1277 format
=> 'pve-volume-id-or-qm-path',
1279 format_description
=> 'volume',
1280 description
=> "The drive's backing volume.",
1282 format
=> get_standard_option
('pve-qm-image-format'),
1285 format
=> 'disk-size',
1286 format_description
=> 'DiskSize',
1287 description
=> "Disk size. This is purely informational and has no effect.",
1292 my $efidisk_desc = {
1294 type
=> 'string', format
=> $efidisk_fmt,
1295 description
=> "Configure a Disk for storing EFI vars",
1298 PVE
::JSONSchema
::register_standard_option
("pve-qm-efidisk", $efidisk_desc);
1303 type
=> 'string', format
=> 'pve-qm-usb-device',
1304 format_description
=> 'HOSTUSBDEVICE|spice',
1305 description
=> <<EODESCR,
1306 The Host USB device or port or the value 'spice'. HOSTUSBDEVICE syntax is:
1308 'bus-port(.port)*' (decimal numbers) or
1309 'vendor_id:product_id' (hexadeciaml numbers) or
1312 You can use the 'lsusb -t' command to list existing usb devices.
1314 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
1316 The value 'spice' can be used to add a usb redirection devices for spice.
1322 description
=> "Specifies whether if given host option is a USB3 device or port (this does currently not work reliably with spice redirection and is then ignored).",
1329 type
=> 'string', format
=> $usb_fmt,
1330 description
=> "Configure an USB device (n is 0 to 4).",
1332 PVE
::JSONSchema
::register_standard_option
("pve-qm-usb", $usbdesc);
1334 my $PCIRE = qr/[a-f0-9]{2}:[a-f0-9]{2}(?:\.[a-f0-9])?/;
1339 pattern
=> qr/$PCIRE(;$PCIRE)*/,
1340 format_description
=> 'HOSTPCIID[;HOSTPCIID2...]',
1341 description
=> <<EODESCR,
1342 Host PCI device pass through. The PCI ID of a host's PCI device or a list
1343 of PCI virtual functions of the host. HOSTPCIID syntax is:
1345 'bus:dev.func' (hexadecimal numbers)
1347 You can us the 'lspci' command to list existing PCI devices.
1352 description
=> "Specify whether or not the device's ROM will be visible in the guest's memory map.",
1358 pattern
=> '[^,;]+',
1359 format_description
=> 'string',
1360 description
=> "Custom pci device rom filename (must be located in /usr/share/kvm/).",
1365 description
=> "Choose the PCI-express bus (needs the 'q35' machine model).",
1371 description
=> "Enable vfio-vga device support.",
1377 format_description
=> 'string',
1378 pattern
=> '[^/\.:]+',
1380 description
=> <<EODESCR
1381 The type of mediated device to use.
1382 An instance of this type will be created on startup of the VM and
1383 will be cleaned up when the VM stops.
1387 PVE
::JSONSchema
::register_format
('pve-qm-hostpci', $hostpci_fmt);
1391 type
=> 'string', format
=> 'pve-qm-hostpci',
1392 description
=> "Map host PCI devices into guest.",
1393 verbose_description
=> <<EODESCR,
1394 Map host PCI devices into guest.
1396 NOTE: This option allows direct access to host hardware. So it is no longer
1397 possible to migrate such machines - use with special care.
1399 CAUTION: Experimental! User reported problems with this option.
1402 PVE
::JSONSchema
::register_standard_option
("pve-qm-hostpci", $hostpcidesc);
1407 pattern
=> '(/dev/.+|socket)',
1408 description
=> "Create a serial device inside the VM (n is 0 to 3)",
1409 verbose_description
=> <<EODESCR,
1410 Create a serial device inside the VM (n is 0 to 3), and pass through a
1411 host serial device (i.e. /dev/ttyS0), or create a unix socket on the
1412 host side (use 'qm terminal' to open a terminal connection).
1414 NOTE: If you pass through a host serial device, it is no longer possible to migrate such machines - use with special care.
1416 CAUTION: Experimental! User reported problems with this option.
1423 pattern
=> '/dev/parport\d+|/dev/usb/lp\d+',
1424 description
=> "Map host parallel devices (n is 0 to 2).",
1425 verbose_description
=> <<EODESCR,
1426 Map host parallel devices (n is 0 to 2).
1428 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
1430 CAUTION: Experimental! User reported problems with this option.
1434 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
1435 $confdesc->{"parallel$i"} = $paralleldesc;
1438 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
1439 $confdesc->{"serial$i"} = $serialdesc;
1442 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
1443 $confdesc->{"hostpci$i"} = $hostpcidesc;
1446 for (my $i = 0; $i < $MAX_IDE_DISKS; $i++) {
1447 $drivename_hash->{"ide$i"} = 1;
1448 $confdesc->{"ide$i"} = $idedesc;
1451 for (my $i = 0; $i < $MAX_SATA_DISKS; $i++) {
1452 $drivename_hash->{"sata$i"} = 1;
1453 $confdesc->{"sata$i"} = $satadesc;
1456 for (my $i = 0; $i < $MAX_SCSI_DISKS; $i++) {
1457 $drivename_hash->{"scsi$i"} = 1;
1458 $confdesc->{"scsi$i"} = $scsidesc ;
1461 for (my $i = 0; $i < $MAX_VIRTIO_DISKS; $i++) {
1462 $drivename_hash->{"virtio$i"} = 1;
1463 $confdesc->{"virtio$i"} = $virtiodesc;
1466 $drivename_hash->{efidisk0
} = 1;
1467 $confdesc->{efidisk0
} = $efidisk_desc;
1469 for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
1470 $confdesc->{"usb$i"} = $usbdesc;
1475 type
=> 'string', format
=> 'pve-volume-id',
1476 description
=> "Reference to unused volumes. This is used internally, and should not be modified manually.",
1479 for (my $i = 0; $i < $MAX_UNUSED_DISKS; $i++) {
1480 $confdesc->{"unused$i"} = $unuseddesc;
1483 my $kvm_api_version = 0;
1486 return $kvm_api_version if $kvm_api_version;
1488 open my $fh, '<', '/dev/kvm'
1491 # 0xae00 => KVM_GET_API_VERSION
1492 $kvm_api_version = ioctl($fh, 0xae00, 0);
1494 return $kvm_api_version;
1497 my $kvm_user_version = {};
1500 sub kvm_user_version
{
1503 $binary //= get_command_for_arch
(get_host_arch
()); # get the native arch by default
1504 my $st = stat($binary);
1506 my $cachedmtime = $kvm_mtime->{$binary} // -1;
1507 return $kvm_user_version->{$binary} if $kvm_user_version->{$binary} &&
1508 $cachedmtime == $st->mtime;
1510 $kvm_user_version->{$binary} = 'unknown';
1511 $kvm_mtime->{$binary} = $st->mtime;
1515 if ($line =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)(\.\d+)?[,\s]/) {
1516 $kvm_user_version->{$binary} = $2;
1520 eval { run_command
([$binary, '--version'], outfunc
=> $code); };
1523 return $kvm_user_version->{$binary};
1527 sub kernel_has_vhost_net
{
1528 return -c
'/dev/vhost-net';
1531 sub valid_drive_names
{
1532 # order is important - used to autoselect boot disk
1533 return ((map { "ide$_" } (0 .. ($MAX_IDE_DISKS - 1))),
1534 (map { "scsi$_" } (0 .. ($MAX_SCSI_DISKS - 1))),
1535 (map { "virtio$_" } (0 .. ($MAX_VIRTIO_DISKS - 1))),
1536 (map { "sata$_" } (0 .. ($MAX_SATA_DISKS - 1))),
1540 sub is_valid_drivename
{
1543 return defined($drivename_hash->{$dev});
1548 return defined($confdesc->{$key});
1552 return $nic_model_list;
1555 sub os_list_description
{
1559 wxp
=> 'Windows XP',
1560 w2k
=> 'Windows 2000',
1561 w2k3
=>, 'Windows 2003',
1562 w2k8
=> 'Windows 2008',
1563 wvista
=> 'Windows Vista',
1564 win7
=> 'Windows 7',
1565 win8
=> 'Windows 8/2012',
1566 win10
=> 'Windows 10/2016',
1574 sub get_cdrom_path
{
1576 return $cdrom_path if $cdrom_path;
1578 return $cdrom_path = "/dev/cdrom" if -l
"/dev/cdrom";
1579 return $cdrom_path = "/dev/cdrom1" if -l
"/dev/cdrom1";
1580 return $cdrom_path = "/dev/cdrom2" if -l
"/dev/cdrom2";
1584 my ($storecfg, $vmid, $cdrom) = @_;
1586 if ($cdrom eq 'cdrom') {
1587 return get_cdrom_path
();
1588 } elsif ($cdrom eq 'none') {
1590 } elsif ($cdrom =~ m
|^/|) {
1593 return PVE
::Storage
::path
($storecfg, $cdrom);
1597 # try to convert old style file names to volume IDs
1598 sub filename_to_volume_id
{
1599 my ($vmid, $file, $media) = @_;
1601 if (!($file eq 'none' || $file eq 'cdrom' ||
1602 $file =~ m
|^/dev/.+| || $file =~ m/^([^:]+):(.+)$/)) {
1604 return undef if $file =~ m
|/|;
1606 if ($media && $media eq 'cdrom') {
1607 $file = "local:iso/$file";
1609 $file = "local:$vmid/$file";
1616 sub verify_media_type
{
1617 my ($opt, $vtype, $media) = @_;
1622 if ($media eq 'disk') {
1624 } elsif ($media eq 'cdrom') {
1627 die "internal error";
1630 return if ($vtype eq $etype);
1632 raise_param_exc
({ $opt => "unexpected media type ($vtype != $etype)" });
1635 sub cleanup_drive_path
{
1636 my ($opt, $storecfg, $drive) = @_;
1638 # try to convert filesystem paths to volume IDs
1640 if (($drive->{file
} !~ m/^(cdrom|none)$/) &&
1641 ($drive->{file
} !~ m
|^/dev/.+|) &&
1642 ($drive->{file
} !~ m/^([^:]+):(.+)$/) &&
1643 ($drive->{file
} !~ m/^\d+$/)) {
1644 my ($vtype, $volid) = PVE
::Storage
::path_to_volume_id
($storecfg, $drive->{file
});
1645 raise_param_exc
({ $opt => "unable to associate path '$drive->{file}' to any storage"}) if !$vtype;
1646 $drive->{media
} = 'cdrom' if !$drive->{media
} && $vtype eq 'iso';
1647 verify_media_type
($opt, $vtype, $drive->{media
});
1648 $drive->{file
} = $volid;
1651 $drive->{media
} = 'cdrom' if !$drive->{media
} && $drive->{file
} =~ m/^(cdrom|none)$/;
1654 sub parse_hotplug_features
{
1659 return $res if $data eq '0';
1661 $data = $confdesc->{hotplug
}->{default} if $data eq '1';
1663 foreach my $feature (PVE
::Tools
::split_list
($data)) {
1664 if ($feature =~ m/^(network|disk|cpu|memory|usb)$/) {
1667 die "invalid hotplug feature '$feature'\n";
1673 PVE
::JSONSchema
::register_format
('pve-hotplug-features', \
&pve_verify_hotplug_features
);
1674 sub pve_verify_hotplug_features
{
1675 my ($value, $noerr) = @_;
1677 return $value if parse_hotplug_features
($value);
1679 return undef if $noerr;
1681 die "unable to parse hotplug option\n";
1684 # ideX = [volume=]volume-id[,media=d][,cyls=c,heads=h,secs=s[,trans=t]]
1685 # [,snapshot=on|off][,cache=on|off][,format=f][,backup=yes|no]
1686 # [,rerror=ignore|report|stop][,werror=enospc|ignore|report|stop]
1687 # [,aio=native|threads][,discard=ignore|on][,detect_zeroes=on|off]
1688 # [,iothread=on][,serial=serial][,model=model]
1691 my ($key, $data) = @_;
1693 my ($interface, $index);
1695 if ($key =~ m/^([^\d]+)(\d+)$/) {
1702 my $desc = $key =~ /^unused\d+$/ ?
$alldrive_fmt
1703 : $confdesc->{$key}->{format
};
1705 warn "invalid drive key: $key\n";
1708 my $res = eval { PVE
::JSONSchema
::parse_property_string
($desc, $data) };
1709 return undef if !$res;
1710 $res->{interface
} = $interface;
1711 $res->{index} = $index;
1714 foreach my $opt (qw(bps bps_rd bps_wr)) {
1715 if (my $bps = defined(delete $res->{$opt})) {
1716 if (defined($res->{"m$opt"})) {
1717 warn "both $opt and m$opt specified\n";
1721 $res->{"m$opt"} = sprintf("%.3f", $bps / (1024*1024.0));
1725 # can't use the schema's 'requires' because of the mbps* => bps* "transforming aliases"
1726 for my $requirement (
1727 [mbps_max
=> 'mbps'],
1728 [mbps_rd_max
=> 'mbps_rd'],
1729 [mbps_wr_max
=> 'mbps_wr'],
1730 [miops_max
=> 'miops'],
1731 [miops_rd_max
=> 'miops_rd'],
1732 [miops_wr_max
=> 'miops_wr'],
1733 [bps_max_length
=> 'mbps_max'],
1734 [bps_rd_max_length
=> 'mbps_rd_max'],
1735 [bps_wr_max_length
=> 'mbps_wr_max'],
1736 [iops_max_length
=> 'iops_max'],
1737 [iops_rd_max_length
=> 'iops_rd_max'],
1738 [iops_wr_max_length
=> 'iops_wr_max']) {
1739 my ($option, $requires) = @$requirement;
1740 if ($res->{$option} && !$res->{$requires}) {
1741 warn "$option requires $requires\n";
1746 return undef if $error;
1748 return undef if $res->{mbps_rd
} && $res->{mbps
};
1749 return undef if $res->{mbps_wr
} && $res->{mbps
};
1750 return undef if $res->{iops_rd
} && $res->{iops
};
1751 return undef if $res->{iops_wr
} && $res->{iops
};
1753 if ($res->{media
} && ($res->{media
} eq 'cdrom')) {
1754 return undef if $res->{snapshot
} || $res->{trans
} || $res->{format
};
1755 return undef if $res->{heads
} || $res->{secs
} || $res->{cyls
};
1756 return undef if $res->{interface
} eq 'virtio';
1759 if (my $size = $res->{size
}) {
1760 return undef if !defined($res->{size
} = PVE
::JSONSchema
::parse_size
($size));
1767 my ($vmid, $drive) = @_;
1768 my $data = { %$drive };
1769 delete $data->{$_} for qw(index interface);
1770 return PVE
::JSONSchema
::print_property_string
($data, $alldrive_fmt);
1774 my($fh, $noerr) = @_;
1777 my $SG_GET_VERSION_NUM = 0x2282;
1779 my $versionbuf = "\x00" x
8;
1780 my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
1782 die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
1785 my $version = unpack("I", $versionbuf);
1786 if ($version < 30000) {
1787 die "scsi generic interface too old\n" if !$noerr;
1791 my $buf = "\x00" x
36;
1792 my $sensebuf = "\x00" x
8;
1793 my $cmd = pack("C x3 C x1", 0x12, 36);
1795 # see /usr/include/scsi/sg.h
1796 my $sg_io_hdr_t = "i i C C s I P P P I I i P C C C C S S i I I";
1798 my $packet = pack($sg_io_hdr_t, ord('S'), -3, length($cmd),
1799 length($sensebuf), 0, length($buf), $buf,
1800 $cmd, $sensebuf, 6000);
1802 $ret = ioctl($fh, $SG_IO, $packet);
1804 die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
1808 my @res = unpack($sg_io_hdr_t, $packet);
1809 if ($res[17] || $res[18]) {
1810 die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
1815 (my $byte0, my $byte1, $res->{vendor
},
1816 $res->{product
}, $res->{revision
}) = unpack("C C x6 A8 A16 A4", $buf);
1818 $res->{removable
} = $byte1 & 128 ?
1 : 0;
1819 $res->{type
} = $byte0 & 31;
1827 my $fh = IO
::File-
>new("+<$path") || return undef;
1828 my $res = scsi_inquiry
($fh, 1);
1834 sub machine_type_is_q35
{
1837 return $conf->{machine
} && ($conf->{machine
} =~ m/q35/) ?
1 : 0;
1840 sub print_tabletdevice_full
{
1841 my ($conf, $arch) = @_;
1843 my $q35 = machine_type_is_q35
($conf);
1845 # we use uhci for old VMs because tablet driver was buggy in older qemu
1847 if (machine_type_is_q35
($conf) || $arch eq 'aarch64') {
1853 return "usb-tablet,id=tablet,bus=$usbbus.0,port=1";
1856 sub print_keyboarddevice_full
{
1857 my ($conf, $arch, $machine) = @_;
1859 return undef if $arch ne 'aarch64';
1861 return "usb-kbd,id=keyboard,bus=ehci.0,port=2";
1864 sub print_drivedevice_full
{
1865 my ($storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type) = @_;
1870 if ($drive->{interface
} eq 'virtio') {
1871 my $pciaddr = print_pci_addr
("$drive->{interface}$drive->{index}", $bridges, $arch, $machine_type);
1872 $device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
1873 $device .= ",iothread=iothread-$drive->{interface}$drive->{index}" if $drive->{iothread
};
1874 } elsif ($drive->{interface
} eq 'scsi') {
1876 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
1877 my $unit = $drive->{index} % $maxdev;
1878 my $devicetype = 'hd';
1880 if (drive_is_cdrom
($drive)) {
1883 if ($drive->{file
} =~ m
|^/|) {
1884 $path = $drive->{file
};
1885 if (my $info = path_is_scsi
($path)) {
1886 if ($info->{type
} == 0 && $drive->{scsiblock
}) {
1887 $devicetype = 'block';
1888 } elsif ($info->{type
} == 1) { # tape
1889 $devicetype = 'generic';
1893 $path = PVE
::Storage
::path
($storecfg, $drive->{file
});
1896 if($path =~ m/^iscsi\:\/\
//){
1897 $devicetype = 'generic';
1901 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)){
1902 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,scsi-id=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1904 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,channel=0,scsi-id=0,lun=$drive->{index},drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1907 if ($drive->{ssd
} && ($devicetype eq 'block' || $devicetype eq 'hd')) {
1908 $device .= ",rotation_rate=1";
1910 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1912 } elsif ($drive->{interface
} eq 'ide' || $drive->{interface
} eq 'sata') {
1913 my $maxdev = ($drive->{interface
} eq 'sata') ?
$MAX_SATA_DISKS : 2;
1914 my $controller = int($drive->{index} / $maxdev);
1915 my $unit = $drive->{index} % $maxdev;
1916 my $devicetype = ($drive->{media
} && $drive->{media
} eq 'cdrom') ?
"cd" : "hd";
1918 $device = "ide-$devicetype";
1919 if ($drive->{interface
} eq 'ide') {
1920 $device .= ",bus=ide.$controller,unit=$unit";
1922 $device .= ",bus=ahci$controller.$unit";
1924 $device .= ",drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1926 if ($devicetype eq 'hd') {
1927 if (my $model = $drive->{model
}) {
1928 $model = URI
::Escape
::uri_unescape
($model);
1929 $device .= ",model=$model";
1931 if ($drive->{ssd
}) {
1932 $device .= ",rotation_rate=1";
1935 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1936 } elsif ($drive->{interface
} eq 'usb') {
1938 # -device ide-drive,bus=ide.1,unit=0,drive=drive-ide0-1-0,id=ide0-1-0
1940 die "unsupported interface type";
1943 $device .= ",bootindex=$drive->{bootindex}" if $drive->{bootindex
};
1945 if (my $serial = $drive->{serial
}) {
1946 $serial = URI
::Escape
::uri_unescape
($serial);
1947 $device .= ",serial=$serial";
1954 sub get_initiator_name
{
1957 my $fh = IO
::File-
>new('/etc/iscsi/initiatorname.iscsi') || return undef;
1958 while (defined(my $line = <$fh>)) {
1959 next if $line !~ m/^\s*InitiatorName\s*=\s*([\.\-:\w]+)/;
1968 sub print_drive_full
{
1969 my ($storecfg, $vmid, $drive) = @_;
1972 my $volid = $drive->{file
};
1975 if (drive_is_cdrom
($drive)) {
1976 $path = get_iso_path
($storecfg, $vmid, $volid);
1978 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
1980 $path = PVE
::Storage
::path
($storecfg, $volid);
1981 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
1982 $format = qemu_img_format
($scfg, $volname);
1990 my @qemu_drive_options = qw(heads secs cyls trans media format cache rerror werror aio discard);
1991 foreach my $o (@qemu_drive_options) {
1992 $opts .= ",$o=$drive->{$o}" if defined($drive->{$o});
1995 # snapshot only accepts on|off
1996 if (defined($drive->{snapshot
})) {
1997 my $v = $drive->{snapshot
} ?
'on' : 'off';
1998 $opts .= ",snapshot=$v";
2001 foreach my $type (['', '-total'], [_rd
=> '-read'], [_wr
=> '-write']) {
2002 my ($dir, $qmpname) = @$type;
2003 if (my $v = $drive->{"mbps$dir"}) {
2004 $opts .= ",throttling.bps$qmpname=".int($v*1024*1024);
2006 if (my $v = $drive->{"mbps${dir}_max"}) {
2007 $opts .= ",throttling.bps$qmpname-max=".int($v*1024*1024);
2009 if (my $v = $drive->{"bps${dir}_max_length"}) {
2010 $opts .= ",throttling.bps$qmpname-max-length=$v";
2012 if (my $v = $drive->{"iops${dir}"}) {
2013 $opts .= ",throttling.iops$qmpname=$v";
2015 if (my $v = $drive->{"iops${dir}_max"}) {
2016 $opts .= ",throttling.iops$qmpname-max=$v";
2018 if (my $v = $drive->{"iops${dir}_max_length"}) {
2019 $opts .= ",throttling.iops$qmpname-max-length=$v";
2023 $opts .= ",format=$format" if $format && !$drive->{format
};
2025 my $cache_direct = 0;
2027 if (my $cache = $drive->{cache
}) {
2028 $cache_direct = $cache =~ /^(?:off|none|directsync)$/;
2029 } elsif (!drive_is_cdrom
($drive)) {
2030 $opts .= ",cache=none";
2034 # aio native works only with O_DIRECT
2035 if (!$drive->{aio
}) {
2037 $opts .= ",aio=native";
2039 $opts .= ",aio=threads";
2043 if (!drive_is_cdrom
($drive)) {
2045 if (defined($drive->{detect_zeroes
}) && !$drive->{detect_zeroes
}) {
2046 $detectzeroes = 'off';
2047 } elsif ($drive->{discard
}) {
2048 $detectzeroes = $drive->{discard
} eq 'on' ?
'unmap' : 'on';
2050 # This used to be our default with discard not being specified:
2051 $detectzeroes = 'on';
2053 $opts .= ",detect-zeroes=$detectzeroes" if $detectzeroes;
2056 my $pathinfo = $path ?
"file=$path," : '';
2058 return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
2061 sub print_netdevice_full
{
2062 my ($vmid, $conf, $net, $netid, $bridges, $use_old_bios_files, $arch, $machine_type) = @_;
2064 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
2066 my $device = $net->{model
};
2067 if ($net->{model
} eq 'virtio') {
2068 $device = 'virtio-net-pci';
2071 my $pciaddr = print_pci_addr
("$netid", $bridges, $arch, $machine_type);
2072 my $tmpstr = "$device,mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
2073 if ($net->{queues
} && $net->{queues
} > 1 && $net->{model
} eq 'virtio'){
2074 #Consider we have N queues, the number of vectors needed is 2*N + 2 (plus one config interrupt and control vq)
2075 my $vectors = $net->{queues
} * 2 + 2;
2076 $tmpstr .= ",vectors=$vectors,mq=on";
2078 $tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex
} ;
2080 if ($use_old_bios_files) {
2082 if ($device eq 'virtio-net-pci') {
2083 $romfile = 'pxe-virtio.rom';
2084 } elsif ($device eq 'e1000') {
2085 $romfile = 'pxe-e1000.rom';
2086 } elsif ($device eq 'ne2k') {
2087 $romfile = 'pxe-ne2k_pci.rom';
2088 } elsif ($device eq 'pcnet') {
2089 $romfile = 'pxe-pcnet.rom';
2090 } elsif ($device eq 'rtl8139') {
2091 $romfile = 'pxe-rtl8139.rom';
2093 $tmpstr .= ",romfile=$romfile" if $romfile;
2099 sub print_netdev_full
{
2100 my ($vmid, $conf, $arch, $net, $netid, $hotplug) = @_;
2103 if ($netid =~ m/^net(\d+)$/) {
2107 die "got strange net id '$i'\n" if $i >= ${MAX_NETS
};
2109 my $ifname = "tap${vmid}i$i";
2111 # kvm uses TUNSETIFF ioctl, and that limits ifname length
2112 die "interface name '$ifname' is too long (max 15 character)\n"
2113 if length($ifname) >= 16;
2115 my $vhostparam = '';
2116 if (is_native
($arch)) {
2117 $vhostparam = ',vhost=on' if kernel_has_vhost_net
() && $net->{model
} eq 'virtio';
2120 my $vmname = $conf->{name
} || "vm$vmid";
2123 my $script = $hotplug ?
"pve-bridge-hotplug" : "pve-bridge";
2125 if ($net->{bridge
}) {
2126 $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/$script,downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
2128 $netdev = "type=user,id=$netid,hostname=$vmname";
2131 $netdev .= ",queues=$net->{queues}" if ($net->{queues
} && $net->{model
} eq 'virtio');
2137 sub print_cpu_device
{
2138 my ($conf, $id) = @_;
2140 my $kvm = $conf->{kvm
} // 1;
2141 my $cpu = $kvm ?
"kvm64" : "qemu64";
2142 if (my $cputype = $conf->{cpu
}) {
2143 my $cpuconf = PVE
::JSONSchema
::parse_property_string
($cpu_fmt, $cputype)
2144 or die "Cannot parse cpu description: $cputype\n";
2145 $cpu = $cpuconf->{cputype
};
2148 my $cores = $conf->{cores
} || 1;
2150 my $current_core = ($id - 1) % $cores;
2151 my $current_socket = int(($id - 1 - $current_core)/$cores);
2153 return "$cpu-x86_64-cpu,id=cpu$id,socket-id=$current_socket,core-id=$current_core,thread-id=0";
2157 'cirrus' => 'cirrus-vga',
2159 'vmware' => 'vmware-svga',
2160 'virtio' => 'virtio-vga',
2163 sub print_vga_device
{
2164 my ($conf, $vga, $arch, $machine, $id, $qxlnum, $bridges) = @_;
2166 my $type = $vga_map->{$vga->{type
}};
2167 if ($arch eq 'aarch64' && defined($type) && $type eq 'virtio-vga') {
2168 $type = 'virtio-gpu';
2170 my $vgamem_mb = $vga->{memory
};
2172 $type = $id ?
'qxl' : 'qxl-vga';
2174 die "no devicetype for $vga->{type}\n" if !$type;
2178 if ($vga->{type
} eq 'virtio') {
2179 my $bytes = PVE
::Tools
::convert_size
($vgamem_mb, "mb" => "b");
2180 $memory = ",max_hostmem=$bytes";
2182 # from https://www.spice-space.org/multiple-monitors.html
2183 $memory = ",vgamem_mb=$vga->{memory}";
2184 my $ram = $vgamem_mb * 4;
2185 my $vram = $vgamem_mb * 2;
2186 $memory .= ",ram_size_mb=$ram,vram_size_mb=$vram";
2188 $memory = ",vgamem_mb=$vga->{memory}";
2190 } elsif ($qxlnum && $id) {
2191 $memory = ",ram_size=67108864,vram_size=33554432";
2194 my $q35 = machine_type_is_q35
($conf);
2195 my $vgaid = "vga" . ($id // '');
2198 if ($q35 && $vgaid eq 'vga') {
2199 # the first display uses pcie.0 bus on q35 machines
2200 $pciaddr = print_pcie_addr
($vgaid, $bridges, $arch, $machine);
2202 $pciaddr = print_pci_addr
($vgaid, $bridges, $arch, $machine);
2205 return "$type,id=${vgaid}${memory}${pciaddr}";
2208 sub drive_is_cloudinit
{
2210 return $drive->{file
} =~ m
@[:/]vm-\d
+-cloudinit
(?
:\
.$QEMU_FORMAT_RE)?
$@;
2213 sub drive_is_cdrom
{
2214 my ($drive, $exclude_cloudinit) = @_;
2216 return 0 if $exclude_cloudinit && drive_is_cloudinit
($drive);
2218 return $drive && $drive->{media
} && ($drive->{media
} eq 'cdrom');
2222 sub parse_number_sets
{
2225 foreach my $part (split(/;/, $set)) {
2226 if ($part =~ /^\s*(\d+)(?:-(\d+))?\s*$/) {
2227 die "invalid range: $part ($2 < $1)\n" if defined($2) && $2 < $1;
2228 push @$res, [ $1, $2 ];
2230 die "invalid range: $part\n";
2239 my $res = PVE
::JSONSchema
::parse_property_string
($numa_fmt, $data);
2240 $res->{cpus
} = parse_number_sets
($res->{cpus
}) if defined($res->{cpus
});
2241 $res->{hostnodes
} = parse_number_sets
($res->{hostnodes
}) if defined($res->{hostnodes
});
2248 return undef if !$value;
2250 my $res = PVE
::JSONSchema
::parse_property_string
($hostpci_fmt, $value);
2252 my @idlist = split(/;/, $res->{host
});
2253 delete $res->{host
};
2254 foreach my $id (@idlist) {
2255 if ($id =~ m/\./) { # full id 00:00.1
2256 push @{$res->{pciid
}}, {
2259 } else { # partial id 00:00
2260 $res->{pciid
} = PVE
::SysFSTools
::lspci
($id);
2266 # netX: e1000=XX:XX:XX:XX:XX:XX,bridge=vmbr0,rate=<mbps>
2270 my $res = eval { PVE
::JSONSchema
::parse_property_string
($net_fmt, $data) };
2275 if (!defined($res->{macaddr
})) {
2276 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
2277 $res->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
});
2282 # ipconfigX ip=cidr,gw=ip,ip6=cidr,gw6=ip
2283 sub parse_ipconfig
{
2286 my $res = eval { PVE
::JSONSchema
::parse_property_string
($ipconfig_fmt, $data) };
2292 if ($res->{gw
} && !$res->{ip
}) {
2293 warn 'gateway specified without specifying an IP address';
2296 if ($res->{gw6
} && !$res->{ip6
}) {
2297 warn 'IPv6 gateway specified without specifying an IPv6 address';
2300 if ($res->{gw
} && $res->{ip
} eq 'dhcp') {
2301 warn 'gateway specified together with DHCP';
2304 if ($res->{gw6
} && $res->{ip6
} !~ /^$IPV6RE/) {
2306 warn "IPv6 gateway specified together with $res->{ip6} address";
2310 if (!$res->{ip
} && !$res->{ip6
}) {
2311 return { ip
=> 'dhcp', ip6
=> 'dhcp' };
2320 return PVE
::JSONSchema
::print_property_string
($net, $net_fmt);
2323 sub add_random_macs
{
2324 my ($settings) = @_;
2326 foreach my $opt (keys %$settings) {
2327 next if $opt !~ m/^net(\d+)$/;
2328 my $net = parse_net
($settings->{$opt});
2330 $settings->{$opt} = print_net
($net);
2334 sub vm_is_volid_owner
{
2335 my ($storecfg, $vmid, $volid) = @_;
2337 if ($volid !~ m
|^/|) {
2339 eval { ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid); };
2340 if ($owner && ($owner == $vmid)) {
2348 sub split_flagged_list
{
2349 my $text = shift || '';
2350 $text =~ s/[,;]/ /g;
2352 return { map { /^(!?)(.*)$/ && ($2, $1) } ($text =~ /\S+/g) };
2355 sub join_flagged_list
{
2356 my ($how, $lst) = @_;
2357 join $how, map { $lst->{$_} . $_ } keys %$lst;
2360 sub vmconfig_delete_pending_option
{
2361 my ($conf, $key, $force) = @_;
2363 delete $conf->{pending
}->{$key};
2364 my $pending_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
2365 $pending_delete_hash->{$key} = $force ?
'!' : '';
2366 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
2369 sub vmconfig_undelete_pending_option
{
2370 my ($conf, $key) = @_;
2372 my $pending_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
2373 delete $pending_delete_hash->{$key};
2375 if (%$pending_delete_hash) {
2376 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
2378 delete $conf->{pending
}->{delete};
2382 sub vmconfig_register_unused_drive
{
2383 my ($storecfg, $vmid, $conf, $drive) = @_;
2385 if (drive_is_cloudinit
($drive)) {
2386 eval { PVE
::Storage
::vdisk_free
($storecfg, $drive->{file
}) };
2388 } elsif (!drive_is_cdrom
($drive)) {
2389 my $volid = $drive->{file
};
2390 if (vm_is_volid_owner
($storecfg, $vmid, $volid)) {
2391 PVE
::QemuConfig-
>add_unused_volume($conf, $volid, $vmid);
2396 sub vmconfig_cleanup_pending
{
2399 # remove pending changes when nothing changed
2401 foreach my $opt (keys %{$conf->{pending
}}) {
2402 if (defined($conf->{$opt}) && ($conf->{pending
}->{$opt} eq $conf->{$opt})) {
2404 delete $conf->{pending
}->{$opt};
2408 my $current_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
2409 my $pending_delete_hash = {};
2410 while (my ($opt, $force) = each %$current_delete_hash) {
2411 if (defined($conf->{$opt})) {
2412 $pending_delete_hash->{$opt} = $force;
2418 if (%$pending_delete_hash) {
2419 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
2421 delete $conf->{pending
}->{delete};
2427 # smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str][,base64=bool]
2431 pattern
=> '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
2432 format_description
=> 'UUID',
2433 description
=> "Set SMBIOS1 UUID.",
2438 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2439 format_description
=> 'Base64 encoded string',
2440 description
=> "Set SMBIOS1 version.",
2445 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2446 format_description
=> 'Base64 encoded string',
2447 description
=> "Set SMBIOS1 serial number.",
2452 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2453 format_description
=> 'Base64 encoded string',
2454 description
=> "Set SMBIOS1 manufacturer.",
2459 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2460 format_description
=> 'Base64 encoded string',
2461 description
=> "Set SMBIOS1 product ID.",
2466 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2467 format_description
=> 'Base64 encoded string',
2468 description
=> "Set SMBIOS1 SKU string.",
2473 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
2474 format_description
=> 'Base64 encoded string',
2475 description
=> "Set SMBIOS1 family string.",
2480 description
=> 'Flag to indicate that the SMBIOS values are base64 encoded',
2488 my $res = eval { PVE
::JSONSchema
::parse_property_string
($smbios1_fmt, $data) };
2495 return PVE
::JSONSchema
::print_property_string
($smbios1, $smbios1_fmt);
2498 PVE
::JSONSchema
::register_format
('pve-qm-smbios1', $smbios1_fmt);
2500 PVE
::JSONSchema
::register_format
('pve-qm-bootdisk', \
&verify_bootdisk
);
2501 sub verify_bootdisk
{
2502 my ($value, $noerr) = @_;
2504 return $value if is_valid_drivename
($value);
2506 return undef if $noerr;
2508 die "invalid boot disk '$value'\n";
2511 sub parse_watchdog
{
2514 return undef if !$value;
2516 my $res = eval { PVE
::JSONSchema
::parse_property_string
($watchdog_fmt, $value) };
2521 sub parse_guest_agent
{
2524 return {} if !defined($value->{agent
});
2526 my $res = eval { PVE
::JSONSchema
::parse_property_string
($agent_fmt, $value->{agent
}) };
2529 # if the agent is disabled ignore the other potentially set properties
2530 return {} if !$res->{enabled
};
2537 return {} if !$value;
2538 my $res = eval { PVE
::JSONSchema
::parse_property_string
($vga_fmt, $value) };
2543 PVE
::JSONSchema
::register_format
('pve-qm-usb-device', \
&verify_usb_device
);
2544 sub verify_usb_device
{
2545 my ($value, $noerr) = @_;
2547 return $value if parse_usb_device
($value);
2549 return undef if $noerr;
2551 die "unable to parse usb device\n";
2554 # add JSON properties for create and set function
2555 sub json_config_properties
{
2558 foreach my $opt (keys %$confdesc) {
2559 next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate' || $opt eq 'runningmachine';
2560 $prop->{$opt} = $confdesc->{$opt};
2566 # return copy of $confdesc_cloudinit to generate documentation
2567 sub cloudinit_config_properties
{
2569 return dclone
($confdesc_cloudinit);
2573 my ($key, $value) = @_;
2575 die "unknown setting '$key'\n" if !$confdesc->{$key};
2577 my $type = $confdesc->{$key}->{type
};
2579 if (!defined($value)) {
2580 die "got undefined value\n";
2583 if ($value =~ m/[\n\r]/) {
2584 die "property contains a line feed\n";
2587 if ($type eq 'boolean') {
2588 return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
2589 return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
2590 die "type check ('boolean') failed - got '$value'\n";
2591 } elsif ($type eq 'integer') {
2592 return int($1) if $value =~ m/^(\d+)$/;
2593 die "type check ('integer') failed - got '$value'\n";
2594 } elsif ($type eq 'number') {
2595 return $value if $value =~ m/^(\d+)(\.\d+)?$/;
2596 die "type check ('number') failed - got '$value'\n";
2597 } elsif ($type eq 'string') {
2598 if (my $fmt = $confdesc->{$key}->{format
}) {
2599 PVE
::JSONSchema
::check_format
($fmt, $value);
2602 $value =~ s/^\"(.*)\"$/$1/;
2605 die "internal error"
2612 my $conf = PVE
::QemuConfig-
>config_file($vmid);
2613 utime undef, undef, $conf;
2617 my ($storecfg, $vmid, $keep_empty_config, $skiplock) = @_;
2619 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
2621 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2623 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
2625 if ($conf->{template
}) {
2626 # check if any base image is still used by a linked clone
2627 foreach_drive
($conf, sub {
2628 my ($ds, $drive) = @_;
2630 return if drive_is_cdrom
($drive);
2632 my $volid = $drive->{file
};
2634 return if !$volid || $volid =~ m
|^/|;
2636 die "base volume '$volid' is still in use by linked cloned\n"
2637 if PVE
::Storage
::volume_is_base_and_used
($storecfg, $volid);
2642 # only remove disks owned by this VM
2643 foreach_drive
($conf, sub {
2644 my ($ds, $drive) = @_;
2646 return if drive_is_cdrom
($drive, 1);
2648 my $volid = $drive->{file
};
2650 return if !$volid || $volid =~ m
|^/|;
2652 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
2653 return if !$path || !$owner || ($owner != $vmid);
2656 PVE
::Storage
::vdisk_free
($storecfg, $volid);
2658 warn "Could not remove disk '$volid', check manually: $@" if $@;
2662 if ($keep_empty_config) {
2663 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
2668 # also remove unused disk
2670 my $dl = PVE
::Storage
::vdisk_list
($storecfg, undef, $vmid);
2673 PVE
::Storage
::foreach_volid
($dl, sub {
2674 my ($volid, $sid, $volname, $d) = @_;
2675 PVE
::Storage
::vdisk_free
($storecfg, $volid);
2684 sub parse_vm_config
{
2685 my ($filename, $raw) = @_;
2687 return undef if !defined($raw);
2690 digest
=> Digest
::SHA
::sha1_hex
($raw),
2695 $filename =~ m
|/qemu-server/(\d
+)\
.conf
$|
2696 || die "got strange filename '$filename'";
2704 my @lines = split(/\n/, $raw);
2705 foreach my $line (@lines) {
2706 next if $line =~ m/^\s*$/;
2708 if ($line =~ m/^\[PENDING\]\s*$/i) {
2709 $section = 'pending';
2710 if (defined($descr)) {
2712 $conf->{description
} = $descr;
2715 $conf = $res->{$section} = {};
2718 } elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
2720 if (defined($descr)) {
2722 $conf->{description
} = $descr;
2725 $conf = $res->{snapshots
}->{$section} = {};
2729 if ($line =~ m/^\#(.*)\s*$/) {
2730 $descr = '' if !defined($descr);
2731 $descr .= PVE
::Tools
::decode_text
($1) . "\n";
2735 if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
2736 $descr = '' if !defined($descr);
2737 $descr .= PVE
::Tools
::decode_text
($2);
2738 } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
2739 $conf->{snapstate
} = $1;
2740 } elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
2743 $conf->{$key} = $value;
2744 } elsif ($line =~ m/^delete:\s*(.*\S)\s*$/) {
2746 if ($section eq 'pending') {
2747 $conf->{delete} = $value; # we parse this later
2749 warn "vm $vmid - propertry 'delete' is only allowed in [PENDING]\n";
2751 } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(.+?)\s*$/) {
2754 eval { $value = check_type
($key, $value); };
2756 warn "vm $vmid - unable to parse value of '$key' - $@";
2758 $key = 'ide2' if $key eq 'cdrom';
2759 my $fmt = $confdesc->{$key}->{format
};
2760 if ($fmt && $fmt =~ /^pve-qm-(?:ide|scsi|virtio|sata)$/) {
2761 my $v = parse_drive
($key, $value);
2762 if (my $volid = filename_to_volume_id
($vmid, $v->{file
}, $v->{media
})) {
2763 $v->{file
} = $volid;
2764 $value = print_drive
($vmid, $v);
2766 warn "vm $vmid - unable to parse value of '$key'\n";
2771 $conf->{$key} = $value;
2776 if (defined($descr)) {
2778 $conf->{description
} = $descr;
2780 delete $res->{snapstate
}; # just to be sure
2785 sub write_vm_config
{
2786 my ($filename, $conf) = @_;
2788 delete $conf->{snapstate
}; # just to be sure
2790 if ($conf->{cdrom
}) {
2791 die "option ide2 conflicts with cdrom\n" if $conf->{ide2
};
2792 $conf->{ide2
} = $conf->{cdrom
};
2793 delete $conf->{cdrom
};
2796 # we do not use 'smp' any longer
2797 if ($conf->{sockets
}) {
2798 delete $conf->{smp
};
2799 } elsif ($conf->{smp
}) {
2800 $conf->{sockets
} = $conf->{smp
};
2801 delete $conf->{cores
};
2802 delete $conf->{smp
};
2805 my $used_volids = {};
2807 my $cleanup_config = sub {
2808 my ($cref, $pending, $snapname) = @_;
2810 foreach my $key (keys %$cref) {
2811 next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots' ||
2812 $key eq 'snapstate' || $key eq 'pending';
2813 my $value = $cref->{$key};
2814 if ($key eq 'delete') {
2815 die "propertry 'delete' is only allowed in [PENDING]\n"
2817 # fixme: check syntax?
2820 eval { $value = check_type
($key, $value); };
2821 die "unable to parse value of '$key' - $@" if $@;
2823 $cref->{$key} = $value;
2825 if (!$snapname && is_valid_drivename
($key)) {
2826 my $drive = parse_drive
($key, $value);
2827 $used_volids->{$drive->{file
}} = 1 if $drive && $drive->{file
};
2832 &$cleanup_config($conf);
2834 &$cleanup_config($conf->{pending
}, 1);
2836 foreach my $snapname (keys %{$conf->{snapshots
}}) {
2837 die "internal error" if $snapname eq 'pending';
2838 &$cleanup_config($conf->{snapshots
}->{$snapname}, undef, $snapname);
2841 # remove 'unusedX' settings if we re-add a volume
2842 foreach my $key (keys %$conf) {
2843 my $value = $conf->{$key};
2844 if ($key =~ m/^unused/ && $used_volids->{$value}) {
2845 delete $conf->{$key};
2849 my $generate_raw_config = sub {
2850 my ($conf, $pending) = @_;
2854 # add description as comment to top of file
2855 if (defined(my $descr = $conf->{description
})) {
2857 foreach my $cl (split(/\n/, $descr)) {
2858 $raw .= '#' . PVE
::Tools
::encode_text
($cl) . "\n";
2861 $raw .= "#\n" if $pending;
2865 foreach my $key (sort keys %$conf) {
2866 next if $key eq 'digest' || $key eq 'description' || $key eq 'pending' || $key eq 'snapshots';
2867 $raw .= "$key: $conf->{$key}\n";
2872 my $raw = &$generate_raw_config($conf);
2874 if (scalar(keys %{$conf->{pending
}})){
2875 $raw .= "\n[PENDING]\n";
2876 $raw .= &$generate_raw_config($conf->{pending
}, 1);
2879 foreach my $snapname (sort keys %{$conf->{snapshots
}}) {
2880 $raw .= "\n[$snapname]\n";
2881 $raw .= &$generate_raw_config($conf->{snapshots
}->{$snapname});
2891 # we use static defaults from our JSON schema configuration
2892 foreach my $key (keys %$confdesc) {
2893 if (defined(my $default = $confdesc->{$key}->{default})) {
2894 $res->{$key} = $default;
2902 my $vmlist = PVE
::Cluster
::get_vmlist
();
2904 return $res if !$vmlist || !$vmlist->{ids
};
2905 my $ids = $vmlist->{ids
};
2907 foreach my $vmid (keys %$ids) {
2908 my $d = $ids->{$vmid};
2909 next if !$d->{node
} || $d->{node
} ne $nodename;
2910 next if !$d->{type
} || $d->{type
} ne 'qemu';
2911 $res->{$vmid}->{exists} = 1;
2916 # test if VM uses local resources (to prevent migration)
2917 sub check_local_resources
{
2918 my ($conf, $noerr) = @_;
2922 push @loc_res, "hostusb" if $conf->{hostusb
}; # old syntax
2923 push @loc_res, "hostpci" if $conf->{hostpci
}; # old syntax
2925 push @loc_res, "ivshmem" if $conf->{ivshmem
};
2927 foreach my $k (keys %$conf) {
2928 next if $k =~ m/^usb/ && ($conf->{$k} eq 'spice');
2929 # sockets are safe: they will recreated be on the target side post-migrate
2930 next if $k =~ m/^serial/ && ($conf->{$k} eq 'socket');
2931 push @loc_res, $k if $k =~ m/^(usb|hostpci|serial|parallel)\d+$/;
2934 die "VM uses local resources\n" if scalar @loc_res && !$noerr;
2939 # check if used storages are available on all nodes (use by migrate)
2940 sub check_storage_availability
{
2941 my ($storecfg, $conf, $node) = @_;
2943 foreach_drive
($conf, sub {
2944 my ($ds, $drive) = @_;
2946 my $volid = $drive->{file
};
2949 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2952 # check if storage is available on both nodes
2953 my $scfg = PVE
::Storage
::storage_check_node
($storecfg, $sid);
2954 PVE
::Storage
::storage_check_node
($storecfg, $sid, $node);
2958 # list nodes where all VM images are available (used by has_feature API)
2960 my ($conf, $storecfg) = @_;
2962 my $nodelist = PVE
::Cluster
::get_nodelist
();
2963 my $nodehash = { map { $_ => 1 } @$nodelist };
2964 my $nodename = PVE
::INotify
::nodename
();
2966 foreach_drive
($conf, sub {
2967 my ($ds, $drive) = @_;
2969 my $volid = $drive->{file
};
2972 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2974 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2975 if ($scfg->{disable
}) {
2977 } elsif (my $avail = $scfg->{nodes
}) {
2978 foreach my $node (keys %$nodehash) {
2979 delete $nodehash->{$node} if !$avail->{$node};
2981 } elsif (!$scfg->{shared
}) {
2982 foreach my $node (keys %$nodehash) {
2983 delete $nodehash->{$node} if $node ne $nodename
2992 sub check_local_storage_availability
{
2993 my ($conf, $storecfg) = @_;
2995 my $nodelist = PVE
::Cluster
::get_nodelist
();
2996 my $nodehash = { map { $_ => {} } @$nodelist };
2998 foreach_drive
($conf, sub {
2999 my ($ds, $drive) = @_;
3001 my $volid = $drive->{file
};
3004 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
3006 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
3008 if ($scfg->{disable
}) {
3009 foreach my $node (keys %$nodehash) {
3010 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
3012 } elsif (my $avail = $scfg->{nodes
}) {
3013 foreach my $node (keys %$nodehash) {
3014 if (!$avail->{$node}) {
3015 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
3022 foreach my $node (values %$nodehash) {
3023 if (my $unavail = $node->{unavailable_storages
}) {
3024 $node->{unavailable_storages
} = [ sort keys %$unavail ];
3032 my ($pidfile, $pid) = @_;
3034 my $fh = IO
::File-
>new("/proc/$pid/cmdline", "r");
3038 return undef if !$line;
3039 my @param = split(/\0/, $line);
3041 my $cmd = $param[0];
3042 return if !$cmd || ($cmd !~ m
|kvm
$| && $cmd !~ m
@(?
:^|/)qemu-system-[^/]+$@);
3044 for (my $i = 0; $i < scalar (@param); $i++) {
3047 if (($p eq '-pidfile') || ($p eq '--pidfile')) {
3048 my $p = $param[$i+1];
3049 return 1 if $p && ($p eq $pidfile);
3058 my ($vmid, $nocheck, $node) = @_;
3060 my $filename = PVE
::QemuConfig-
>config_file($vmid, $node);
3062 die "unable to find configuration file for VM $vmid - no such machine\n"
3063 if !$nocheck && ! -f
$filename;
3065 my $pidfile = pidfile_name
($vmid);
3067 if (my $fd = IO
::File-
>new("<$pidfile")) {
3072 my $mtime = $st->mtime;
3073 if ($mtime > time()) {
3074 warn "file '$filename' modified in future\n";
3077 if ($line =~ m/^(\d+)$/) {
3079 if (check_cmdline
($pidfile, $pid)) {
3080 if (my $pinfo = PVE
::ProcFSTools
::check_process_running
($pid)) {
3092 my $vzlist = config_list
();
3094 my $fd = IO
::Dir-
>new($var_run_tmpdir) || return $vzlist;
3096 while (defined(my $de = $fd->read)) {
3097 next if $de !~ m/^(\d+)\.pid$/;
3099 next if !defined($vzlist->{$vmid});
3100 if (my $pid = check_running
($vmid)) {
3101 $vzlist->{$vmid}->{pid
} = $pid;
3109 my ($storecfg, $conf) = @_;
3111 my $bootdisk = $conf->{bootdisk
};
3112 return undef if !$bootdisk;
3113 return undef if !is_valid_drivename
($bootdisk);
3115 return undef if !$conf->{$bootdisk};
3117 my $drive = parse_drive
($bootdisk, $conf->{$bootdisk});
3118 return undef if !defined($drive);
3120 return undef if drive_is_cdrom
($drive);
3122 my $volid = $drive->{file
};
3123 return undef if !$volid;
3125 return $drive->{size
};
3128 our $vmstatus_return_properties = {
3129 vmid
=> get_standard_option
('pve-vmid'),
3131 description
=> "Qemu process status.",
3133 enum
=> ['stopped', 'running'],
3136 description
=> "Maximum memory in bytes.",
3139 renderer
=> 'bytes',
3142 description
=> "Root disk size in bytes.",
3145 renderer
=> 'bytes',
3148 description
=> "VM name.",
3153 description
=> "Qemu QMP agent status.",
3158 description
=> "PID of running qemu process.",
3163 description
=> "Uptime.",
3166 renderer
=> 'duration',
3169 description
=> "Maximum usable CPUs.",
3174 description
=> "The current config lock, if any.",
3180 my $last_proc_pid_stat;
3182 # get VM status information
3183 # This must be fast and should not block ($full == false)
3184 # We only query KVM using QMP if $full == true (this can be slow)
3186 my ($opt_vmid, $full) = @_;
3190 my $storecfg = PVE
::Storage
::config
();
3192 my $list = vzlist
();
3193 my $defaults = load_defaults
();
3195 my ($uptime) = PVE
::ProcFSTools
::read_proc_uptime
(1);
3197 my $cpucount = $cpuinfo->{cpus
} || 1;
3199 foreach my $vmid (keys %$list) {
3200 next if $opt_vmid && ($vmid ne $opt_vmid);
3202 my $cfspath = PVE
::QemuConfig-
>cfs_config_path($vmid);
3203 my $conf = PVE
::Cluster
::cfs_read_file
($cfspath) || {};
3205 my $d = { vmid
=> $vmid };
3206 $d->{pid
} = $list->{$vmid}->{pid
};
3208 # fixme: better status?
3209 $d->{status
} = $list->{$vmid}->{pid
} ?
'running' : 'stopped';
3211 my $size = disksize
($storecfg, $conf);
3212 if (defined($size)) {
3213 $d->{disk
} = 0; # no info available
3214 $d->{maxdisk
} = $size;
3220 $d->{cpus
} = ($conf->{sockets
} || $defaults->{sockets
})
3221 * ($conf->{cores
} || $defaults->{cores
});
3222 $d->{cpus
} = $cpucount if $d->{cpus
} > $cpucount;
3223 $d->{cpus
} = $conf->{vcpus
} if $conf->{vcpus
};
3225 $d->{name
} = $conf->{name
} || "VM $vmid";
3226 $d->{maxmem
} = $conf->{memory
} ?
$conf->{memory
}*(1024*1024)
3227 : $defaults->{memory
}*(1024*1024);
3229 if ($conf->{balloon
}) {
3230 $d->{balloon_min
} = $conf->{balloon
}*(1024*1024);
3231 $d->{shares
} = defined($conf->{shares
}) ?
$conf->{shares
}
3232 : $defaults->{shares
};
3243 $d->{diskwrite
} = 0;
3245 $d->{template
} = PVE
::QemuConfig-
>is_template($conf);
3247 $d->{serial
} = 1 if conf_has_serial
($conf);
3248 $d->{lock} = $conf->{lock} if $conf->{lock};
3253 my $netdev = PVE
::ProcFSTools
::read_proc_net_dev
();
3254 foreach my $dev (keys %$netdev) {
3255 next if $dev !~ m/^tap([1-9]\d*)i/;
3257 my $d = $res->{$vmid};
3260 $d->{netout
} += $netdev->{$dev}->{receive
};
3261 $d->{netin
} += $netdev->{$dev}->{transmit
};
3264 $d->{nics
}->{$dev}->{netout
} = $netdev->{$dev}->{receive
};
3265 $d->{nics
}->{$dev}->{netin
} = $netdev->{$dev}->{transmit
};
3270 my $ctime = gettimeofday
;
3272 foreach my $vmid (keys %$list) {
3274 my $d = $res->{$vmid};
3275 my $pid = $d->{pid
};
3278 my $pstat = PVE
::ProcFSTools
::read_proc_pid_stat
($pid);
3279 next if !$pstat; # not running
3281 my $used = $pstat->{utime} + $pstat->{stime
};
3283 $d->{uptime
} = int(($uptime - $pstat->{starttime
})/$cpuinfo->{user_hz
});
3285 if ($pstat->{vsize
}) {
3286 $d->{mem
} = int(($pstat->{rss
}/$pstat->{vsize
})*$d->{maxmem
});
3289 my $old = $last_proc_pid_stat->{$pid};
3291 $last_proc_pid_stat->{$pid} = {
3299 my $dtime = ($ctime - $old->{time}) * $cpucount * $cpuinfo->{user_hz
};
3301 if ($dtime > 1000) {
3302 my $dutime = $used - $old->{used
};
3304 $d->{cpu
} = (($dutime/$dtime)* $cpucount) / $d->{cpus
};
3305 $last_proc_pid_stat->{$pid} = {
3311 $d->{cpu
} = $old->{cpu
};
3315 return $res if !$full;
3317 my $qmpclient = PVE
::QMPClient-
>new();
3319 my $ballooncb = sub {
3320 my ($vmid, $resp) = @_;
3322 my $info = $resp->{'return'};
3323 return if !$info->{max_mem
};
3325 my $d = $res->{$vmid};
3327 # use memory assigned to VM
3328 $d->{maxmem
} = $info->{max_mem
};
3329 $d->{balloon
} = $info->{actual
};
3331 if (defined($info->{total_mem
}) && defined($info->{free_mem
})) {
3332 $d->{mem
} = $info->{total_mem
} - $info->{free_mem
};
3333 $d->{freemem
} = $info->{free_mem
};
3336 $d->{ballooninfo
} = $info;
3339 my $blockstatscb = sub {
3340 my ($vmid, $resp) = @_;
3341 my $data = $resp->{'return'} || [];
3342 my $totalrdbytes = 0;
3343 my $totalwrbytes = 0;
3345 for my $blockstat (@$data) {
3346 $totalrdbytes = $totalrdbytes + $blockstat->{stats
}->{rd_bytes
};
3347 $totalwrbytes = $totalwrbytes + $blockstat->{stats
}->{wr_bytes
};
3349 $blockstat->{device
} =~ s/drive-//;
3350 $res->{$vmid}->{blockstat
}->{$blockstat->{device
}} = $blockstat->{stats
};
3352 $res->{$vmid}->{diskread
} = $totalrdbytes;
3353 $res->{$vmid}->{diskwrite
} = $totalwrbytes;
3356 my $statuscb = sub {
3357 my ($vmid, $resp) = @_;
3359 $qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
3360 # this fails if ballon driver is not loaded, so this must be
3361 # the last commnand (following command are aborted if this fails).
3362 $qmpclient->queue_cmd($vmid, $ballooncb, 'query-balloon');
3364 my $status = 'unknown';
3365 if (!defined($status = $resp->{'return'}->{status
})) {
3366 warn "unable to get VM status\n";
3370 $res->{$vmid}->{qmpstatus
} = $resp->{'return'}->{status
};
3373 foreach my $vmid (keys %$list) {
3374 next if $opt_vmid && ($vmid ne $opt_vmid);
3375 next if !$res->{$vmid}->{pid
}; # not running
3376 $qmpclient->queue_cmd($vmid, $statuscb, 'query-status');
3379 $qmpclient->queue_execute(undef, 2);
3381 foreach my $vmid (keys %$list) {
3382 next if $opt_vmid && ($vmid ne $opt_vmid);
3383 $res->{$vmid}->{qmpstatus
} = $res->{$vmid}->{status
} if !$res->{$vmid}->{qmpstatus
};
3390 my ($conf, $func, @param) = @_;
3392 foreach my $ds (valid_drive_names
()) {
3393 next if !defined($conf->{$ds});
3395 my $drive = parse_drive
($ds, $conf->{$ds});
3398 &$func($ds, $drive, @param);
3403 my ($conf, $func, @param) = @_;
3407 my $test_volid = sub {
3408 my ($volid, $is_cdrom, $replicate, $shared, $snapname, $size) = @_;
3412 $volhash->{$volid}->{cdrom
} //= 1;
3413 $volhash->{$volid}->{cdrom
} = 0 if !$is_cdrom;
3415 $volhash->{$volid}->{replicate
} //= 0;
3416 $volhash->{$volid}->{replicate
} = 1 if $replicate;
3418 $volhash->{$volid}->{shared
} //= 0;
3419 $volhash->{$volid}->{shared
} = 1 if $shared;
3421 $volhash->{$volid}->{referenced_in_config
} //= 0;
3422 $volhash->{$volid}->{referenced_in_config
} = 1 if !defined($snapname);
3424 $volhash->{$volid}->{referenced_in_snapshot
}->{$snapname} = 1
3425 if defined($snapname);
3426 $volhash->{$volid}->{size
} = $size if $size;
3429 foreach_drive
($conf, sub {
3430 my ($ds, $drive) = @_;
3431 $test_volid->($drive->{file
}, drive_is_cdrom
($drive), $drive->{replicate
} // 1, $drive->{shared
}, undef, $drive->{size
});
3434 foreach my $snapname (keys %{$conf->{snapshots
}}) {
3435 my $snap = $conf->{snapshots
}->{$snapname};
3436 $test_volid->($snap->{vmstate
}, 0, 1, $snapname);
3437 foreach_drive
($snap, sub {
3438 my ($ds, $drive) = @_;
3439 $test_volid->($drive->{file
}, drive_is_cdrom
($drive), $drive->{replicate
} // 1, $drive->{shared
}, $snapname);
3443 foreach my $volid (keys %$volhash) {
3444 &$func($volid, $volhash->{$volid}, @param);
3448 sub conf_has_serial
{
3451 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
3452 if ($conf->{"serial$i"}) {
3460 sub conf_has_audio
{
3461 my ($conf, $id) = @_;
3464 my $audio = $conf->{"audio$id"};
3465 return undef if !defined($audio);
3467 my $audioproperties = PVE
::JSONSchema
::parse_property_string
($audio_fmt, $audio);
3468 my $audiodriver = $audioproperties->{driver
} // 'spice';
3471 dev
=> $audioproperties->{device
},
3472 dev_id
=> "audiodev$id",
3473 backend
=> $audiodriver,
3474 backend_id
=> "$audiodriver-backend${id}",
3478 sub vga_conf_has_spice
{
3481 my $vgaconf = parse_vga
($vga);
3482 my $vgatype = $vgaconf->{type
};
3483 return 0 if !$vgatype || $vgatype !~ m/^qxl([234])?$/;
3488 my $host_arch; # FIXME: fix PVE::Tools::get_host_arch
3489 sub get_host_arch
() {
3490 $host_arch = (POSIX
::uname
())[4] if !$host_arch;
3496 return get_host_arch
() eq $arch;
3499 my $default_machines = {
3504 sub get_basic_machine_info
{
3505 my ($conf, $forcemachine) = @_;
3507 my $arch = $conf->{arch
} // get_host_arch
();
3508 my $machine = $forcemachine || $conf->{machine
} || $default_machines->{$arch};
3509 return ($arch, $machine);
3512 sub get_ovmf_files
($) {
3515 my $ovmf = $OVMF->{$arch}
3516 or die "no OVMF images known for architecture '$arch'\n";
3522 aarch64
=> '/usr/bin/qemu-system-aarch64',
3523 x86_64
=> '/usr/bin/qemu-system-x86_64',
3525 sub get_command_for_arch
($) {
3527 return '/usr/bin/kvm' if is_native
($arch);
3529 my $cmd = $Arch2Qemu->{$arch}
3530 or die "don't know how to emulate architecture '$arch'\n";
3534 sub get_cpu_options
{
3535 my ($conf, $arch, $kvm, $machine_type, $kvm_off, $kvmver, $winversion, $gpu_passthrough) = @_;
3538 my $ostype = $conf->{ostype
};
3540 my $cpu = $kvm ?
"kvm64" : "qemu64";
3541 if ($arch eq 'aarch64') {
3542 $cpu = 'cortex-a57';
3545 if (my $cputype = $conf->{cpu
}) {
3546 my $cpuconf = PVE
::JSONSchema
::parse_property_string
($cpu_fmt, $cputype)
3547 or die "Cannot parse cpu description: $cputype\n";
3548 $cpu = $cpuconf->{cputype
};
3549 $kvm_off = 1 if $cpuconf->{hidden
};
3550 $hv_vendor_id = $cpuconf->{'hv-vendor-id'};
3552 if (defined(my $flags = $cpuconf->{flags
})) {
3553 push @$cpuFlags, split(";", $flags);
3557 push @$cpuFlags , '+lahf_lm' if $cpu eq 'kvm64' && $arch eq 'x86_64';
3559 push @$cpuFlags , '-x2apic'
3560 if $conf->{ostype
} && $conf->{ostype
} eq 'solaris';
3562 push @$cpuFlags, '+sep' if $cpu eq 'kvm64' || $cpu eq 'kvm32';
3564 push @$cpuFlags, '-rdtscp' if $cpu =~ m/^Opteron/;
3566 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3) && $arch eq 'x86_64') {
3568 push @$cpuFlags , '+kvm_pv_unhalt' if $kvm;
3569 push @$cpuFlags , '+kvm_pv_eoi' if $kvm;
3572 add_hyperv_enlightenments
($cpuFlags, $winversion, $machine_type, $kvmver, $conf->{bios
}, $gpu_passthrough, $hv_vendor_id) if $kvm;
3574 push @$cpuFlags, 'enforce' if $cpu ne 'host' && $kvm && $arch eq 'x86_64';
3576 push @$cpuFlags, 'kvm=off' if $kvm_off;
3578 if (my $cpu_vendor = $cpu_vendor_list->{$cpu}) {
3579 push @$cpuFlags, "vendor=${cpu_vendor}"
3580 if $cpu_vendor ne 'default';
3581 } elsif ($arch ne 'aarch64') {
3582 die "internal error"; # should not happen
3585 $cpu .= "," . join(',', @$cpuFlags) if scalar(@$cpuFlags);
3587 return ('-cpu', $cpu);
3590 sub config_to_command
{
3591 my ($storecfg, $vmid, $conf, $defaults, $forcemachine) = @_;
3594 my $globalFlags = [];
3595 my $machineFlags = [];
3600 my $vernum = 0; # unknown
3601 my $ostype = $conf->{ostype
};
3602 my $winversion = windows_version
($ostype);
3603 my $kvm = $conf->{kvm
};
3605 my ($arch, $machine_type) = get_basic_machine_info
($conf, $forcemachine);
3606 my $kvm_binary = get_command_for_arch
($arch);
3607 my $kvmver = kvm_user_version
($kvm_binary);
3608 $kvm //= 1 if is_native
($arch);
3611 die "KVM virtualisation configured, but not available. Either disable in VM configuration or enable in BIOS.\n"
3612 if !defined kvm_version
();
3615 if ($kvmver =~ m/^(\d+)\.(\d+)$/) {
3616 $vernum = $1*1000000+$2*1000;
3617 } elsif ($kvmver =~ m/^(\d+)\.(\d+)\.(\d+)$/) {
3618 $vernum = $1*1000000+$2*1000+$3;
3621 die "detected old qemu-kvm binary ($kvmver)\n" if $vernum < 15000;
3623 my $have_ovz = -f
'/proc/vz/vestat';
3625 my $q35 = machine_type_is_q35
($conf);
3626 my $hotplug_features = parse_hotplug_features
(defined($conf->{hotplug
}) ?
$conf->{hotplug
} : '1');
3627 my $use_old_bios_files = undef;
3628 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
3630 my $cpuunits = defined($conf->{cpuunits
}) ?
3631 $conf->{cpuunits
} : $defaults->{cpuunits
};
3633 push @$cmd, $kvm_binary;
3635 push @$cmd, '-id', $vmid;
3637 my $vmname = $conf->{name
} || "vm$vmid";
3639 push @$cmd, '-name', $vmname;
3643 my $qmpsocket = qmp_socket
($vmid);
3644 push @$cmd, '-chardev', "socket,id=qmp,path=$qmpsocket,server,nowait";
3645 push @$cmd, '-mon', "chardev=qmp,mode=control";
3647 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 12)) {
3648 push @$cmd, '-chardev', "socket,id=qmp-event,path=/var/run/qmeventd.sock,reconnect=5";
3649 push @$cmd, '-mon', "chardev=qmp-event,mode=control";
3652 push @$cmd, '-pidfile' , pidfile_name
($vmid);
3654 push @$cmd, '-daemonize';
3656 if ($conf->{smbios1
}) {
3657 my $smbios_conf = parse_smbios1
($conf->{smbios1
});
3658 if ($smbios_conf->{base64
}) {
3659 # Do not pass base64 flag to qemu
3660 delete $smbios_conf->{base64
};
3661 my $smbios_string = "";
3662 foreach my $key (keys %$smbios_conf) {
3664 if ($key eq "uuid") {
3665 $value = $smbios_conf->{uuid
}
3667 $value = decode_base64
($smbios_conf->{$key});
3669 # qemu accepts any binary data, only commas need escaping by double comma
3671 $smbios_string .= "," . $key . "=" . $value if $value;
3673 push @$cmd, '-smbios', "type=1" . $smbios_string;
3675 push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
3679 if ($conf->{vmgenid
}) {
3680 push @$devices, '-device', 'vmgenid,guid='.$conf->{vmgenid
};
3683 my ($ovmf_code, $ovmf_vars) = get_ovmf_files
($arch);
3684 if ($conf->{bios
} && $conf->{bios
} eq 'ovmf') {
3685 die "uefi base image not found\n" if ! -f
$ovmf_code;
3689 if (my $efidisk = $conf->{efidisk0
}) {
3690 my $d = PVE
::JSONSchema
::parse_property_string
($efidisk_fmt, $efidisk);
3691 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($d->{file
}, 1);
3692 $format = $d->{format
};
3694 $path = PVE
::Storage
::path
($storecfg, $d->{file
});
3695 if (!defined($format)) {
3696 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
3697 $format = qemu_img_format
($scfg, $volname);
3701 die "efidisk format must be specified\n"
3702 if !defined($format);
3705 warn "no efidisk configured! Using temporary efivars disk.\n";
3706 $path = "/tmp/$vmid-ovmf.fd";
3707 PVE
::Tools
::file_copy
($ovmf_vars, $path, -s
$ovmf_vars);
3711 push @$cmd, '-drive', "if=pflash,unit=0,format=raw,readonly,file=$ovmf_code";
3712 push @$cmd, '-drive', "if=pflash,unit=1,format=$format,id=drive-efidisk0,file=$path";
3717 # we use different pcie-port hardware for qemu >= 4.0 for passthrough
3718 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 4, 0)) {
3719 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35-4.0.cfg';
3721 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35.cfg';
3725 # add usb controllers
3726 my @usbcontrollers = PVE
::QemuServer
::USB
::get_usb_controllers
($conf, $bridges, $arch, $machine_type, $usbdesc->{format
}, $MAX_USB_DEVICES);
3727 push @$devices, @usbcontrollers if @usbcontrollers;
3728 my $vga = parse_vga
($conf->{vga
});
3730 my $qxlnum = vga_conf_has_spice
($conf->{vga
});
3731 $vga->{type
} = 'qxl' if $qxlnum;
3733 if (!$vga->{type
}) {
3734 if ($arch eq 'aarch64') {
3735 $vga->{type
} = 'virtio';
3736 } elsif (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 9)) {
3737 $vga->{type
} = (!$winversion || $winversion >= 6) ?
'std' : 'cirrus';
3739 $vga->{type
} = ($winversion >= 6) ?
'std' : 'cirrus';
3743 # enable absolute mouse coordinates (needed by vnc)
3745 if (defined($conf->{tablet
})) {
3746 $tablet = $conf->{tablet
};
3748 $tablet = $defaults->{tablet
};
3749 $tablet = 0 if $qxlnum; # disable for spice because it is not needed
3750 $tablet = 0 if $vga->{type
} =~ m/^serial\d+$/; # disable if we use serial terminal (no vga card)
3754 push @$devices, '-device', print_tabletdevice_full
($conf, $arch) if $tablet;
3755 my $kbd = print_keyboarddevice_full
($conf, $arch);
3756 push @$devices, '-device', $kbd if defined($kbd);
3760 my $gpu_passthrough;
3763 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
3764 my $id = "hostpci$i";
3765 my $d = parse_hostpci
($conf->{$id});
3768 if (my $pcie = $d->{pcie
}) {
3769 die "q35 machine model is not enabled" if !$q35;
3770 # win7 wants to have the pcie devices directly on the pcie bus
3771 # instead of in the root port
3772 if ($winversion == 7) {
3773 $pciaddr = print_pcie_addr
("${id}bus0");
3775 # add more root ports if needed, 4 are present by default
3776 # by pve-q35 cfgs, rest added here on demand.
3778 push @$devices, '-device', print_pcie_root_port
($i);
3780 $pciaddr = print_pcie_addr
($id);
3783 $pciaddr = print_pci_addr
($id, $bridges, $arch, $machine_type);
3787 if ($d->{'x-vga'}) {
3788 $xvga = ',x-vga=on' if !($conf->{bios
} && $conf->{bios
} eq 'ovmf');
3790 $vga->{type
} = 'none' if !defined($conf->{vga
});
3791 $gpu_passthrough = 1;
3794 my $pcidevices = $d->{pciid
};
3795 my $multifunction = 1 if @$pcidevices > 1;
3798 if ($d->{mdev
} && scalar(@$pcidevices) == 1) {
3799 my $pci_id = $pcidevices->[0]->{id
};
3800 my $uuid = PVE
::SysFSTools
::generate_mdev_uuid
($vmid, $i);
3801 $sysfspath = "/sys/bus/pci/devices/0000:$pci_id/$uuid";
3802 } elsif ($d->{mdev
}) {
3803 warn "ignoring mediated device '$id' with multifunction device\n";
3807 foreach my $pcidevice (@$pcidevices) {
3808 my $devicestr = "vfio-pci";
3811 $devicestr .= ",sysfsdev=$sysfspath";
3813 $devicestr .= ",host=$pcidevice->{id}";
3816 my $mf_addr = $multifunction ?
".$j" : '';
3817 $devicestr .= ",id=${id}${mf_addr}${pciaddr}${mf_addr}";
3820 $devicestr .= ',rombar=0' if defined($d->{rombar
}) && !$d->{rombar
};
3821 $devicestr .= "$xvga";
3822 $devicestr .= ",multifunction=on" if $multifunction;
3823 $devicestr .= ",romfile=/usr/share/kvm/$d->{romfile}" if $d->{romfile
};
3826 push @$devices, '-device', $devicestr;
3832 my @usbdevices = PVE
::QemuServer
::USB
::get_usb_devices
($conf, $usbdesc->{format
}, $MAX_USB_DEVICES);
3833 push @$devices, @usbdevices if @usbdevices;
3835 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
3836 if (my $path = $conf->{"serial$i"}) {
3837 if ($path eq 'socket') {
3838 my $socket = "/var/run/qemu-server/${vmid}.serial$i";
3839 push @$devices, '-chardev', "socket,id=serial$i,path=$socket,server,nowait";
3840 # On aarch64, serial0 is the UART device. Qemu only allows
3841 # connecting UART devices via the '-serial' command line, as
3842 # the device has a fixed slot on the hardware...
3843 if ($arch eq 'aarch64' && $i == 0) {
3844 push @$devices, '-serial', "chardev:serial$i";
3846 push @$devices, '-device', "isa-serial,chardev=serial$i";
3849 die "no such serial device\n" if ! -c
$path;
3850 push @$devices, '-chardev', "tty,id=serial$i,path=$path";
3851 push @$devices, '-device', "isa-serial,chardev=serial$i";
3857 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
3858 if (my $path = $conf->{"parallel$i"}) {
3859 die "no such parallel device\n" if ! -c
$path;
3860 my $devtype = $path =~ m!^/dev/usb/lp! ?
'tty' : 'parport';
3861 push @$devices, '-chardev', "$devtype,id=parallel$i,path=$path";
3862 push @$devices, '-device', "isa-parallel,chardev=parallel$i";
3866 if (my $audio = conf_has_audio
($conf)) {
3868 my $audiopciaddr = print_pci_addr
("audio0", $bridges, $arch, $machine_type);
3870 my $id = $audio->{dev_id
};
3871 if ($audio->{dev
} eq 'AC97') {
3872 push @$devices, '-device', "AC97,id=${id}${audiopciaddr}";
3873 } elsif ($audio->{dev
} =~ /intel\-hda$/) {
3874 push @$devices, '-device', "$audio->{dev},id=${id}${audiopciaddr}";
3875 push @$devices, '-device', "hda-micro,id=${id}-codec0,bus=${id}.0,cad=0";
3876 push @$devices, '-device', "hda-duplex,id=${id}-codec1,bus=${id}.0,cad=1";
3878 die "unkown audio device '$audio->{dev}', implement me!";
3881 push @$devices, '-audiodev', "$audio->{backend},id=$audio->{backend_id}";
3885 $sockets = $conf->{smp
} if $conf->{smp
}; # old style - no longer iused
3886 $sockets = $conf->{sockets
} if $conf->{sockets
};
3888 my $cores = $conf->{cores
} || 1;
3890 my $maxcpus = $sockets * $cores;
3892 my $vcpus = $conf->{vcpus
} ?
$conf->{vcpus
} : $maxcpus;
3894 my $allowed_vcpus = $cpuinfo->{cpus
};
3896 die "MAX $allowed_vcpus vcpus allowed per VM on this node\n"
3897 if ($allowed_vcpus < $maxcpus);
3899 if($hotplug_features->{cpu
} && qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 7)) {
3901 push @$cmd, '-smp', "1,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3902 for (my $i = 2; $i <= $vcpus; $i++) {
3903 my $cpustr = print_cpu_device
($conf,$i);
3904 push @$cmd, '-device', $cpustr;
3909 push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3911 push @$cmd, '-nodefaults';
3913 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
3915 my $bootindex_hash = {};
3917 foreach my $o (split(//, $bootorder)) {
3918 $bootindex_hash->{$o} = $i*100;
3922 push @$cmd, '-boot', "menu=on,strict=on,reboot-timeout=1000,splash=/usr/share/qemu-server/bootsplash.jpg";
3924 push @$cmd, '-no-acpi' if defined($conf->{acpi
}) && $conf->{acpi
} == 0;
3926 push @$cmd, '-no-reboot' if defined($conf->{reboot
}) && $conf->{reboot
} == 0;
3928 if ($vga->{type
} && $vga->{type
} !~ m/^serial\d+$/ && $vga->{type
} ne 'none'){
3929 push @$devices, '-device', print_vga_device
($conf, $vga, $arch, $machine_type, undef, $qxlnum, $bridges);
3930 my $socket = vnc_socket
($vmid);
3931 push @$cmd, '-vnc', "unix:$socket,password";
3933 push @$cmd, '-vga', 'none' if $vga->{type
} eq 'none';
3934 push @$cmd, '-nographic';
3938 my $tdf = defined($conf->{tdf
}) ?
$conf->{tdf
} : $defaults->{tdf
};
3940 my $useLocaltime = $conf->{localtime};
3942 if ($winversion >= 5) { # windows
3943 $useLocaltime = 1 if !defined($conf->{localtime});
3945 # use time drift fix when acpi is enabled
3946 if (!(defined($conf->{acpi
}) && $conf->{acpi
} == 0)) {
3947 $tdf = 1 if !defined($conf->{tdf
});
3951 if ($winversion >= 6) {
3952 push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
3953 push @$cmd, '-no-hpet';
3956 push @$rtcFlags, 'driftfix=slew' if $tdf;
3959 push @$machineFlags, 'accel=tcg';
3962 if ($machine_type) {
3963 push @$machineFlags, "type=${machine_type}";
3966 if (($conf->{startdate
}) && ($conf->{startdate
} ne 'now')) {
3967 push @$rtcFlags, "base=$conf->{startdate}";
3968 } elsif ($useLocaltime) {
3969 push @$rtcFlags, 'base=localtime';
3972 push @$cmd, get_cpu_options
($conf, $arch, $kvm, $machine_type, $kvm_off, $kvmver, $winversion, $gpu_passthrough);
3974 PVE
::QemuServer
::Memory
::config
($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd);
3976 push @$cmd, '-S' if $conf->{freeze
};
3978 push @$cmd, '-k', $conf->{keyboard
} if defined($conf->{keyboard
});
3980 if (parse_guest_agent
($conf)->{enabled
}) {
3981 my $qgasocket = qmp_socket
($vmid, 1);
3982 my $pciaddr = print_pci_addr
("qga0", $bridges, $arch, $machine_type);
3983 push @$devices, '-chardev', "socket,path=$qgasocket,server,nowait,id=qga0";
3984 push @$devices, '-device', "virtio-serial,id=qga0$pciaddr";
3985 push @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
3993 for(my $i = 1; $i < $qxlnum; $i++){
3994 push @$devices, '-device', print_vga_device
($conf, $vga, $arch, $machine_type, $i, $qxlnum, $bridges);
3997 # assume other OS works like Linux
3998 my ($ram, $vram) = ("134217728", "67108864");
3999 if ($vga->{memory
}) {
4000 $ram = PVE
::Tools
::convert_size
($qxlnum*4*$vga->{memory
}, 'mb' => 'b');
4001 $vram = PVE
::Tools
::convert_size
($qxlnum*2*$vga->{memory
}, 'mb' => 'b');
4003 push @$cmd, '-global', "qxl-vga.ram_size=$ram";
4004 push @$cmd, '-global', "qxl-vga.vram_size=$vram";
4008 my $pciaddr = print_pci_addr
("spice", $bridges, $arch, $machine_type);
4010 my $nodename = PVE
::INotify
::nodename
();
4011 my $pfamily = PVE
::Tools
::get_host_address_family
($nodename);
4012 my @nodeaddrs = PVE
::Tools
::getaddrinfo_all
('localhost', family
=> $pfamily);
4013 die "failed to get an ip address of type $pfamily for 'localhost'\n" if !@nodeaddrs;
4014 my $localhost = PVE
::Network
::addr_to_ip
($nodeaddrs[0]->{addr
});
4015 $spice_port = PVE
::Tools
::next_spice_port
($pfamily, $localhost);
4017 my $spice_enhancement = PVE
::JSONSchema
::parse_property_string
($spice_enhancements_fmt, $conf->{spice_enhancements
} // '');
4018 if ($spice_enhancement->{foldersharing
}) {
4019 push @$devices, '-chardev', "spiceport,id=foldershare,name=org.spice-space.webdav.0";
4020 push @$devices, '-device', "virtserialport,chardev=foldershare,name=org.spice-space.webdav.0";
4023 my $spice_opts = "tls-port=${spice_port},addr=$localhost,tls-ciphers=HIGH,seamless-migration=on";
4024 $spice_opts .= ",streaming-video=$spice_enhancement->{videostreaming}" if $spice_enhancement->{videostreaming
};
4025 push @$devices, '-spice', "$spice_opts";
4027 push @$devices, '-device', "virtio-serial,id=spice$pciaddr";
4028 push @$devices, '-chardev', "spicevmc,id=vdagent,name=vdagent";
4029 push @$devices, '-device', "virtserialport,chardev=vdagent,name=com.redhat.spice.0";
4033 # enable balloon by default, unless explicitly disabled
4034 if (!defined($conf->{balloon
}) || $conf->{balloon
}) {
4035 $pciaddr = print_pci_addr
("balloon0", $bridges, $arch, $machine_type);
4036 push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr";
4039 if ($conf->{watchdog
}) {
4040 my $wdopts = parse_watchdog
($conf->{watchdog
});
4041 $pciaddr = print_pci_addr
("watchdog", $bridges, $arch, $machine_type);
4042 my $watchdog = $wdopts->{model
} || 'i6300esb';
4043 push @$devices, '-device', "$watchdog$pciaddr";
4044 push @$devices, '-watchdog-action', $wdopts->{action
} if $wdopts->{action
};
4048 my $scsicontroller = {};
4049 my $ahcicontroller = {};
4050 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : $defaults->{scsihw
};
4052 # Add iscsi initiator name if available
4053 if (my $initiator = get_initiator_name
()) {
4054 push @$devices, '-iscsi', "initiator-name=$initiator";
4057 foreach_drive
($conf, sub {
4058 my ($ds, $drive) = @_;
4060 if (PVE
::Storage
::parse_volume_id
($drive->{file
}, 1)) {
4061 push @$vollist, $drive->{file
};
4064 # ignore efidisk here, already added in bios/fw handling code above
4065 return if $drive->{interface
} eq 'efidisk';
4067 $use_virtio = 1 if $ds =~ m/^virtio/;
4069 if (drive_is_cdrom
($drive)) {
4070 if ($bootindex_hash->{d
}) {
4071 $drive->{bootindex
} = $bootindex_hash->{d
};
4072 $bootindex_hash->{d
} += 1;
4075 if ($bootindex_hash->{c
}) {
4076 $drive->{bootindex
} = $bootindex_hash->{c
} if $conf->{bootdisk
} && ($conf->{bootdisk
} eq $ds);
4077 $bootindex_hash->{c
} += 1;
4081 if($drive->{interface
} eq 'virtio'){
4082 push @$cmd, '-object', "iothread,id=iothread-$ds" if $drive->{iothread
};
4085 if ($drive->{interface
} eq 'scsi') {
4087 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
4089 $pciaddr = print_pci_addr
("$controller_prefix$controller", $bridges, $arch, $machine_type);
4090 my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ?
"virtio-scsi-pci" : $scsihw;
4093 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{iothread
}){
4094 $iothread .= ",iothread=iothread-$controller_prefix$controller";
4095 push @$cmd, '-object', "iothread,id=iothread-$controller_prefix$controller";
4096 } elsif ($drive->{iothread
}) {
4097 warn "iothread is only valid with virtio disk or virtio-scsi-single controller, ignoring\n";
4101 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{queues
}){
4102 $queues = ",num_queues=$drive->{queues}";
4105 push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr$iothread$queues" if !$scsicontroller->{$controller};
4106 $scsicontroller->{$controller}=1;
4109 if ($drive->{interface
} eq 'sata') {
4110 my $controller = int($drive->{index} / $MAX_SATA_DISKS);
4111 $pciaddr = print_pci_addr
("ahci$controller", $bridges, $arch, $machine_type);
4112 push @$devices, '-device', "ahci,id=ahci$controller,multifunction=on$pciaddr" if !$ahcicontroller->{$controller};
4113 $ahcicontroller->{$controller}=1;
4116 my $drive_cmd = print_drive_full
($storecfg, $vmid, $drive);
4117 push @$devices, '-drive',$drive_cmd;
4118 push @$devices, '-device', print_drivedevice_full
($storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type);
4121 for (my $i = 0; $i < $MAX_NETS; $i++) {
4122 next if !$conf->{"net$i"};
4123 my $d = parse_net
($conf->{"net$i"});
4126 $use_virtio = 1 if $d->{model
} eq 'virtio';
4128 if ($bootindex_hash->{n
}) {
4129 $d->{bootindex
} = $bootindex_hash->{n
};
4130 $bootindex_hash->{n
} += 1;
4133 my $netdevfull = print_netdev_full
($vmid, $conf, $arch, $d, "net$i");
4134 push @$devices, '-netdev', $netdevfull;
4136 my $netdevicefull = print_netdevice_full
($vmid, $conf, $d, "net$i", $bridges, $use_old_bios_files, $arch, $machine_type);
4137 push @$devices, '-device', $netdevicefull;
4140 if ($conf->{ivshmem
}) {
4141 my $ivshmem = PVE
::JSONSchema
::parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
4145 $bus = print_pcie_addr
("ivshmem");
4147 $bus = print_pci_addr
("ivshmem", $bridges, $arch, $machine_type);
4150 my $ivshmem_name = $ivshmem->{name
} // $vmid;
4151 my $path = '/dev/shm/pve-shm-' . $ivshmem_name;
4153 push @$devices, '-device', "ivshmem-plain,memdev=ivshmem$bus,";
4154 push @$devices, '-object', "memory-backend-file,id=ivshmem,share=on,mem-path=$path,size=$ivshmem->{size}M";
4159 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3)) {
4164 $bridges->{3} = 1 if $scsihw =~ m/^virtio-scsi-single/;
4166 while (my ($k, $v) = each %$bridges) {
4167 $pciaddr = print_pci_addr
("pci.$k", undef, $arch, $machine_type);
4168 unshift @$devices, '-device', "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr" if $k > 0;
4172 push @$cmd, @$devices;
4173 push @$cmd, '-rtc', join(',', @$rtcFlags)
4174 if scalar(@$rtcFlags);
4175 push @$cmd, '-machine', join(',', @$machineFlags)
4176 if scalar(@$machineFlags);
4177 push @$cmd, '-global', join(',', @$globalFlags)
4178 if scalar(@$globalFlags);
4180 if (my $vmstate = $conf->{vmstate
}) {
4181 my $statepath = PVE
::Storage
::path
($storecfg, $vmstate);
4182 PVE
::Storage
::activate_volumes
($storecfg, [$vmstate]);
4183 push @$cmd, '-loadstate', $statepath;
4187 if ($conf->{args
}) {
4188 my $aa = PVE
::Tools
::split_args
($conf->{args
});
4192 return wantarray ?
($cmd, $vollist, $spice_port) : $cmd;
4197 return "${var_run_tmpdir}/$vmid.vnc";
4203 my $res = vm_mon_cmd
($vmid, 'query-spice');
4205 return $res->{'tls-port'} || $res->{'port'} || die "no spice port\n";
4209 my ($vmid, $qga, $name) = @_;
4210 my $sockettype = $qga ?
'qga' : 'qmp';
4211 my $ext = $name ?
'-'.$name : '';
4212 return "${var_run_tmpdir}/$vmid$ext.$sockettype";
4217 return "${var_run_tmpdir}/$vmid.pid";
4220 sub vm_devices_list
{
4223 my $res = vm_mon_cmd
($vmid, 'query-pci');
4224 my $devices_to_check = [];
4226 foreach my $pcibus (@$res) {
4227 push @$devices_to_check, @{$pcibus->{devices
}},
4230 while (@$devices_to_check) {
4232 for my $d (@$devices_to_check) {
4233 $devices->{$d->{'qdev_id'}} = 1 if $d->{'qdev_id'};
4234 next if !$d->{'pci_bridge'};
4236 $devices->{$d->{'qdev_id'}} += scalar(@{$d->{'pci_bridge'}->{devices
}});
4237 push @$to_check, @{$d->{'pci_bridge'}->{devices
}};
4239 $devices_to_check = $to_check;
4242 my $resblock = vm_mon_cmd
($vmid, 'query-block');
4243 foreach my $block (@$resblock) {
4244 if($block->{device
} =~ m/^drive-(\S+)/){
4249 my $resmice = vm_mon_cmd
($vmid, 'query-mice');
4250 foreach my $mice (@$resmice) {
4251 if ($mice->{name
} eq 'QEMU HID Tablet') {
4252 $devices->{tablet
} = 1;
4257 # for usb devices there is no query-usb
4258 # but we can iterate over the entries in
4259 # qom-list path=/machine/peripheral
4260 my $resperipheral = vm_mon_cmd
($vmid, 'qom-list', path
=> '/machine/peripheral');
4261 foreach my $per (@$resperipheral) {
4262 if ($per->{name
} =~ m/^usb\d+$/) {
4263 $devices->{$per->{name
}} = 1;
4271 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
4273 my $q35 = machine_type_is_q35
($conf);
4275 my $devices_list = vm_devices_list
($vmid);
4276 return 1 if defined($devices_list->{$deviceid});
4278 qemu_add_pci_bridge
($storecfg, $conf, $vmid, $deviceid, $arch, $machine_type); # add PCI bridge if we need it for the device
4280 if ($deviceid eq 'tablet') {
4282 qemu_deviceadd
($vmid, print_tabletdevice_full
($conf, $arch));
4284 } elsif ($deviceid eq 'keyboard') {
4286 qemu_deviceadd
($vmid, print_keyboarddevice_full
($conf, $arch));
4288 } elsif ($deviceid =~ m/^usb(\d+)$/) {
4290 die "usb hotplug currently not reliable\n";
4291 # since we can't reliably hot unplug all added usb devices
4292 # and usb passthrough disables live migration
4293 # we disable usb hotplugging for now
4294 qemu_deviceadd
($vmid, PVE
::QemuServer
::USB
::print_usbdevice_full
($conf, $deviceid, $device));
4296 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
4298 qemu_iothread_add
($vmid, $deviceid, $device);
4300 qemu_driveadd
($storecfg, $vmid, $device);
4301 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, $arch, $machine_type);
4303 qemu_deviceadd
($vmid, $devicefull);
4304 eval { qemu_deviceaddverify
($vmid, $deviceid); };
4306 eval { qemu_drivedel
($vmid, $deviceid); };
4311 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
4314 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : "lsi";
4315 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
4316 my $scsihw_type = $scsihw eq 'virtio-scsi-single' ?
"virtio-scsi-pci" : $scsihw;
4318 my $devicefull = "$scsihw_type,id=$deviceid$pciaddr";
4320 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{iothread
}) {
4321 qemu_iothread_add
($vmid, $deviceid, $device);
4322 $devicefull .= ",iothread=iothread-$deviceid";
4325 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{queues
}) {
4326 $devicefull .= ",num_queues=$device->{queues}";
4329 qemu_deviceadd
($vmid, $devicefull);
4330 qemu_deviceaddverify
($vmid, $deviceid);
4332 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
4334 qemu_findorcreatescsihw
($storecfg,$conf, $vmid, $device, $arch, $machine_type);
4335 qemu_driveadd
($storecfg, $vmid, $device);
4337 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, $arch, $machine_type);
4338 eval { qemu_deviceadd
($vmid, $devicefull); };
4340 eval { qemu_drivedel
($vmid, $deviceid); };
4345 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
4347 return undef if !qemu_netdevadd
($vmid, $conf, $arch, $device, $deviceid);
4349 my $machine_type = PVE
::QemuServer
::qemu_machine_pxe
($vmid, $conf);
4350 my $use_old_bios_files = undef;
4351 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
4353 my $netdevicefull = print_netdevice_full
($vmid, $conf, $device, $deviceid, undef, $use_old_bios_files, $arch, $machine_type);
4354 qemu_deviceadd
($vmid, $netdevicefull);
4356 qemu_deviceaddverify
($vmid, $deviceid);
4357 qemu_set_link_status
($vmid, $deviceid, !$device->{link_down
});
4360 eval { qemu_netdevdel
($vmid, $deviceid); };
4365 } elsif (!$q35 && $deviceid =~ m/^(pci\.)(\d+)$/) {
4368 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
4369 my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
4371 qemu_deviceadd
($vmid, $devicefull);
4372 qemu_deviceaddverify
($vmid, $deviceid);
4375 die "can't hotplug device '$deviceid'\n";
4381 # fixme: this should raise exceptions on error!
4382 sub vm_deviceunplug
{
4383 my ($vmid, $conf, $deviceid) = @_;
4385 my $devices_list = vm_devices_list
($vmid);
4386 return 1 if !defined($devices_list->{$deviceid});
4388 die "can't unplug bootdisk" if $conf->{bootdisk
} && $conf->{bootdisk
} eq $deviceid;
4390 if ($deviceid eq 'tablet' || $deviceid eq 'keyboard') {
4392 qemu_devicedel
($vmid, $deviceid);
4394 } elsif ($deviceid =~ m/^usb\d+$/) {
4396 die "usb hotplug currently not reliable\n";
4397 # when unplugging usb devices this way,
4398 # there may be remaining usb controllers/hubs
4399 # so we disable it for now
4400 qemu_devicedel
($vmid, $deviceid);
4401 qemu_devicedelverify
($vmid, $deviceid);
4403 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
4405 qemu_devicedel
($vmid, $deviceid);
4406 qemu_devicedelverify
($vmid, $deviceid);
4407 qemu_drivedel
($vmid, $deviceid);
4408 qemu_iothread_del
($conf, $vmid, $deviceid);
4410 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
4412 qemu_devicedel
($vmid, $deviceid);
4413 qemu_devicedelverify
($vmid, $deviceid);
4414 qemu_iothread_del
($conf, $vmid, $deviceid);
4416 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
4418 qemu_devicedel
($vmid, $deviceid);
4419 qemu_drivedel
($vmid, $deviceid);
4420 qemu_deletescsihw
($conf, $vmid, $deviceid);
4422 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
4424 qemu_devicedel
($vmid, $deviceid);
4425 qemu_devicedelverify
($vmid, $deviceid);
4426 qemu_netdevdel
($vmid, $deviceid);
4429 die "can't unplug device '$deviceid'\n";
4435 sub qemu_deviceadd
{
4436 my ($vmid, $devicefull) = @_;
4438 $devicefull = "driver=".$devicefull;
4439 my %options = split(/[=,]/, $devicefull);
4441 vm_mon_cmd
($vmid, "device_add" , %options);
4444 sub qemu_devicedel
{
4445 my ($vmid, $deviceid) = @_;
4447 my $ret = vm_mon_cmd
($vmid, "device_del", id
=> $deviceid);
4450 sub qemu_iothread_add
{
4451 my($vmid, $deviceid, $device) = @_;
4453 if ($device->{iothread
}) {
4454 my $iothreads = vm_iothreads_list
($vmid);
4455 qemu_objectadd
($vmid, "iothread-$deviceid", "iothread") if !$iothreads->{"iothread-$deviceid"};
4459 sub qemu_iothread_del
{
4460 my($conf, $vmid, $deviceid) = @_;
4462 my $confid = $deviceid;
4463 if ($deviceid =~ m/^(?:virtioscsi|scsihw)(\d+)$/) {
4464 $confid = 'scsi' . $1;
4466 my $device = parse_drive
($confid, $conf->{$confid});
4467 if ($device->{iothread
}) {
4468 my $iothreads = vm_iothreads_list
($vmid);
4469 qemu_objectdel
($vmid, "iothread-$deviceid") if $iothreads->{"iothread-$deviceid"};
4473 sub qemu_objectadd
{
4474 my($vmid, $objectid, $qomtype) = @_;
4476 vm_mon_cmd
($vmid, "object-add", id
=> $objectid, "qom-type" => $qomtype);
4481 sub qemu_objectdel
{
4482 my($vmid, $objectid) = @_;
4484 vm_mon_cmd
($vmid, "object-del", id
=> $objectid);
4490 my ($storecfg, $vmid, $device) = @_;
4492 my $drive = print_drive_full
($storecfg, $vmid, $device);
4493 $drive =~ s/\\/\\\\/g;
4494 my $ret = vm_human_monitor_command
($vmid, "drive_add auto \"$drive\"");
4496 # If the command succeeds qemu prints: "OK
"
4497 return 1 if $ret =~ m/OK/s;
4499 die "adding drive failed
: $ret\n";
4503 my($vmid, $deviceid) = @_;
4505 my $ret = vm_human_monitor_command($vmid, "drive_del drive-
$deviceid");
4508 return 1 if $ret eq "";
4510 # NB: device not found errors mean the drive was auto-deleted and we ignore the error
4511 return 1 if $ret =~ m/Device \'.*?\' not found/s;
4513 die "deleting drive
$deviceid failed
: $ret\n";
4516 sub qemu_deviceaddverify {
4517 my ($vmid, $deviceid) = @_;
4519 for (my $i = 0; $i <= 5; $i++) {
4520 my $devices_list = vm_devices_list($vmid);
4521 return 1 if defined($devices_list->{$deviceid});
4525 die "error on hotplug device
'$deviceid'\n";
4529 sub qemu_devicedelverify {
4530 my ($vmid, $deviceid) = @_;
4532 # need to verify that the device is correctly removed as device_del
4533 # is async and empty return is not reliable
4535 for (my $i = 0; $i <= 5; $i++) {
4536 my $devices_list = vm_devices_list($vmid);
4537 return 1 if !defined($devices_list->{$deviceid});
4541 die "error on hot-unplugging device
'$deviceid'\n";
4544 sub qemu_findorcreatescsihw {
4545 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
4547 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
4549 my $scsihwid="$controller_prefix$controller";
4550 my $devices_list = vm_devices_list($vmid);
4552 if(!defined($devices_list->{$scsihwid})) {
4553 vm_deviceplug($storecfg, $conf, $vmid, $scsihwid, $device, $arch, $machine_type);
4559 sub qemu_deletescsihw {
4560 my ($conf, $vmid, $opt) = @_;
4562 my $device = parse_drive($opt, $conf->{$opt});
4564 if ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
4565 vm_deviceunplug($vmid, $conf, "virtioscsi
$device->{index}");
4569 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
4571 my $devices_list = vm_devices_list($vmid);
4572 foreach my $opt (keys %{$devices_list}) {
4573 if (PVE::QemuServer::is_valid_drivename($opt)) {
4574 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
4575 if($drive->{interface} eq 'scsi' && $drive->{index} < (($maxdev-1)*($controller+1))) {
4581 my $scsihwid="scsihw
$controller";
4583 vm_deviceunplug($vmid, $conf, $scsihwid);
4588 sub qemu_add_pci_bridge {
4589 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
4595 print_pci_addr($device, $bridges, $arch, $machine_type);
4597 while (my ($k, $v) = each %$bridges) {
4600 return 1 if !defined($bridgeid) || $bridgeid < 1;
4602 my $bridge = "pci
.$bridgeid";
4603 my $devices_list = vm_devices_list($vmid);
4605 if (!defined($devices_list->{$bridge})) {
4606 vm_deviceplug($storecfg, $conf, $vmid, $bridge, $arch, $machine_type);
4612 sub qemu_set_link_status {
4613 my ($vmid, $device, $up) = @_;
4615 vm_mon_cmd($vmid, "set_link
", name => $device,
4616 up => $up ? JSON::true : JSON::false);
4619 sub qemu_netdevadd {
4620 my ($vmid, $conf, $arch, $device, $deviceid) = @_;
4622 my $netdev = print_netdev_full($vmid, $conf, $arch, $device, $deviceid, 1);
4623 my %options = split(/[=,]/, $netdev);
4625 vm_mon_cmd($vmid, "netdev_add
", %options);
4629 sub qemu_netdevdel {
4630 my ($vmid, $deviceid) = @_;
4632 vm_mon_cmd($vmid, "netdev_del
", id => $deviceid);
4635 sub qemu_usb_hotplug {
4636 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
4640 # remove the old one first
4641 vm_deviceunplug($vmid, $conf, $deviceid);
4643 # check if xhci controller is necessary and available
4644 if ($device->{usb3}) {
4646 my $devicelist = vm_devices_list($vmid);
4648 if (!$devicelist->{xhci}) {
4649 my $pciaddr = print_pci_addr("xhci
", undef, $arch, $machine_type);
4650 qemu_deviceadd($vmid, "nec-usb-xhci
,id
=xhci
$pciaddr");
4653 my $d = parse_usb_device($device->{host});
4654 $d->{usb3} = $device->{usb3};
4657 vm_deviceplug($storecfg, $conf, $vmid, $deviceid, $d, $arch, $machine_type);
4660 sub qemu_cpu_hotplug {
4661 my ($vmid, $conf, $vcpus) = @_;
4663 my $machine_type = PVE::QemuServer::get_current_qemu_machine($vmid);
4666 $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
4667 $sockets = $conf->{sockets} if $conf->{sockets};
4668 my $cores = $conf->{cores} || 1;
4669 my $maxcpus = $sockets * $cores;
4671 $vcpus = $maxcpus if !$vcpus;
4673 die "you can
't add more vcpus than maxcpus\n"
4674 if $vcpus > $maxcpus;
4676 my $currentvcpus = $conf->{vcpus} || $maxcpus;
4678 if ($vcpus < $currentvcpus) {
4680 if (qemu_machine_feature_enabled ($machine_type, undef, 2, 7)) {
4682 for (my $i = $currentvcpus; $i > $vcpus; $i--) {
4683 qemu_devicedel($vmid, "cpu$i");
4685 my $currentrunningvcpus = undef;
4687 $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
4688 last if scalar(@{$currentrunningvcpus}) == $i-1;
4689 raise_param_exc({ vcpus => "error unplugging cpu$i" }) if $retry > 5;
4693 #update conf after each succesfull cpu unplug
4694 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4695 PVE::QemuConfig->write_config($vmid, $conf);
4698 die "cpu hot-unplugging requires qemu version 2.7 or higher\n";
4704 my $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
4705 die "vcpus in running vm does not match its configuration\n"
4706 if scalar(@{$currentrunningvcpus}) != $currentvcpus;
4708 if (qemu_machine_feature_enabled ($machine_type, undef, 2, 7)) {
4710 for (my $i = $currentvcpus+1; $i <= $vcpus; $i++) {
4711 my $cpustr = print_cpu_device($conf, $i);
4712 qemu_deviceadd($vmid, $cpustr);
4715 my $currentrunningvcpus = undef;
4717 $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
4718 last if scalar(@{$currentrunningvcpus}) == $i;
4719 raise_param_exc({ vcpus => "error hotplugging cpu$i" }) if $retry > 10;
4723 #update conf after each succesfull cpu hotplug
4724 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4725 PVE::QemuConfig->write_config($vmid, $conf);
4729 for (my $i = $currentvcpus; $i < $vcpus; $i++) {
4730 vm_mon_cmd($vmid, "cpu-add", id => int($i));
4735 sub qemu_block_set_io_throttle {
4736 my ($vmid, $deviceid,
4737 $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr,
4738 $bps_max, $bps_rd_max, $bps_wr_max, $iops_max, $iops_rd_max, $iops_wr_max,
4739 $bps_max_length, $bps_rd_max_length, $bps_wr_max_length,
4740 $iops_max_length, $iops_rd_max_length, $iops_wr_max_length) = @_;
4742 return if !check_running($vmid) ;
4744 vm_mon_cmd($vmid, "block_set_io_throttle", device => $deviceid,
4746 bps_rd => int($bps_rd),
4747 bps_wr => int($bps_wr),
4749 iops_rd => int($iops_rd),
4750 iops_wr => int($iops_wr),
4751 bps_max => int($bps_max),
4752 bps_rd_max => int($bps_rd_max),
4753 bps_wr_max => int($bps_wr_max),
4754 iops_max => int($iops_max),
4755 iops_rd_max => int($iops_rd_max),
4756 iops_wr_max => int($iops_wr_max),
4757 bps_max_length => int($bps_max_length),
4758 bps_rd_max_length => int($bps_rd_max_length),
4759 bps_wr_max_length => int($bps_wr_max_length),
4760 iops_max_length => int($iops_max_length),
4761 iops_rd_max_length => int($iops_rd_max_length),
4762 iops_wr_max_length => int($iops_wr_max_length),
4767 # old code, only used to shutdown old VM after update
4769 my ($fh, $timeout) = @_;
4771 my $sel = new IO::Select;
4778 while (scalar (@ready = $sel->can_read($timeout))) {
4780 if ($count = $fh->sysread($buf, 8192)) {
4781 if ($buf =~ /^(.*)\(qemu\) $/s) {
4788 if (!defined($count)) {
4795 die "monitor read timeout\n" if !scalar(@ready);
4800 sub qemu_block_resize {
4801 my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
4803 my $running = check_running($vmid);
4805 $size = 0 if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
4807 return if !$running;
4809 vm_mon_cmd($vmid, "block_resize", device => $deviceid, size => int($size));
4813 sub qemu_volume_snapshot {
4814 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4816 my $running = check_running($vmid);
4818 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4819 vm_mon_cmd($vmid, 'blockdev-snapshot-internal-sync
', device => $deviceid, name => $snap);
4821 PVE::Storage::volume_snapshot($storecfg, $volid, $snap);
4825 sub qemu_volume_snapshot_delete {
4826 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4828 my $running = check_running($vmid);
4833 my $conf = PVE::QemuConfig->load_config($vmid);
4834 foreach_drive($conf, sub {
4835 my ($ds, $drive) = @_;
4836 $running = 1 if $drive->{file} eq $volid;
4840 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4841 vm_mon_cmd($vmid, 'blockdev-snapshot-delete-internal-sync
', device => $deviceid, name => $snap);
4843 PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
4847 sub set_migration_caps {
4853 "auto-converge" => 1,
4855 "x-rdma-pin-all" => 0,
4860 my $supported_capabilities = vm_mon_cmd_nocheck($vmid, "query-migrate-capabilities");
4862 for my $supported_capability (@$supported_capabilities) {
4864 capability => $supported_capability->{capability},
4865 state => $enabled_cap->{$supported_capability->{capability}} ? JSON::true : JSON::false,
4869 vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => $cap_ref);
4872 my $fast_plug_option = {
4880 'vmstatestorage
' => 1,
4884 # hotplug changes in [PENDING]
4885 # $selection hash can be used to only apply specified options, for
4886 # example: { cores => 1 } (only apply changed 'cores
')
4887 # $errors ref is used to return error messages
4888 sub vmconfig_hotplug_pending {
4889 my ($vmid, $conf, $storecfg, $selection, $errors) = @_;
4891 my $defaults = load_defaults();
4892 my ($arch, $machine_type) = get_basic_machine_info($conf, undef);
4894 # commit values which do not have any impact on running VM first
4895 # Note: those option cannot raise errors, we we do not care about
4896 # $selection and always apply them.
4898 my $add_error = sub {
4899 my ($opt, $msg) = @_;
4900 $errors->{$opt} = "hotplug problem - $msg";
4904 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4905 if ($fast_plug_option->{$opt}) {
4906 $conf->{$opt} = $conf->{pending}->{$opt};
4907 delete $conf->{pending}->{$opt};
4913 PVE::QemuConfig->write_config($vmid, $conf);
4914 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4917 my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
4919 my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
4920 while (my ($opt, $force) = each %$pending_delete_hash) {
4921 next if $selection && !$selection->{$opt};
4923 if ($opt eq 'hotplug
') {
4924 die "skip\n" if ($conf->{hotplug} =~ /memory/);
4925 } elsif ($opt eq 'tablet
') {
4926 die "skip\n" if !$hotplug_features->{usb};
4927 if ($defaults->{tablet}) {
4928 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
4929 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
4930 if $arch eq 'aarch64
';
4932 vm_deviceunplug($vmid, $conf, 'tablet
');
4933 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
4935 } elsif ($opt =~ m/^usb\d+/) {
4937 # since we cannot reliably hot unplug usb devices
4938 # we are disabling it
4939 die "skip\n" if !$hotplug_features->{usb} || $conf->{$opt} =~ m/spice/i;
4940 vm_deviceunplug($vmid, $conf, $opt);
4941 } elsif ($opt eq 'vcpus
') {
4942 die "skip\n" if !$hotplug_features->{cpu};
4943 qemu_cpu_hotplug($vmid, $conf, undef);
4944 } elsif ($opt eq 'balloon
') {
4945 # enable balloon device is not hotpluggable
4946 die "skip\n" if defined($conf->{balloon}) && $conf->{balloon} == 0;
4947 # here we reset the ballooning value to memory
4948 my $balloon = $conf->{memory} || $defaults->{memory};
4949 vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4950 } elsif ($fast_plug_option->{$opt}) {
4952 } elsif ($opt =~ m/^net(\d+)$/) {
4953 die "skip\n" if !$hotplug_features->{network};
4954 vm_deviceunplug($vmid, $conf, $opt);
4955 } elsif (is_valid_drivename($opt)) {
4956 die "skip\n" if !$hotplug_features->{disk} || $opt =~ m/(ide|sata)(\d+)/;
4957 vm_deviceunplug($vmid, $conf, $opt);
4958 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4959 } elsif ($opt =~ m/^memory$/) {
4960 die "skip\n" if !$hotplug_features->{memory};
4961 PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
4962 } elsif ($opt eq 'cpuunits
') {
4963 cgroups_write("cpu", $vmid, "cpu.shares", $defaults->{cpuunits});
4964 } elsif ($opt eq 'cpulimit
') {
4965 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", -1);
4971 &$add_error($opt, $err) if $err ne "skip\n";
4973 # save new config if hotplug was successful
4974 delete $conf->{$opt};
4975 vmconfig_undelete_pending_option($conf, $opt);
4976 PVE::QemuConfig->write_config($vmid, $conf);
4977 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4981 my $apply_pending_cloudinit;
4982 $apply_pending_cloudinit = sub {
4983 my ($key, $value) = @_;
4984 $apply_pending_cloudinit = sub {}; # once is enough
4986 my @cloudinit_opts = keys %$confdesc_cloudinit;
4987 foreach my $opt (keys %{$conf->{pending}}) {
4988 next if !grep { $_ eq $opt } @cloudinit_opts;
4989 $conf->{$opt} = delete $conf->{pending}->{$opt};
4992 my $new_conf = { %$conf };
4993 $new_conf->{$key} = $value;
4994 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($new_conf, $vmid);
4997 foreach my $opt (keys %{$conf->{pending}}) {
4998 next if $selection && !$selection->{$opt};
4999 my $value = $conf->{pending}->{$opt};
5001 if ($opt eq 'hotplug
') {
5002 die "skip\n" if ($value =~ /memory/) || ($value !~ /memory/ && $conf->{hotplug} =~ /memory/);
5003 } elsif ($opt eq 'tablet
') {
5004 die "skip\n" if !$hotplug_features->{usb};
5006 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
5007 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
5008 if $arch eq 'aarch64
';
5009 } elsif ($value == 0) {
5010 vm_deviceunplug($vmid, $conf, 'tablet
');
5011 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
5013 } elsif ($opt =~ m/^usb\d+$/) {
5015 # since we cannot reliably hot unplug usb devices
5016 # we are disabling it
5017 die "skip\n" if !$hotplug_features->{usb} || $value =~ m/spice/i;
5018 my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format}, $value) };
5019 die "skip\n" if !$d;
5020 qemu_usb_hotplug($storecfg, $conf, $vmid, $opt, $d, $arch, $machine_type);
5021 } elsif ($opt eq 'vcpus
') {
5022 die "skip\n" if !$hotplug_features->{cpu};
5023 qemu_cpu_hotplug($vmid, $conf, $value);
5024 } elsif ($opt eq 'balloon
') {
5025 # enable/disable balloning device is not hotpluggable
5026 my $old_balloon_enabled = !!(!defined($conf->{balloon}) || $conf->{balloon});
5027 my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
5028 die "skip\n" if $old_balloon_enabled != $new_balloon_enabled;
5030 # allow manual ballooning if shares is set to zero
5031 if ((defined($conf->{shares}) && ($conf->{shares} == 0))) {
5032 my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
5033 vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
5035 } elsif ($opt =~ m/^net(\d+)$/) {
5036 # some changes can be done without hotplug
5037 vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
5038 $vmid, $opt, $value, $arch, $machine_type);
5039 } elsif (is_valid_drivename($opt)) {
5040 # some changes can be done without hotplug
5041 my $drive = parse_drive($opt, $value);
5042 if (drive_is_cloudinit($drive)) {
5043 &$apply_pending_cloudinit($opt, $value);
5045 vmconfig_update_disk($storecfg, $conf, $hotplug_features->{disk},
5046 $vmid, $opt, $value, 1, $arch, $machine_type);
5047 } elsif ($opt =~ m/^memory$/) { #dimms
5048 die "skip\n" if !$hotplug_features->{memory};
5049 $value = PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
5050 } elsif ($opt eq 'cpuunits
') {
5051 cgroups_write("cpu", $vmid, "cpu.shares", $conf->{pending}->{$opt});
5052 } elsif ($opt eq 'cpulimit
') {
5053 my $cpulimit = $conf->{pending}->{$opt} == 0 ? -1 : int($conf->{pending}->{$opt} * 100000);
5054 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", $cpulimit);
5056 die "skip\n"; # skip non-hot-pluggable options
5060 &$add_error($opt, $err) if $err ne "skip\n";
5062 # save new config if hotplug was successful
5063 $conf->{$opt} = $value;
5064 delete $conf->{pending}->{$opt};
5065 PVE::QemuConfig->write_config($vmid, $conf);
5066 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5071 sub try_deallocate_drive {
5072 my ($storecfg, $vmid, $conf, $key, $drive, $rpcenv, $authuser, $force) = @_;
5074 if (($force || $key =~ /^unused/) && !drive_is_cdrom($drive, 1)) {
5075 my $volid = $drive->{file};
5076 if (vm_is_volid_owner($storecfg, $vmid, $volid)) {
5077 my $sid = PVE::Storage::parse_volume_id($volid);
5078 $rpcenv->check($authuser, "/storage/$sid", ['Datastore
.AllocateSpace
']);
5080 # check if the disk is really unused
5081 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
5082 if is_volume_in_use($storecfg, $conf, $key, $volid);
5083 PVE::Storage::vdisk_free($storecfg, $volid);
5086 # If vm is not owner of this disk remove from config
5094 sub vmconfig_delete_or_detach_drive {
5095 my ($vmid, $storecfg, $conf, $opt, $force) = @_;
5097 my $drive = parse_drive($opt, $conf->{$opt});
5099 my $rpcenv = PVE::RPCEnvironment::get();
5100 my $authuser = $rpcenv->get_user();
5103 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM
.Config
.Disk
']);
5104 try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser, $force);
5106 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $drive);
5110 sub vmconfig_apply_pending {
5111 my ($vmid, $conf, $storecfg) = @_;
5115 my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
5116 while (my ($opt, $force) = each %$pending_delete_hash) {
5117 die "internal error" if $opt =~ m/^unused/;
5118 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5119 if (!defined($conf->{$opt})) {
5120 vmconfig_undelete_pending_option($conf, $opt);
5121 PVE::QemuConfig->write_config($vmid, $conf);
5122 } elsif (is_valid_drivename($opt)) {
5123 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
5124 vmconfig_undelete_pending_option($conf, $opt);
5125 delete $conf->{$opt};
5126 PVE::QemuConfig->write_config($vmid, $conf);
5128 vmconfig_undelete_pending_option($conf, $opt);
5129 delete $conf->{$opt};
5130 PVE::QemuConfig->write_config($vmid, $conf);
5134 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5136 foreach my $opt (keys %{$conf->{pending}}) { # add/change
5137 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5139 if (defined($conf->{$opt}) && ($conf->{$opt} eq $conf->{pending}->{$opt})) {
5140 # skip if nothing changed
5141 } elsif (is_valid_drivename($opt)) {
5142 vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}))
5143 if defined($conf->{$opt});
5144 $conf->{$opt} = $conf->{pending}->{$opt};
5146 $conf->{$opt} = $conf->{pending}->{$opt};
5149 delete $conf->{pending}->{$opt};
5150 PVE::QemuConfig->write_config($vmid, $conf);
5154 my $safe_num_ne = sub {
5157 return 0 if !defined($a) && !defined($b);
5158 return 1 if !defined($a);
5159 return 1 if !defined($b);
5164 my $safe_string_ne = sub {
5167 return 0 if !defined($a) && !defined($b);
5168 return 1 if !defined($a);
5169 return 1 if !defined($b);
5174 sub vmconfig_update_net {
5175 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $arch, $machine_type) = @_;
5177 my $newnet = parse_net($value);
5179 if ($conf->{$opt}) {
5180 my $oldnet = parse_net($conf->{$opt});
5182 if (&$safe_string_ne($oldnet->{model}, $newnet->{model}) ||
5183 &$safe_string_ne($oldnet->{macaddr}, $newnet->{macaddr}) ||
5184 &$safe_num_ne($oldnet->{queues}, $newnet->{queues}) ||
5185 !($newnet->{bridge} && $oldnet->{bridge})) { # bridge/nat mode change
5187 # for non online change, we try to hot-unplug
5188 die "skip\n" if !$hotplug;
5189 vm_deviceunplug($vmid, $conf, $opt);
5192 die "internal error" if $opt !~ m/net(\d+)/;
5193 my $iface = "tap${vmid}i$1";
5195 if (&$safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
5196 &$safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
5197 &$safe_string_ne($oldnet->{trunks}, $newnet->{trunks}) ||
5198 &$safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
5199 PVE::Network::tap_unplug($iface);
5200 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
5201 } elsif (&$safe_num_ne($oldnet->{rate}, $newnet->{rate})) {
5202 # Rate can be applied on its own but any change above needs to
5203 # include the rate in tap_plug since OVS resets everything.
5204 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
5207 if (&$safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
5208 qemu_set_link_status($vmid, $opt, !$newnet->{link_down});
5216 vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet, $arch, $machine_type);
5222 sub vmconfig_update_disk {
5223 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $force, $arch, $machine_type) = @_;
5225 # fixme: do we need force?
5227 my $drive = parse_drive($opt, $value);
5229 if ($conf->{$opt}) {
5231 if (my $old_drive = parse_drive($opt, $conf->{$opt})) {
5233 my $media = $drive->{media} || 'disk
';
5234 my $oldmedia = $old_drive->{media} || 'disk
';
5235 die "unable to change media type\n" if $media ne $oldmedia;
5237 if (!drive_is_cdrom($old_drive)) {
5239 if ($drive->{file} ne $old_drive->{file}) {
5241 die "skip\n" if !$hotplug;
5243 # unplug and register as unused
5244 vm_deviceunplug($vmid, $conf, $opt);
5245 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive)
5248 # update existing disk
5250 # skip non hotpluggable value
5251 if (&$safe_string_ne($drive->{discard}, $old_drive->{discard}) ||
5252 &$safe_string_ne($drive->{iothread}, $old_drive->{iothread}) ||
5253 &$safe_string_ne($drive->{queues}, $old_drive->{queues}) ||
5254 &$safe_string_ne($drive->{cache}, $old_drive->{cache})) {
5259 if (&$safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
5260 &$safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
5261 &$safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
5262 &$safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
5263 &$safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
5264 &$safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr}) ||
5265 &$safe_num_ne($drive->{mbps_max}, $old_drive->{mbps_max}) ||
5266 &$safe_num_ne($drive->{mbps_rd_max}, $old_drive->{mbps_rd_max}) ||
5267 &$safe_num_ne($drive->{mbps_wr_max}, $old_drive->{mbps_wr_max}) ||
5268 &$safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
5269 &$safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
5270 &$safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max}) ||
5271 &$safe_num_ne($drive->{bps_max_length}, $old_drive->{bps_max_length}) ||
5272 &$safe_num_ne($drive->{bps_rd_max_length}, $old_drive->{bps_rd_max_length}) ||
5273 &$safe_num_ne($drive->{bps_wr_max_length}, $old_drive->{bps_wr_max_length}) ||
5274 &$safe_num_ne($drive->{iops_max_length}, $old_drive->{iops_max_length}) ||
5275 &$safe_num_ne($drive->{iops_rd_max_length}, $old_drive->{iops_rd_max_length}) ||
5276 &$safe_num_ne($drive->{iops_wr_max_length}, $old_drive->{iops_wr_max_length})) {
5278 qemu_block_set_io_throttle($vmid,"drive-$opt",
5279 ($drive->{mbps} || 0)*1024*1024,
5280 ($drive->{mbps_rd} || 0)*1024*1024,
5281 ($drive->{mbps_wr} || 0)*1024*1024,
5282 $drive->{iops} || 0,
5283 $drive->{iops_rd} || 0,
5284 $drive->{iops_wr} || 0,
5285 ($drive->{mbps_max} || 0)*1024*1024,
5286 ($drive->{mbps_rd_max} || 0)*1024*1024,
5287 ($drive->{mbps_wr_max} || 0)*1024*1024,
5288 $drive->{iops_max} || 0,
5289 $drive->{iops_rd_max} || 0,
5290 $drive->{iops_wr_max} || 0,
5291 $drive->{bps_max_length} || 1,
5292 $drive->{bps_rd_max_length} || 1,
5293 $drive->{bps_wr_max_length} || 1,
5294 $drive->{iops_max_length} || 1,
5295 $drive->{iops_rd_max_length} || 1,
5296 $drive->{iops_wr_max_length} || 1);
5305 if ($drive->{file} eq 'none
') {
5306 vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
5307 if (drive_is_cloudinit($old_drive)) {
5308 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive);
5311 my $path = get_iso_path($storecfg, $vmid, $drive->{file});
5312 vm_mon_cmd($vmid, "eject", force => JSON::true,device => "drive-$opt"); # force eject if locked
5313 vm_mon_cmd($vmid, "change", device => "drive-$opt",target => "$path") if $path;
5321 die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
5323 PVE::Storage::activate_volumes($storecfg, [$drive->{file}]) if $drive->{file} !~ m|^/dev/.+|;
5324 vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive, $arch, $machine_type);
5328 my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused,
5329 $forcemachine, $spice_ticket, $migration_network, $migration_type, $targetstorage) = @_;
5331 PVE::QemuConfig->lock_config($vmid, sub {
5332 my $conf = PVE::QemuConfig->load_config($vmid, $migratedfrom);
5334 die "you can't start a vm
if it
's a template\n" if PVE::QemuConfig->is_template($conf);
5336 my $is_suspended = PVE::QemuConfig->has_lock($conf, 'suspended
');
5338 PVE::QemuConfig->check_lock($conf)
5339 if !($skiplock || $is_suspended);
5341 die "VM $vmid already running\n" if check_running($vmid, undef, $migratedfrom);
5343 if (!$statefile && scalar(keys %{$conf->{pending}})) {
5344 vmconfig_apply_pending($vmid, $conf, $storecfg);
5345 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5348 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($conf, $vmid);
5350 my $defaults = load_defaults();
5352 # set environment variable useful inside network script
5353 $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
5355 my $local_volumes = {};
5357 if ($targetstorage) {
5358 foreach_drive($conf, sub {
5359 my ($ds, $drive) = @_;
5361 return if drive_is_cdrom($drive);
5363 my $volid = $drive->{file};
5367 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
5369 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
5370 return if $scfg->{shared};
5371 $local_volumes->{$ds} = [$volid, $storeid, $volname];
5376 foreach my $opt (sort keys %$local_volumes) {
5378 my ($volid, $storeid, $volname) = @{$local_volumes->{$opt}};
5379 my $drive = parse_drive($opt, $conf->{$opt});
5381 #if remote storage is specified, use default format
5382 if ($targetstorage && $targetstorage ne "1") {
5383 $storeid = $targetstorage;
5384 my ($defFormat, $validFormats) = PVE::Storage::storage_default_format($storecfg, $storeid);
5385 $format = $defFormat;
5387 #else we use same format than original
5388 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
5389 $format = qemu_img_format($scfg, $volid);
5392 my $newvolid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $format, undef, ($drive->{size}/1024));
5393 my $newdrive = $drive;
5394 $newdrive->{format} = $format;
5395 $newdrive->{file} = $newvolid;
5396 my $drivestr = PVE::QemuServer::print_drive($vmid, $newdrive);
5397 $local_volumes->{$opt} = $drivestr;
5398 #pass drive to conf for command line
5399 $conf->{$opt} = $drivestr;
5403 PVE::GuestHelpers::exec_hookscript($conf, $vmid, 'pre-start
', 1);
5405 if ($is_suspended) {
5406 # enforce machine type on suspended vm to ensure HW compatibility
5407 $forcemachine = $conf->{runningmachine};
5408 print "Resuming suspended VM\n";
5411 my ($cmd, $vollist, $spice_port) = config_to_command($storecfg, $vmid, $conf, $defaults, $forcemachine);
5413 my $migrate_port = 0;
5416 if ($statefile eq 'tcp
') {
5417 my $localip = "localhost";
5418 my $datacenterconf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
5419 my $nodename = PVE::INotify::nodename();
5421 if (!defined($migration_type)) {
5422 if (defined($datacenterconf->{migration}->{type})) {
5423 $migration_type = $datacenterconf->{migration}->{type};
5425 $migration_type = 'secure
';
5429 if ($migration_type eq 'insecure
') {
5430 my $migrate_network_addr = PVE::Cluster::get_local_migration_ip($migration_network);
5431 if ($migrate_network_addr) {
5432 $localip = $migrate_network_addr;
5434 $localip = PVE::Cluster::remote_node_ip($nodename, 1);
5437 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
5440 my $pfamily = PVE::Tools::get_host_address_family($nodename);
5441 $migrate_port = PVE::Tools::next_migrate_port($pfamily);
5442 $migrate_uri = "tcp:${localip}:${migrate_port}";
5443 push @$cmd, '-incoming
', $migrate_uri;
5446 } elsif ($statefile eq 'unix
') {
5447 # should be default for secure migrations as a ssh TCP forward
5448 # tunnel is not deterministic reliable ready and fails regurarly
5449 # to set up in time, so use UNIX socket forwards
5450 my $socket_addr = "/run/qemu-server/$vmid.migrate";
5451 unlink $socket_addr;
5453 $migrate_uri = "unix:$socket_addr";
5455 push @$cmd, '-incoming
', $migrate_uri;
5459 push @$cmd, '-loadstate
', $statefile;
5466 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
5467 my $d = parse_hostpci($conf->{"hostpci$i"});
5469 my $pcidevices = $d->{pciid};
5470 foreach my $pcidevice (@$pcidevices) {
5471 my $pciid = $pcidevice->{id};
5473 my $info = PVE::SysFSTools::pci_device_info("0000:$pciid");
5474 die "IOMMU not present\n" if !PVE::SysFSTools::check_iommu_support();
5475 die "no pci device info for device '$pciid'\n" if !$info;
5478 my $uuid = PVE::SysFSTools::generate_mdev_uuid($vmid, $i);
5479 PVE::SysFSTools::pci_create_mdev_device($pciid, $uuid, $d->{mdev});
5481 die "can't unbind
/bind pci group to vfio
'$pciid'\n"
5482 if !PVE::SysFSTools::pci_dev_group_bind_to_vfio($pciid);
5483 die "can
't reset pci device '$pciid'\n"
5484 if $info->{has_fl_reset} and !PVE::SysFSTools::pci_dev_reset($info);
5489 PVE::Storage::activate_volumes($storecfg, $vollist);
5492 run_command(['/bin/systemctl
', 'stop
', "$vmid.scope"],
5493 outfunc => sub {}, errfunc => sub {});
5495 # Issues with the above 'stop
' not being fully completed are extremely rare, a very low
5496 # timeout should be more than enough here...
5497 PVE::Systemd::wait_for_unit_removed("$vmid.scope", 5);
5499 my $cpuunits = defined($conf->{cpuunits}) ? $conf->{cpuunits}
5500 : $defaults->{cpuunits};
5502 my $start_timeout = ($conf->{hugepages} || $is_suspended) ? 300 : 30;
5503 my %run_params = (timeout => $statefile ? undef : $start_timeout, umask => 0077);
5506 Slice => 'qemu
.slice
',
5508 CPUShares => $cpuunits
5511 if (my $cpulimit = $conf->{cpulimit}) {
5512 $properties{CPUQuota} = int($cpulimit * 100);
5514 $properties{timeout} = 10 if $statefile; # setting up the scope shoul be quick
5516 my $run_qemu = sub {
5517 PVE::Tools::run_fork sub {
5518 PVE::Systemd::enter_systemd_scope($vmid, "Proxmox VE VM $vmid", %properties);
5519 run_command($cmd, %run_params);
5523 if ($conf->{hugepages}) {
5526 my $hugepages_topology = PVE::QemuServer::Memory::hugepages_topology($conf);
5527 my $hugepages_host_topology = PVE::QemuServer::Memory::hugepages_host_topology();
5529 PVE::QemuServer::Memory::hugepages_mount();
5530 PVE::QemuServer::Memory::hugepages_allocate($hugepages_topology, $hugepages_host_topology);
5532 eval { $run_qemu->() };
5534 PVE::QemuServer::Memory::hugepages_reset($hugepages_host_topology);
5538 PVE::QemuServer::Memory::hugepages_pre_deallocate($hugepages_topology);
5540 eval { PVE::QemuServer::Memory::hugepages_update_locked($code); };
5543 eval { $run_qemu->() };
5547 # deactivate volumes if start fails
5548 eval { PVE::Storage::deactivate_volumes($storecfg, $vollist); };
5549 die "start failed: $err";
5552 print "migration listens on $migrate_uri\n" if $migrate_uri;
5554 if ($statefile && $statefile ne 'tcp
' && $statefile ne 'unix
') {
5555 eval { vm_mon_cmd_nocheck($vmid, "cont"); };
5559 #start nbd server for storage migration
5560 if ($targetstorage) {
5561 my $nodename = PVE::INotify::nodename();
5562 my $migrate_network_addr = PVE::Cluster::get_local_migration_ip($migration_network);
5563 my $localip = $migrate_network_addr ? $migrate_network_addr : PVE::Cluster::remote_node_ip($nodename, 1);
5564 my $pfamily = PVE::Tools::get_host_address_family($nodename);
5565 $migrate_port = PVE::Tools::next_migrate_port($pfamily);
5567 vm_mon_cmd_nocheck($vmid, "nbd-server-start", addr => { type => 'inet
', data => { host => "${localip}", port => "${migrate_port}" } } );
5569 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
5571 foreach my $opt (sort keys %$local_volumes) {
5572 my $volid = $local_volumes->{$opt};
5573 vm_mon_cmd_nocheck($vmid, "nbd-server-add", device => "drive-$opt", writable => JSON::true );
5574 my $migrate_storage_uri = "nbd:${localip}:${migrate_port}:exportname=drive-$opt";
5575 print "storage migration listens on $migrate_storage_uri volume:$volid\n";
5579 if ($migratedfrom) {
5581 set_migration_caps($vmid);
5586 print "spice listens on port $spice_port\n";
5587 if ($spice_ticket) {
5588 vm_mon_cmd_nocheck($vmid, "set_password", protocol => 'spice
', password => $spice_ticket);
5589 vm_mon_cmd_nocheck($vmid, "expire_password", protocol => 'spice
', time => "+30");
5594 vm_mon_cmd_nocheck($vmid, "balloon", value => $conf->{balloon}*1024*1024)
5595 if !$statefile && $conf->{balloon};
5597 foreach my $opt (keys %$conf) {
5598 next if $opt !~ m/^net\d+$/;
5599 my $nicconf = parse_net($conf->{$opt});
5600 qemu_set_link_status($vmid, $opt, 0) if $nicconf->{link_down};
5604 vm_mon_cmd_nocheck($vmid, 'qom-set
',
5605 path => "machine/peripheral/balloon0",
5606 property => "guest-stats-polling-interval",
5607 value => 2) if (!defined($conf->{balloon}) || $conf->{balloon});
5609 if ($is_suspended && (my $vmstate = $conf->{vmstate})) {
5610 print "Resumed VM, removing state\n";
5611 delete $conf->@{qw(lock vmstate runningmachine)};
5612 PVE
::Storage
::deactivate_volumes
($storecfg, [$vmstate]);
5613 PVE
::Storage
::vdisk_free
($storecfg, $vmstate);
5614 PVE
::QemuConfig-
>write_config($vmid, $conf);
5617 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'post-start');
5622 my ($vmid, $execute, %params) = @_;
5624 my $cmd = { execute
=> $execute, arguments
=> \
%params };
5625 vm_qmp_command
($vmid, $cmd);
5628 sub vm_mon_cmd_nocheck
{
5629 my ($vmid, $execute, %params) = @_;
5631 my $cmd = { execute
=> $execute, arguments
=> \
%params };
5632 vm_qmp_command
($vmid, $cmd, 1);
5635 sub vm_qmp_command
{
5636 my ($vmid, $cmd, $nocheck) = @_;
5641 if ($cmd->{arguments
}) {
5642 $timeout = delete $cmd->{arguments
}->{timeout
};
5646 die "VM $vmid not running\n" if !check_running
($vmid, $nocheck);
5647 my $sname = qmp_socket
($vmid);
5648 if (-e
$sname) { # test if VM is reasonambe new and supports qmp/qga
5649 my $qmpclient = PVE
::QMPClient-
>new();
5651 $res = $qmpclient->cmd($vmid, $cmd, $timeout);
5653 die "unable to open monitor socket\n";
5657 syslog
("err", "VM $vmid qmp command failed - $err");
5664 sub vm_human_monitor_command
{
5665 my ($vmid, $cmdline) = @_;
5668 execute
=> 'human-monitor-command',
5669 arguments
=> { 'command-line' => $cmdline},
5672 return vm_qmp_command
($vmid, $cmd);
5675 sub vm_commandline
{
5676 my ($storecfg, $vmid, $snapname) = @_;
5678 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5681 my $snapshot = $conf->{snapshots
}->{$snapname};
5682 die "snapshot '$snapname' does not exist\n" if !defined($snapshot);
5684 $snapshot->{digest
} = $conf->{digest
}; # keep file digest for API
5689 my $defaults = load_defaults
();
5691 my $cmd = config_to_command
($storecfg, $vmid, $conf, $defaults);
5693 return PVE
::Tools
::cmd2string
($cmd);
5697 my ($vmid, $skiplock) = @_;
5699 PVE
::QemuConfig-
>lock_config($vmid, sub {
5701 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5703 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5705 vm_mon_cmd
($vmid, "system_reset");
5709 sub get_vm_volumes
{
5713 foreach_volid
($conf, sub {
5714 my ($volid, $attr) = @_;
5716 return if $volid =~ m
|^/|;
5718 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
5721 push @$vollist, $volid;
5727 sub vm_stop_cleanup
{
5728 my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
5733 my $vollist = get_vm_volumes
($conf);
5734 PVE
::Storage
::deactivate_volumes
($storecfg, $vollist);
5737 foreach my $ext (qw(mon qmp pid vnc qga)) {
5738 unlink "/var/run/qemu-server/${vmid}.$ext";
5741 if ($conf->{ivshmem
}) {
5742 my $ivshmem = PVE
::JSONSchema
::parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
5743 # just delete it for now, VMs which have this already open do not
5744 # are affected, but new VMs will get a separated one. If this
5745 # becomes an issue we either add some sort of ref-counting or just
5746 # add a "don't delete on stop" flag to the ivshmem format.
5747 unlink '/dev/shm/pve-shm-' . ($ivshmem->{name
} // $vmid);
5750 foreach my $key (keys %$conf) {
5751 next if $key !~ m/^hostpci(\d+)$/;
5752 my $hostpciindex = $1;
5753 my $d = parse_hostpci
($conf->{$key});
5754 my $uuid = PVE
::SysFSTools
::generate_mdev_uuid
($vmid, $hostpciindex);
5756 foreach my $pci (@{$d->{pciid
}}) {
5757 my $pciid = $pci->{id
};
5758 PVE
::SysFSTools
::pci_cleanup_mdev_device
($pciid, $uuid);
5762 vmconfig_apply_pending
($vmid, $conf, $storecfg) if $apply_pending_changes;
5764 warn $@ if $@; # avoid errors - just warn
5767 # Note: use $nockeck to skip tests if VM configuration file exists.
5768 # We need that when migration VMs to other nodes (files already moved)
5769 # Note: we set $keepActive in vzdump stop mode - volumes need to stay active
5771 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
5773 $force = 1 if !defined($force) && !$shutdown;
5776 my $pid = check_running
($vmid, $nocheck, $migratedfrom);
5777 kill 15, $pid if $pid;
5778 my $conf = PVE
::QemuConfig-
>load_config($vmid, $migratedfrom);
5779 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 0);
5783 PVE
::QemuConfig-
>lock_config($vmid, sub {
5785 my $pid = check_running
($vmid, $nocheck);
5790 $conf = PVE
::QemuConfig-
>load_config($vmid);
5791 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5792 if (!defined($timeout) && $shutdown && $conf->{startup
}) {
5793 my $opts = PVE
::JSONSchema
::pve_parse_startup_order
($conf->{startup
});
5794 $timeout = $opts->{down
} if $opts->{down
};
5796 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'pre-stop');
5801 if (defined($conf) && parse_guest_agent
($conf)->{enabled
}) {
5802 vm_qmp_command
($vmid, {
5803 execute
=> "guest-shutdown",
5804 arguments
=> { timeout
=> $timeout }
5807 vm_qmp_command
($vmid, { execute
=> "system_powerdown" }, $nocheck);
5810 vm_qmp_command
($vmid, { execute
=> "quit" }, $nocheck);
5816 $timeout = 60 if !defined($timeout);
5819 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5824 if ($count >= $timeout) {
5826 warn "VM still running - terminating now with SIGTERM\n";
5829 die "VM quit/powerdown failed - got timeout\n";
5832 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5837 warn "VM quit/powerdown failed - terminating now with SIGTERM\n";
5840 die "VM quit/powerdown failed\n";
5848 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5853 if ($count >= $timeout) {
5854 warn "VM still running - terminating now with SIGKILL\n";
5859 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5864 my ($vmid, $skiplock, $includestate, $statestorage) = @_;
5871 PVE
::QemuConfig-
>lock_config($vmid, sub {
5873 $conf = PVE
::QemuConfig-
>load_config($vmid);
5875 my $is_backing_up = PVE
::QemuConfig-
>has_lock($conf, 'backup');
5876 PVE
::QemuConfig-
>check_lock($conf)
5877 if !($skiplock || $is_backing_up);
5879 die "cannot suspend to disk during backup\n"
5880 if $is_backing_up && $includestate;
5882 if ($includestate) {
5883 $conf->{lock} = 'suspending';
5884 my $date = strftime
("%Y-%m-%d", localtime(time()));
5885 $storecfg = PVE
::Storage
::config
();
5886 $vmstate = PVE
::QemuConfig-
>__snapshot_save_vmstate($vmid, $conf, "suspend-$date", $storecfg, $statestorage, 1);
5887 $path = PVE
::Storage
::path
($storecfg, $vmstate);
5888 PVE
::QemuConfig-
>write_config($vmid, $conf);
5890 vm_mon_cmd
($vmid, "stop");
5894 if ($includestate) {
5896 PVE
::Storage
::activate_volumes
($storecfg, [$vmstate]);
5899 vm_mon_cmd
($vmid, "savevm-start", statefile
=> $path);
5901 my $state = vm_mon_cmd_nocheck
($vmid, "query-savevm");
5902 if (!$state->{status
}) {
5903 die "savevm not active\n";
5904 } elsif ($state->{status
} eq 'active') {
5907 } elsif ($state->{status
} eq 'completed') {
5908 print "State saved, quitting\n";
5910 } elsif ($state->{status
} eq 'failed' && $state->{error
}) {
5911 die "query-savevm failed with error '$state->{error}'\n"
5913 die "query-savevm returned status '$state->{status}'\n";
5919 PVE
::QemuConfig-
>lock_config($vmid, sub {
5920 $conf = PVE
::QemuConfig-
>load_config($vmid);
5922 # cleanup, but leave suspending lock, to indicate something went wrong
5924 vm_mon_cmd
($vmid, "savevm-end");
5925 PVE
::Storage
::deactivate_volumes
($storecfg, [$vmstate]);
5926 PVE
::Storage
::vdisk_free
($storecfg, $vmstate);
5927 delete $conf->@{qw(vmstate runningmachine)};
5928 PVE
::QemuConfig-
>write_config($vmid, $conf);
5934 die "lock changed unexpectedly\n"
5935 if !PVE
::QemuConfig-
>has_lock($conf, 'suspending');
5937 vm_qmp_command
($vmid, { execute
=> "quit" });
5938 $conf->{lock} = 'suspended';
5939 PVE
::QemuConfig-
>write_config($vmid, $conf);
5945 my ($vmid, $skiplock, $nocheck) = @_;
5947 PVE
::QemuConfig-
>lock_config($vmid, sub {
5948 my $vm_mon_cmd = $nocheck ? \
&vm_mon_cmd_nocheck
: \
&vm_mon_cmd
;
5949 my $res = $vm_mon_cmd->($vmid, 'query-status');
5950 my $resume_cmd = 'cont';
5952 if ($res->{status
} && $res->{status
} eq 'suspended') {
5953 $resume_cmd = 'system_wakeup';
5958 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5960 PVE
::QemuConfig-
>check_lock($conf)
5961 if !($skiplock || PVE
::QemuConfig-
>has_lock($conf, 'backup'));
5964 $vm_mon_cmd->($vmid, $resume_cmd);
5969 my ($vmid, $skiplock, $key) = @_;
5971 PVE
::QemuConfig-
>lock_config($vmid, sub {
5973 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5975 # there is no qmp command, so we use the human monitor command
5976 my $res = vm_human_monitor_command
($vmid, "sendkey $key");
5977 die $res if $res ne '';
5982 my ($storecfg, $vmid, $skiplock) = @_;
5984 PVE
::QemuConfig-
>lock_config($vmid, sub {
5986 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5988 if (!check_running
($vmid)) {
5989 destroy_vm
($storecfg, $vmid, undef, $skiplock);
5991 die "VM $vmid is running - destroy failed\n";
5996 # vzdump restore implementaion
5998 sub tar_archive_read_firstfile
{
5999 my $archive = shift;
6001 die "ERROR: file '$archive' does not exist\n" if ! -f
$archive;
6003 # try to detect archive type first
6004 my $pid = open (my $fh, '-|', 'tar', 'tf', $archive) ||
6005 die "unable to open file '$archive'\n";
6006 my $firstfile = <$fh>;
6010 die "ERROR: archive contaions no data\n" if !$firstfile;
6016 sub tar_restore_cleanup
{
6017 my ($storecfg, $statfile) = @_;
6019 print STDERR
"starting cleanup\n";
6021 if (my $fd = IO
::File-
>new($statfile, "r")) {
6022 while (defined(my $line = <$fd>)) {
6023 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
6026 if ($volid =~ m
|^/|) {
6027 unlink $volid || die 'unlink failed\n';
6029 PVE
::Storage
::vdisk_free
($storecfg, $volid);
6031 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
6033 print STDERR
"unable to cleanup '$volid' - $@" if $@;
6035 print STDERR
"unable to parse line in statfile - $line";
6042 sub restore_archive
{
6043 my ($archive, $vmid, $user, $opts) = @_;
6045 my $format = $opts->{format
};
6048 if ($archive =~ m/\.tgz$/ || $archive =~ m/\.tar\.gz$/) {
6049 $format = 'tar' if !$format;
6051 } elsif ($archive =~ m/\.tar$/) {
6052 $format = 'tar' if !$format;
6053 } elsif ($archive =~ m/.tar.lzo$/) {
6054 $format = 'tar' if !$format;
6056 } elsif ($archive =~ m/\.vma$/) {
6057 $format = 'vma' if !$format;
6058 } elsif ($archive =~ m/\.vma\.gz$/) {
6059 $format = 'vma' if !$format;
6061 } elsif ($archive =~ m/\.vma\.lzo$/) {
6062 $format = 'vma' if !$format;
6065 $format = 'vma' if !$format; # default
6068 # try to detect archive format
6069 if ($format eq 'tar') {
6070 return restore_tar_archive
($archive, $vmid, $user, $opts);
6072 return restore_vma_archive
($archive, $vmid, $user, $opts, $comp);
6076 sub restore_update_config_line
{
6077 my ($outfd, $cookie, $vmid, $map, $line, $unique) = @_;
6079 return if $line =~ m/^\#qmdump\#/;
6080 return if $line =~ m/^\#vzdump\#/;
6081 return if $line =~ m/^lock:/;
6082 return if $line =~ m/^unused\d+:/;
6083 return if $line =~ m/^parent:/;
6085 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
6086 if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
6087 # try to convert old 1.X settings
6088 my ($id, $ind, $ethcfg) = ($1, $2, $3);
6089 foreach my $devconfig (PVE
::Tools
::split_list
($ethcfg)) {
6090 my ($model, $macaddr) = split(/\=/, $devconfig);
6091 $macaddr = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if !$macaddr || $unique;
6094 bridge
=> "vmbr$ind",
6095 macaddr
=> $macaddr,
6097 my $netstr = print_net
($net);
6099 print $outfd "net$cookie->{netcount}: $netstr\n";
6100 $cookie->{netcount
}++;
6102 } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && $unique) {
6103 my ($id, $netstr) = ($1, $2);
6104 my $net = parse_net
($netstr);
6105 $net->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if $net->{macaddr
};
6106 $netstr = print_net
($net);
6107 print $outfd "$id: $netstr\n";
6108 } elsif ($line =~ m/^((ide|scsi|virtio|sata|efidisk)\d+):\s*(\S+)\s*$/) {
6111 my $di = parse_drive
($virtdev, $value);
6112 if (defined($di->{backup
}) && !$di->{backup
}) {
6113 print $outfd "#$line";
6114 } elsif ($map->{$virtdev}) {
6115 delete $di->{format
}; # format can change on restore
6116 $di->{file
} = $map->{$virtdev};
6117 $value = print_drive
($vmid, $di);
6118 print $outfd "$virtdev: $value\n";
6122 } elsif (($line =~ m/^vmgenid: (.*)/)) {
6124 if ($vmgenid ne '0') {
6125 # always generate a new vmgenid if there was a valid one setup
6126 $vmgenid = generate_uuid
();
6128 print $outfd "vmgenid: $vmgenid\n";
6129 } elsif (($line =~ m/^(smbios1: )(.*)/) && $unique) {
6130 my ($uuid, $uuid_str);
6131 UUID
::generate
($uuid);
6132 UUID
::unparse
($uuid, $uuid_str);
6133 my $smbios1 = parse_smbios1
($2);
6134 $smbios1->{uuid
} = $uuid_str;
6135 print $outfd $1.print_smbios1
($smbios1)."\n";
6142 my ($cfg, $vmid) = @_;
6144 my $info = PVE
::Storage
::vdisk_list
($cfg, undef, $vmid);
6146 my $volid_hash = {};
6147 foreach my $storeid (keys %$info) {
6148 foreach my $item (@{$info->{$storeid}}) {
6149 next if !($item->{volid
} && $item->{size
});
6150 $item->{path
} = PVE
::Storage
::path
($cfg, $item->{volid
});
6151 $volid_hash->{$item->{volid
}} = $item;
6158 sub is_volume_in_use
{
6159 my ($storecfg, $conf, $skip_drive, $volid) = @_;
6161 my $path = PVE
::Storage
::path
($storecfg, $volid);
6163 my $scan_config = sub {
6164 my ($cref, $snapname) = @_;
6166 foreach my $key (keys %$cref) {
6167 my $value = $cref->{$key};
6168 if (is_valid_drivename
($key)) {
6169 next if $skip_drive && $key eq $skip_drive;
6170 my $drive = parse_drive
($key, $value);
6171 next if !$drive || !$drive->{file
} || drive_is_cdrom
($drive);
6172 return 1 if $volid eq $drive->{file
};
6173 if ($drive->{file
} =~ m!^/!) {
6174 return 1 if $drive->{file
} eq $path;
6176 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
}, 1);
6178 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid, 1);
6180 return 1 if $path eq PVE
::Storage
::path
($storecfg, $drive->{file
}, $snapname);
6188 return 1 if &$scan_config($conf);
6192 foreach my $snapname (keys %{$conf->{snapshots
}}) {
6193 return 1 if &$scan_config($conf->{snapshots
}->{$snapname}, $snapname);
6199 sub update_disksize
{
6200 my ($vmid, $conf, $volid_hash) = @_;
6203 my $prefix = "VM $vmid:";
6205 # used and unused disks
6206 my $referenced = {};
6208 # Note: it is allowed to define multiple storages with same path (alias), so
6209 # we need to check both 'volid' and real 'path' (two different volid can point
6210 # to the same path).
6212 my $referencedpath = {};
6215 foreach my $opt (keys %$conf) {
6216 if (is_valid_drivename
($opt)) {
6217 my $drive = parse_drive
($opt, $conf->{$opt});
6218 my $volid = $drive->{file
};
6221 $referenced->{$volid} = 1;
6222 if ($volid_hash->{$volid} &&
6223 (my $path = $volid_hash->{$volid}->{path
})) {
6224 $referencedpath->{$path} = 1;
6227 next if drive_is_cdrom
($drive);
6228 next if !$volid_hash->{$volid};
6230 $drive->{size
} = $volid_hash->{$volid}->{size
};
6231 my $new = print_drive
($vmid, $drive);
6232 if ($new ne $conf->{$opt}) {
6234 $conf->{$opt} = $new;
6235 print "$prefix update disk '$opt' information.\n";
6240 # remove 'unusedX' entry if volume is used
6241 foreach my $opt (keys %$conf) {
6242 next if $opt !~ m/^unused\d+$/;
6243 my $volid = $conf->{$opt};
6244 my $path = $volid_hash->{$volid}->{path
} if $volid_hash->{$volid};
6245 if ($referenced->{$volid} || ($path && $referencedpath->{$path})) {
6246 print "$prefix remove entry '$opt', its volume '$volid' is in use.\n";
6248 delete $conf->{$opt};
6251 $referenced->{$volid} = 1;
6252 $referencedpath->{$path} = 1 if $path;
6255 foreach my $volid (sort keys %$volid_hash) {
6256 next if $volid =~ m/vm-$vmid-state-/;
6257 next if $referenced->{$volid};
6258 my $path = $volid_hash->{$volid}->{path
};
6259 next if !$path; # just to be sure
6260 next if $referencedpath->{$path};
6262 my $key = PVE
::QemuConfig-
>add_unused_volume($conf, $volid);
6263 print "$prefix add unreferenced volume '$volid' as '$key' to config.\n";
6264 $referencedpath->{$path} = 1; # avoid to add more than once (aliases)
6271 my ($vmid, $nolock, $dryrun) = @_;
6273 my $cfg = PVE
::Storage
::config
();
6275 # FIXME: Remove once our RBD plugin can handle CT and VM on a single storage
6276 # see: https://pve.proxmox.com/pipermail/pve-devel/2018-July/032900.html
6277 foreach my $stor (keys %{$cfg->{ids
}}) {
6278 delete($cfg->{ids
}->{$stor}) if ! $cfg->{ids
}->{$stor}->{content
}->{images
};
6281 print "rescan volumes...\n";
6282 my $volid_hash = scan_volids
($cfg, $vmid);
6284 my $updatefn = sub {
6287 my $conf = PVE
::QemuConfig-
>load_config($vmid);
6289 PVE
::QemuConfig-
>check_lock($conf);
6292 foreach my $volid (keys %$volid_hash) {
6293 my $info = $volid_hash->{$volid};
6294 $vm_volids->{$volid} = $info if $info->{vmid
} && $info->{vmid
} == $vmid;
6297 my $changes = update_disksize
($vmid, $conf, $vm_volids);
6299 PVE
::QemuConfig-
>write_config($vmid, $conf) if $changes && !$dryrun;
6302 if (defined($vmid)) {
6306 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
6309 my $vmlist = config_list
();
6310 foreach my $vmid (keys %$vmlist) {
6314 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
6320 sub restore_vma_archive
{
6321 my ($archive, $vmid, $user, $opts, $comp) = @_;
6323 my $readfrom = $archive;
6325 my $cfg = PVE
::Storage
::config
();
6327 my $bwlimit = $opts->{bwlimit
};
6329 my $dbg_cmdstring = '';
6330 my $add_pipe = sub {
6332 push @$commands, $cmd;
6333 $dbg_cmdstring .= ' | ' if length($dbg_cmdstring);
6334 $dbg_cmdstring .= PVE
::Tools
::cmd2string
($cmd);
6339 if ($archive eq '-') {
6342 # If we use a backup from a PVE defined storage we also consider that
6343 # storage's rate limit:
6344 my (undef, $volid) = PVE
::Storage
::path_to_volume_id
($cfg, $archive);
6345 if (defined($volid)) {
6346 my ($sid, undef) = PVE
::Storage
::parse_volume_id
($volid);
6347 my $readlimit = PVE
::Storage
::get_bandwidth_limit
('restore', [$sid], $bwlimit);
6349 print STDERR
"applying read rate limit: $readlimit\n";
6350 my $cstream = ['cstream', '-t', $readlimit*1024, '--', $readfrom];
6351 $add_pipe->($cstream);
6358 if ($comp eq 'gzip') {
6359 $cmd = ['zcat', $readfrom];
6360 } elsif ($comp eq 'lzop') {
6361 $cmd = ['lzop', '-d', '-c', $readfrom];
6363 die "unknown compression method '$comp'\n";
6368 my $tmpdir = "/var/tmp/vzdumptmp$$";
6371 # disable interrupts (always do cleanups)
6375 local $SIG{HUP
} = sub { warn "got interrupt - ignored\n"; };
6377 my $mapfifo = "/var/tmp/vzdumptmp$$.fifo";
6378 POSIX
::mkfifo
($mapfifo, 0600);
6381 my $openfifo = sub {
6382 open($fifofh, '>', $mapfifo) || die $!;
6385 $add_pipe->(['vma', 'extract', '-v', '-r', $mapfifo, $readfrom, $tmpdir]);
6392 my $rpcenv = PVE
::RPCEnvironment
::get
();
6394 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6395 my $tmpfn = "$conffile.$$.tmp";
6397 # Note: $oldconf is undef if VM does not exists
6398 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
6399 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
6403 my $print_devmap = sub {
6404 my $virtdev_hash = {};
6406 my $cfgfn = "$tmpdir/qemu-server.conf";
6408 # we can read the config - that is already extracted
6409 my $fh = IO
::File-
>new($cfgfn, "r") ||
6410 "unable to read qemu-server.conf - $!\n";
6412 my $fwcfgfn = "$tmpdir/qemu-server.fw";
6414 my $pve_firewall_dir = '/etc/pve/firewall';
6415 mkdir $pve_firewall_dir; # make sure the dir exists
6416 PVE
::Tools
::file_copy
($fwcfgfn, "${pve_firewall_dir}/$vmid.fw");
6419 while (defined(my $line = <$fh>)) {
6420 if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
6421 my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
6422 die "archive does not contain data for drive '$virtdev'\n"
6423 if !$devinfo->{$devname};
6424 if (defined($opts->{storage
})) {
6425 $storeid = $opts->{storage
} || 'local';
6426 } elsif (!$storeid) {
6429 $format = 'raw' if !$format;
6430 $devinfo->{$devname}->{devname
} = $devname;
6431 $devinfo->{$devname}->{virtdev
} = $virtdev;
6432 $devinfo->{$devname}->{format
} = $format;
6433 $devinfo->{$devname}->{storeid
} = $storeid;
6435 # check permission on storage
6436 my $pool = $opts->{pool
}; # todo: do we need that?
6437 if ($user ne 'root@pam') {
6438 $rpcenv->check($user, "/storage/$storeid", ['Datastore.AllocateSpace']);
6441 $storage_limits{$storeid} = $bwlimit;
6443 $virtdev_hash->{$virtdev} = $devinfo->{$devname};
6444 } elsif ($line =~ m/^((?:ide|sata|scsi)\d+):\s*(.*)\s*$/) {
6446 my $drive = parse_drive
($virtdev, $2);
6447 if (drive_is_cloudinit
($drive)) {
6448 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
6449 my $scfg = PVE
::Storage
::storage_config
($cfg, $storeid);
6450 my $format = qemu_img_format
($scfg, $volname); # has 'raw' fallback
6454 storeid
=> $opts->{storage
} // $storeid,
6455 size
=> PVE
::QemuServer
::Cloudinit
::CLOUDINIT_DISK_SIZE
,
6456 file
=> $drive->{file
}, # to make drive_is_cloudinit check possible
6457 name
=> "vm-$vmid-cloudinit",
6460 $virtdev_hash->{$virtdev} = $d;
6465 foreach my $key (keys %storage_limits) {
6466 my $limit = PVE
::Storage
::get_bandwidth_limit
('restore', [$key], $bwlimit);
6468 print STDERR
"rate limit for storage $key: $limit KiB/s\n";
6469 $storage_limits{$key} = $limit * 1024;
6472 foreach my $devname (keys %$devinfo) {
6473 die "found no device mapping information for device '$devname'\n"
6474 if !$devinfo->{$devname}->{virtdev
};
6477 # create empty/temp config
6479 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
6480 foreach_drive
($oldconf, sub {
6481 my ($ds, $drive) = @_;
6483 return if !$drive->{is_cloudinit
} && drive_is_cdrom
($drive);
6485 my $volid = $drive->{file
};
6486 return if !$volid || $volid =~ m
|^/|;
6488 my ($path, $owner) = PVE
::Storage
::path
($cfg, $volid);
6489 return if !$path || !$owner || ($owner != $vmid);
6491 # Note: only delete disk we want to restore
6492 # other volumes will become unused
6493 if ($virtdev_hash->{$ds}) {
6494 eval { PVE
::Storage
::vdisk_free
($cfg, $volid); };
6501 # delete vmstate files, after the restore we have no snapshots anymore
6502 foreach my $snapname (keys %{$oldconf->{snapshots
}}) {
6503 my $snap = $oldconf->{snapshots
}->{$snapname};
6504 if ($snap->{vmstate
}) {
6505 eval { PVE
::Storage
::vdisk_free
($cfg, $snap->{vmstate
}); };
6514 foreach my $virtdev (sort keys %$virtdev_hash) {
6515 my $d = $virtdev_hash->{$virtdev};
6516 my $alloc_size = int(($d->{size
} + 1024 - 1)/1024);
6517 my $storeid = $d->{storeid
};
6518 my $scfg = PVE
::Storage
::storage_config
($cfg, $storeid);
6521 if (my $limit = $storage_limits{$storeid}) {
6522 $map_opts .= "throttling.bps=$limit:throttling.group=$storeid:";
6525 # test if requested format is supported
6526 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($cfg, $storeid);
6527 my $supported = grep { $_ eq $d->{format
} } @$validFormats;
6528 $d->{format
} = $defFormat if !$supported;
6531 if ($d->{is_cloudinit
}) {
6533 $name .= ".$d->{format}" if $d->{format
} ne 'raw';
6536 my $volid = PVE
::Storage
::vdisk_alloc
($cfg, $storeid, $vmid, $d->{format
}, $name, $alloc_size);
6537 print STDERR
"new volume ID is '$volid'\n";
6538 $d->{volid
} = $volid;
6540 PVE
::Storage
::activate_volumes
($cfg, [$volid]);
6542 my $write_zeros = 1;
6543 if (PVE
::Storage
::volume_has_feature
($cfg, 'sparseinit', $volid)) {
6547 if (!$d->{is_cloudinit
}) {
6548 my $path = PVE
::Storage
::path
($cfg, $volid);
6550 print $fifofh "${map_opts}format=$d->{format}:${write_zeros}:$d->{devname}=$path\n";
6552 print "map '$d->{devname}' to '$path' (write zeros = ${write_zeros})\n";
6554 $map->{$virtdev} = $volid;
6557 $fh->seek(0, 0) || die "seek failed - $!\n";
6559 my $outfd = new IO
::File
($tmpfn, "w") ||
6560 die "unable to write config for VM $vmid\n";
6562 my $cookie = { netcount
=> 0 };
6563 while (defined(my $line = <$fh>)) {
6564 restore_update_config_line
($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
6577 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6578 local $SIG{ALRM
} = sub { die "got timeout\n"; };
6580 $oldtimeout = alarm($timeout);
6587 if ($line =~ m/^DEV:\sdev_id=(\d+)\ssize:\s(\d+)\sdevname:\s(\S+)$/) {
6588 my ($dev_id, $size, $devname) = ($1, $2, $3);
6589 $devinfo->{$devname} = { size
=> $size, dev_id
=> $dev_id };
6590 } elsif ($line =~ m/^CTIME: /) {
6591 # we correctly received the vma config, so we can disable
6592 # the timeout now for disk allocation (set to 10 minutes, so
6593 # that we always timeout if something goes wrong)
6596 print $fifofh "done\n";
6597 my $tmp = $oldtimeout || 0;
6598 $oldtimeout = undef;
6604 print "restore vma archive: $dbg_cmdstring\n";
6605 run_command
($commands, input
=> $input, outfunc
=> $parser, afterfork
=> $openfifo);
6609 alarm($oldtimeout) if $oldtimeout;
6612 foreach my $devname (keys %$devinfo) {
6613 my $volid = $devinfo->{$devname}->{volid
};
6614 push @$vollist, $volid if $volid;
6617 PVE
::Storage
::deactivate_volumes
($cfg, $vollist);
6625 foreach my $devname (keys %$devinfo) {
6626 my $volid = $devinfo->{$devname}->{volid
};
6629 if ($volid =~ m
|^/|) {
6630 unlink $volid || die 'unlink failed\n';
6632 PVE
::Storage
::vdisk_free
($cfg, $volid);
6634 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
6636 print STDERR
"unable to cleanup '$volid' - $@" if $@;
6643 rename($tmpfn, $conffile) ||
6644 die "unable to commit configuration file '$conffile'\n";
6646 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6648 eval { rescan
($vmid, 1); };
6652 sub restore_tar_archive
{
6653 my ($archive, $vmid, $user, $opts) = @_;
6655 if ($archive ne '-') {
6656 my $firstfile = tar_archive_read_firstfile
($archive);
6657 die "ERROR: file '$archive' dos not lock like a QemuServer vzdump backup\n"
6658 if $firstfile ne 'qemu-server.conf';
6661 my $storecfg = PVE
::Storage
::config
();
6663 # destroy existing data - keep empty config
6664 my $vmcfgfn = PVE
::QemuConfig-
>config_file($vmid);
6665 destroy_vm
($storecfg, $vmid, 1) if -f
$vmcfgfn;
6667 my $tocmd = "/usr/lib/qemu-server/qmextract";
6669 $tocmd .= " --storage " . PVE
::Tools
::shellquote
($opts->{storage
}) if $opts->{storage
};
6670 $tocmd .= " --pool " . PVE
::Tools
::shellquote
($opts->{pool
}) if $opts->{pool
};
6671 $tocmd .= ' --prealloc' if $opts->{prealloc
};
6672 $tocmd .= ' --info' if $opts->{info
};
6674 # tar option "xf" does not autodetect compression when read from STDIN,
6675 # so we pipe to zcat
6676 my $cmd = "zcat -f|tar xf " . PVE
::Tools
::shellquote
($archive) . " " .
6677 PVE
::Tools
::shellquote
("--to-command=$tocmd");
6679 my $tmpdir = "/var/tmp/vzdumptmp$$";
6682 local $ENV{VZDUMP_TMPDIR
} = $tmpdir;
6683 local $ENV{VZDUMP_VMID
} = $vmid;
6684 local $ENV{VZDUMP_USER
} = $user;
6686 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6687 my $tmpfn = "$conffile.$$.tmp";
6689 # disable interrupts (always do cleanups)
6693 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
6701 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6703 if ($archive eq '-') {
6704 print "extracting archive from STDIN\n";
6705 run_command
($cmd, input
=> "<&STDIN");
6707 print "extracting archive '$archive'\n";
6711 return if $opts->{info
};
6715 my $statfile = "$tmpdir/qmrestore.stat";
6716 if (my $fd = IO
::File-
>new($statfile, "r")) {
6717 while (defined (my $line = <$fd>)) {
6718 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
6719 $map->{$1} = $2 if $1;
6721 print STDERR
"unable to parse line in statfile - $line\n";
6727 my $confsrc = "$tmpdir/qemu-server.conf";
6729 my $srcfd = new IO
::File
($confsrc, "r") ||
6730 die "unable to open file '$confsrc'\n";
6732 my $outfd = new IO
::File
($tmpfn, "w") ||
6733 die "unable to write config for VM $vmid\n";
6735 my $cookie = { netcount
=> 0 };
6736 while (defined (my $line = <$srcfd>)) {
6737 restore_update_config_line
($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
6749 tar_restore_cleanup
($storecfg, "$tmpdir/qmrestore.stat") if !$opts->{info
};
6756 rename $tmpfn, $conffile ||
6757 die "unable to commit configuration file '$conffile'\n";
6759 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6761 eval { rescan
($vmid, 1); };
6765 sub foreach_storage_used_by_vm
{
6766 my ($conf, $func) = @_;
6770 foreach_drive
($conf, sub {
6771 my ($ds, $drive) = @_;
6772 return if drive_is_cdrom
($drive);
6774 my $volid = $drive->{file
};
6776 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
6777 $sidhash->{$sid} = $sid if $sid;
6780 foreach my $sid (sort keys %$sidhash) {
6785 sub do_snapshots_with_qemu
{
6786 my ($storecfg, $volid) = @_;
6788 my $storage_name = PVE
::Storage
::parse_volume_id
($volid);
6789 my $scfg = $storecfg->{ids
}->{$storage_name};
6791 if ($qemu_snap_storage->{$scfg->{type
}} && !$scfg->{krbd
}){
6795 if ($volid =~ m/\.(qcow2|qed)$/){
6802 sub qga_check_running
{
6803 my ($vmid, $nowarn) = @_;
6805 eval { vm_mon_cmd
($vmid, "guest-ping", timeout
=> 3); };
6807 warn "Qemu Guest Agent is not running - $@" if !$nowarn;
6813 sub template_create
{
6814 my ($vmid, $conf, $disk) = @_;
6816 my $storecfg = PVE
::Storage
::config
();
6818 foreach_drive
($conf, sub {
6819 my ($ds, $drive) = @_;
6821 return if drive_is_cdrom
($drive);
6822 return if $disk && $ds ne $disk;
6824 my $volid = $drive->{file
};
6825 return if !PVE
::Storage
::volume_has_feature
($storecfg, 'template', $volid);
6827 my $voliddst = PVE
::Storage
::vdisk_create_base
($storecfg, $volid);
6828 $drive->{file
} = $voliddst;
6829 $conf->{$ds} = print_drive
($vmid, $drive);
6830 PVE
::QemuConfig-
>write_config($vmid, $conf);
6834 sub convert_iscsi_path
{
6837 if ($path =~ m
|^iscsi
://([^/]+)/([^/]+)/(.+)$|) {
6842 my $initiator_name = get_initiator_name
();
6844 return "file.driver=iscsi,file.transport=tcp,file.initiator-name=$initiator_name,".
6845 "file.portal=$portal,file.target=$target,file.lun=$lun,driver=raw";
6848 die "cannot convert iscsi path '$path', unkown format\n";
6851 sub qemu_img_convert
{
6852 my ($src_volid, $dst_volid, $size, $snapname, $is_zero_initialized) = @_;
6854 my $storecfg = PVE
::Storage
::config
();
6855 my ($src_storeid, $src_volname) = PVE
::Storage
::parse_volume_id
($src_volid, 1);
6856 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid, 1);
6858 if ($src_storeid && $dst_storeid) {
6860 PVE
::Storage
::activate_volumes
($storecfg, [$src_volid], $snapname);
6862 my $src_scfg = PVE
::Storage
::storage_config
($storecfg, $src_storeid);
6863 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
6865 my $src_format = qemu_img_format
($src_scfg, $src_volname);
6866 my $dst_format = qemu_img_format
($dst_scfg, $dst_volname);
6868 my $src_path = PVE
::Storage
::path
($storecfg, $src_volid, $snapname);
6869 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
6871 my $src_is_iscsi = ($src_path =~ m
|^iscsi
://|);
6872 my $dst_is_iscsi = ($dst_path =~ m
|^iscsi
://|);
6875 push @$cmd, '/usr/bin/qemu-img', 'convert', '-p', '-n';
6876 push @$cmd, '-l', "snapshot.name=$snapname" if($snapname && $src_format eq "qcow2");
6877 push @$cmd, '-t', 'none' if $dst_scfg->{type
} eq 'zfspool';
6878 push @$cmd, '-T', 'none' if $src_scfg->{type
} eq 'zfspool';
6880 if ($src_is_iscsi) {
6881 push @$cmd, '--image-opts';
6882 $src_path = convert_iscsi_path
($src_path);
6884 push @$cmd, '-f', $src_format;
6887 if ($dst_is_iscsi) {
6888 push @$cmd, '--target-image-opts';
6889 $dst_path = convert_iscsi_path
($dst_path);
6891 push @$cmd, '-O', $dst_format;
6894 push @$cmd, $src_path;
6896 if (!$dst_is_iscsi && $is_zero_initialized) {
6897 push @$cmd, "zeroinit:$dst_path";
6899 push @$cmd, $dst_path;
6904 if($line =~ m/\((\S+)\/100\
%\)/){
6906 my $transferred = int($size * $percent / 100);
6907 my $remaining = $size - $transferred;
6909 print "transferred: $transferred bytes remaining: $remaining bytes total: $size bytes progression: $percent %\n";
6914 eval { run_command
($cmd, timeout
=> undef, outfunc
=> $parser); };
6916 die "copy failed: $err" if $err;
6920 sub qemu_img_format
{
6921 my ($scfg, $volname) = @_;
6923 if ($scfg->{path
} && $volname =~ m/\.($QEMU_FORMAT_RE)$/) {
6930 sub qemu_drive_mirror
{
6931 my ($vmid, $drive, $dst_volid, $vmiddst, $is_zero_initialized, $jobs, $skipcomplete, $qga, $bwlimit) = @_;
6933 $jobs = {} if !$jobs;
6937 $jobs->{"drive-$drive"} = {};
6939 if ($dst_volid =~ /^nbd:/) {
6940 $qemu_target = $dst_volid;
6943 my $storecfg = PVE
::Storage
::config
();
6944 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid);
6946 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
6948 $format = qemu_img_format
($dst_scfg, $dst_volname);
6950 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
6952 $qemu_target = $is_zero_initialized ?
"zeroinit:$dst_path" : $dst_path;
6955 my $opts = { timeout
=> 10, device
=> "drive-$drive", mode
=> "existing", sync
=> "full", target
=> $qemu_target };
6956 $opts->{format
} = $format if $format;
6958 if (defined($bwlimit)) {
6959 $opts->{speed
} = $bwlimit * 1024;
6960 print "drive mirror is starting for drive-$drive with bandwidth limit: ${bwlimit} KB/s\n";
6962 print "drive mirror is starting for drive-$drive\n";
6965 # if a job already runs for this device we get an error, catch it for cleanup
6966 eval { vm_mon_cmd
($vmid, "drive-mirror", %$opts); };
6968 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
6970 die "mirroring error: $err\n";
6973 qemu_drive_mirror_monitor
($vmid, $vmiddst, $jobs, $skipcomplete, $qga);
6976 sub qemu_drive_mirror_monitor
{
6977 my ($vmid, $vmiddst, $jobs, $skipcomplete, $qga) = @_;
6980 my $err_complete = 0;
6983 die "storage migration timed out\n" if $err_complete > 300;
6985 my $stats = vm_mon_cmd
($vmid, "query-block-jobs");
6987 my $running_mirror_jobs = {};
6988 foreach my $stat (@$stats) {
6989 next if $stat->{type
} ne 'mirror';
6990 $running_mirror_jobs->{$stat->{device
}} = $stat;
6993 my $readycounter = 0;
6995 foreach my $job (keys %$jobs) {
6997 if(defined($jobs->{$job}->{complete
}) && !defined($running_mirror_jobs->{$job})) {
6998 print "$job : finished\n";
6999 delete $jobs->{$job};
7003 die "$job: mirroring has been cancelled\n" if !defined($running_mirror_jobs->{$job});
7005 my $busy = $running_mirror_jobs->{$job}->{busy
};
7006 my $ready = $running_mirror_jobs->{$job}->{ready
};
7007 if (my $total = $running_mirror_jobs->{$job}->{len
}) {
7008 my $transferred = $running_mirror_jobs->{$job}->{offset
} || 0;
7009 my $remaining = $total - $transferred;
7010 my $percent = sprintf "%.2f", ($transferred * 100 / $total);
7012 print "$job: transferred: $transferred bytes remaining: $remaining bytes total: $total bytes progression: $percent % busy: $busy ready: $ready \n";
7015 $readycounter++ if $running_mirror_jobs->{$job}->{ready
};
7018 last if scalar(keys %$jobs) == 0;
7020 if ($readycounter == scalar(keys %$jobs)) {
7021 print "all mirroring jobs are ready \n";
7022 last if $skipcomplete; #do the complete later
7024 if ($vmiddst && $vmiddst != $vmid) {
7025 my $agent_running = $qga && qga_check_running
($vmid);
7026 if ($agent_running) {
7027 print "freeze filesystem\n";
7028 eval { PVE
::QemuServer
::vm_mon_cmd
($vmid, "guest-fsfreeze-freeze"); };
7030 print "suspend vm\n";
7031 eval { PVE
::QemuServer
::vm_suspend
($vmid, 1); };
7034 # if we clone a disk for a new target vm, we don't switch the disk
7035 PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs);
7037 if ($agent_running) {
7038 print "unfreeze filesystem\n";
7039 eval { PVE
::QemuServer
::vm_mon_cmd
($vmid, "guest-fsfreeze-thaw"); };
7041 print "resume vm\n";
7042 eval { PVE
::QemuServer
::vm_resume
($vmid, 1, 1); };
7048 foreach my $job (keys %$jobs) {
7049 # try to switch the disk if source and destination are on the same guest
7050 print "$job: Completing block job...\n";
7052 eval { vm_mon_cmd
($vmid, "block-job-complete", device
=> $job) };
7053 if ($@ =~ m/cannot be completed/) {
7054 print "$job: Block job cannot be completed, try again.\n";
7057 print "$job: Completed successfully.\n";
7058 $jobs->{$job}->{complete
} = 1;
7069 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
7070 die "mirroring error: $err";
7075 sub qemu_blockjobs_cancel
{
7076 my ($vmid, $jobs) = @_;
7078 foreach my $job (keys %$jobs) {
7079 print "$job: Cancelling block job\n";
7080 eval { vm_mon_cmd
($vmid, "block-job-cancel", device
=> $job); };
7081 $jobs->{$job}->{cancel
} = 1;
7085 my $stats = vm_mon_cmd
($vmid, "query-block-jobs");
7087 my $running_jobs = {};
7088 foreach my $stat (@$stats) {
7089 $running_jobs->{$stat->{device
}} = $stat;
7092 foreach my $job (keys %$jobs) {
7094 if (defined($jobs->{$job}->{cancel
}) && !defined($running_jobs->{$job})) {
7095 print "$job: Done.\n";
7096 delete $jobs->{$job};
7100 last if scalar(keys %$jobs) == 0;
7107 my ($storecfg, $vmid, $running, $drivename, $drive, $snapname,
7108 $newvmid, $storage, $format, $full, $newvollist, $jobs, $skipcomplete, $qga, $bwlimit) = @_;
7113 print "create linked clone of drive $drivename ($drive->{file})\n";
7114 $newvolid = PVE
::Storage
::vdisk_clone
($storecfg, $drive->{file
}, $newvmid, $snapname);
7115 push @$newvollist, $newvolid;
7118 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
7119 $storeid = $storage if $storage;
7121 my $dst_format = resolve_dst_disk_format
($storecfg, $storeid, $volname, $format);
7122 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $drive->{file
}, 3);
7124 print "create full clone of drive $drivename ($drive->{file})\n";
7126 if (drive_is_cloudinit
($drive)) {
7127 $name = "vm-$newvmid-cloudinit";
7129 # we only get here if it's supported by QEMU_FORMAT_RE, so just accept
7130 if ($dst_format ne 'raw') {
7131 $name .= ".$dst_format";
7134 $newvolid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $newvmid, $dst_format, $name, ($size/1024));
7135 push @$newvollist, $newvolid;
7137 PVE
::Storage
::activate_volumes
($storecfg, [$newvolid]);
7139 my $sparseinit = PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $newvolid);
7140 if (!$running || $snapname) {
7141 # TODO: handle bwlimits
7142 qemu_img_convert
($drive->{file
}, $newvolid, $size, $snapname, $sparseinit);
7145 my $kvmver = get_running_qemu_version
($vmid);
7146 if (!qemu_machine_feature_enabled
(undef, $kvmver, 2, 7)) {
7147 die "drive-mirror with iothread requires qemu version 2.7 or higher\n"
7148 if $drive->{iothread
};
7151 qemu_drive_mirror
($vmid, $drivename, $newvolid, $newvmid, $sparseinit, $jobs, $skipcomplete, $qga, $bwlimit);
7155 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $newvolid, 3);
7158 $disk->{format
} = undef;
7159 $disk->{file
} = $newvolid;
7160 $disk->{size
} = $size;
7165 # this only works if VM is running
7166 sub get_current_qemu_machine
{
7169 my $cmd = { execute
=> 'query-machines', arguments
=> {} };
7170 my $res = vm_qmp_command
($vmid, $cmd);
7172 my ($current, $default);
7173 foreach my $e (@$res) {
7174 $default = $e->{name
} if $e->{'is-default'};
7175 $current = $e->{name
} if $e->{'is-current'};
7178 # fallback to the default machine if current is not supported by qemu
7179 return $current || $default || 'pc';
7182 sub get_running_qemu_version
{
7184 my $cmd = { execute
=> 'query-version', arguments
=> {} };
7185 my $res = vm_qmp_command
($vmid, $cmd);
7186 return "$res->{qemu}->{major}.$res->{qemu}->{minor}";
7189 sub qemu_machine_feature_enabled
{
7190 my ($machine, $kvmver, $version_major, $version_minor) = @_;
7195 if ($machine && $machine =~ m/^((?:pc(-i440fx|-q35)?|virt)-(\d+)\.(\d+))/) {
7197 $current_major = $3;
7198 $current_minor = $4;
7200 } elsif ($kvmver =~ m/^(\d+)\.(\d+)/) {
7202 $current_major = $1;
7203 $current_minor = $2;
7206 return 1 if $current_major > $version_major ||
7207 ($current_major == $version_major &&
7208 $current_minor >= $version_minor);
7211 sub qemu_machine_pxe
{
7212 my ($vmid, $conf) = @_;
7214 my $machine = PVE
::QemuServer
::get_current_qemu_machine
($vmid);
7216 if ($conf->{machine
} && $conf->{machine
} =~ m/\.pxe$/) {
7223 sub qemu_use_old_bios_files
{
7224 my ($machine_type) = @_;
7226 return if !$machine_type;
7228 my $use_old_bios_files = undef;
7230 if ($machine_type =~ m/^(\S+)\.pxe$/) {
7232 $use_old_bios_files = 1;
7234 my $kvmver = kvm_user_version
();
7235 # Note: kvm version < 2.4 use non-efi pxe files, and have problems when we
7236 # load new efi bios files on migration. So this hack is required to allow
7237 # live migration from qemu-2.2 to qemu-2.4, which is sometimes used when
7238 # updrading from proxmox-ve-3.X to proxmox-ve 4.0
7239 $use_old_bios_files = !qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 4);
7242 return ($use_old_bios_files, $machine_type);
7245 sub create_efidisk
($$$$$) {
7246 my ($storecfg, $storeid, $vmid, $fmt, $arch) = @_;
7248 my (undef, $ovmf_vars) = get_ovmf_files
($arch);
7249 die "EFI vars default image not found\n" if ! -f
$ovmf_vars;
7251 my $vars_size = PVE
::Tools
::convert_size
(-s
$ovmf_vars, 'b' => 'kb');
7252 my $volid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $vmid, $fmt, undef, $vars_size);
7253 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
7255 my $path = PVE
::Storage
::path
($storecfg, $volid);
7257 run_command
(['/usr/bin/qemu-img', 'convert', '-n', '-f', 'raw', '-O', $fmt, $ovmf_vars, $path]);
7259 die "Copying EFI vars image failed: $@" if $@;
7261 return ($volid, $vars_size);
7264 sub vm_iothreads_list
{
7267 my $res = vm_mon_cmd
($vmid, 'query-iothreads');
7270 foreach my $iothread (@$res) {
7271 $iothreads->{ $iothread->{id
} } = $iothread->{"thread-id"};
7278 my ($conf, $drive) = @_;
7282 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)) {
7284 } elsif ($conf->{scsihw
} && ($conf->{scsihw
} eq 'virtio-scsi-single')) {
7290 my $controller = int($drive->{index} / $maxdev);
7291 my $controller_prefix = ($conf->{scsihw
} && $conf->{scsihw
} eq 'virtio-scsi-single') ?
"virtioscsi" : "scsihw";
7293 return ($maxdev, $controller, $controller_prefix);
7296 sub add_hyperv_enlightenments
{
7297 my ($cpuFlags, $winversion, $machine_type, $kvmver, $bios, $gpu_passthrough, $hv_vendor_id) = @_;
7299 return if $winversion < 6;
7300 return if $bios && $bios eq 'ovmf' && $winversion < 8;
7302 if ($gpu_passthrough || defined($hv_vendor_id)) {
7303 $hv_vendor_id //= 'proxmox';
7304 push @$cpuFlags , "hv_vendor_id=$hv_vendor_id";
7307 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3)) {
7308 push @$cpuFlags , 'hv_spinlocks=0x1fff';
7309 push @$cpuFlags , 'hv_vapic';
7310 push @$cpuFlags , 'hv_time';
7312 push @$cpuFlags , 'hv_spinlocks=0xffff';
7315 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 6)) {
7316 push @$cpuFlags , 'hv_reset';
7317 push @$cpuFlags , 'hv_vpindex';
7318 push @$cpuFlags , 'hv_runtime';
7321 if ($winversion >= 7) {
7322 push @$cpuFlags , 'hv_relaxed';
7324 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 12)) {
7325 push @$cpuFlags , 'hv_synic';
7326 push @$cpuFlags , 'hv_stimer';
7329 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 3, 1)) {
7330 push @$cpuFlags , 'hv_ipi';
7335 sub windows_version
{
7338 return 0 if !$ostype;
7342 if($ostype eq 'wxp' || $ostype eq 'w2k3' || $ostype eq 'w2k') {
7344 } elsif($ostype eq 'w2k8' || $ostype eq 'wvista') {
7346 } elsif ($ostype =~ m/^win(\d+)$/) {
7353 sub resolve_dst_disk_format
{
7354 my ($storecfg, $storeid, $src_volname, $format) = @_;
7355 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
7358 # if no target format is specified, use the source disk format as hint
7360 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
7361 $format = qemu_img_format
($scfg, $src_volname);
7367 # test if requested format is supported - else use default
7368 my $supported = grep { $_ eq $format } @$validFormats;
7369 $format = $defFormat if !$supported;
7373 sub resolve_first_disk
{
7375 my @disks = PVE
::QemuServer
::valid_drive_names
();
7377 foreach my $ds (reverse @disks) {
7378 next if !$conf->{$ds};
7379 my $disk = PVE
::QemuServer
::parse_drive
($ds, $conf->{$ds});
7380 next if PVE
::QemuServer
::drive_is_cdrom
($disk);
7387 my ($uuid, $uuid_str);
7388 UUID
::generate
($uuid);
7389 UUID
::unparse
($uuid, $uuid_str);
7393 sub generate_smbios1_uuid
{
7394 return "uuid=".generate_uuid
();
7400 vm_mon_cmd
($vmid, 'nbd-server-stop');
7403 sub create_reboot_request
{
7405 open(my $fh, '>', "/run/qemu-server/$vmid.reboot")
7406 or die "failed to create reboot trigger file: $!\n";
7410 sub clear_reboot_request
{
7412 my $path = "/run/qemu-server/$vmid.reboot";
7415 $res = unlink($path);
7416 die "could not remove reboot request for $vmid: $!"
7417 if !$res && $! != POSIX
::ENOENT
;
7422 # bash completion helper
7424 sub complete_backup_archives
{
7425 my ($cmdname, $pname, $cvalue) = @_;
7427 my $cfg = PVE
::Storage
::config
();
7431 if ($cvalue =~ m/^([^:]+):/) {
7435 my $data = PVE
::Storage
::template_list
($cfg, $storeid, 'backup');
7438 foreach my $id (keys %$data) {
7439 foreach my $item (@{$data->{$id}}) {
7440 next if $item->{format
} !~ m/^vma\.(gz|lzo)$/;
7441 push @$res, $item->{volid
} if defined($item->{volid
});
7448 my $complete_vmid_full = sub {
7451 my $idlist = vmstatus
();
7455 foreach my $id (keys %$idlist) {
7456 my $d = $idlist->{$id};
7457 if (defined($running)) {
7458 next if $d->{template
};
7459 next if $running && $d->{status
} ne 'running';
7460 next if !$running && $d->{status
} eq 'running';
7469 return &$complete_vmid_full();
7472 sub complete_vmid_stopped
{
7473 return &$complete_vmid_full(0);
7476 sub complete_vmid_running
{
7477 return &$complete_vmid_full(1);
7480 sub complete_storage
{
7482 my $cfg = PVE
::Storage
::config
();
7483 my $ids = $cfg->{ids
};
7486 foreach my $sid (keys %$ids) {
7487 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, undef, 1);
7488 next if !$ids->{$sid}->{content
}->{images
};