1 package PVE
::QemuServer
;
11 use File
::Copy
qw(copy);
24 use Storable
qw(dclone);
25 use Time
::HiRes
qw(gettimeofday);
29 use PVE
::Cluster
qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
30 use PVE
::DataCenterConfig
;
31 use PVE
::Exception
qw(raise raise_param_exc);
32 use PVE
::GuestHelpers
qw(safe_string_ne safe_num_ne safe_boolean_ne);
34 use PVE
::JSONSchema
qw(get_standard_option);
36 use PVE
::RPCEnvironment
;
40 use PVE
::Tools
qw(run_command lock_file lock_file_full file_read_firstline file_get_contents dir_glob_foreach get_host_arch $IPV6RE);
44 use PVE
::QemuServer
::Helpers
qw(min_version config_aware_timeout);
45 use PVE
::QemuServer
::Cloudinit
;
46 use PVE
::QemuServer
::CPUConfig
qw(print_cpu_device get_cpu_options);
47 use PVE
::QemuServer
::Drive
qw(is_valid_drivename drive_is_cloudinit drive_is_cdrom parse_drive print_drive foreach_drive foreach_volid);
48 use PVE
::QemuServer
::Machine
;
49 use PVE
::QemuServer
::Memory
;
50 use PVE
::QemuServer
::Monitor
qw(mon_cmd);
51 use PVE
::QemuServer
::PCI
qw(print_pci_addr print_pcie_addr print_pcie_root_port);
52 use PVE
::QemuServer
::USB
qw(parse_usb_device);
56 require PVE
::Network
::SDN
::Zones
;
60 my $EDK2_FW_BASE = '/usr/share/pve-edk2-firmware/';
63 "$EDK2_FW_BASE/OVMF_CODE.fd",
64 "$EDK2_FW_BASE/OVMF_VARS.fd"
67 "$EDK2_FW_BASE/AAVMF_CODE.fd",
68 "$EDK2_FW_BASE/AAVMF_VARS.fd"
72 my $cpuinfo = PVE
::ProcFSTools
::read_cpuinfo
();
74 # Note about locking: we use flock on the config file protect
75 # against concurent actions.
76 # Aditionaly, we have a 'lock' setting in the config file. This
77 # can be set to 'migrate', 'backup', 'snapshot' or 'rollback'. Most actions are not
78 # allowed when such lock is set. But you can ignore this kind of
79 # lock with the --skiplock flag.
81 cfs_register_file
('/qemu-server/',
85 PVE
::JSONSchema
::register_standard_option
('pve-qm-stateuri', {
86 description
=> "Some command save/restore state from this location.",
92 PVE
::JSONSchema
::register_standard_option
('pve-qemu-machine', {
93 description
=> "Specifies the Qemu machine type.",
95 pattern
=> '(pc|pc(-i440fx)?-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|q35|pc-q35-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|virt(?:-\d+(\.\d+)+)?(\+pve\d+)?)',
100 #no warnings 'redefine';
103 my ($controller, $vmid, $option, $value) = @_;
105 my $path = "/sys/fs/cgroup/$controller/qemu.slice/$vmid.scope/$option";
106 PVE
::ProcFSTools
::write_proc_entry
($path, $value);
112 $nodename_cache //= PVE
::INotify
::nodename
();
113 return $nodename_cache;
120 enum
=> [qw(i6300esb ib700)],
121 description
=> "Watchdog type to emulate.",
122 default => 'i6300esb',
127 enum
=> [qw(reset shutdown poweroff pause debug none)],
128 description
=> "The action to perform if after activation the guest fails to poll the watchdog in time.",
132 PVE
::JSONSchema
::register_format
('pve-qm-watchdog', $watchdog_fmt);
136 description
=> "Enable/disable Qemu GuestAgent.",
141 fstrim_cloned_disks
=> {
142 description
=> "Run fstrim after cloning/moving a disk.",
148 description
=> "Select the agent type",
152 enum
=> [qw(virtio isa)],
158 description
=> "Select the VGA type.",
163 enum
=> [qw(cirrus qxl qxl2 qxl3 qxl4 none serial0 serial1 serial2 serial3 std virtio vmware)],
166 description
=> "Sets the VGA memory (in MiB). Has no effect with serial display.",
178 description
=> "The size of the file in MB.",
182 pattern
=> '[a-zA-Z0-9\-]+',
184 format_description
=> 'string',
185 description
=> "The name of the file. Will be prefixed with 'pve-shm-'. Default is the VMID. Will be deleted when the VM is stopped.",
192 enum
=> [qw(ich9-intel-hda intel-hda AC97)],
193 description
=> "Configure an audio device."
200 description
=> "Driver backend for the audio device."
204 my $spice_enhancements_fmt = {
209 description
=> "Enable folder sharing via SPICE. Needs Spice-WebDAV daemon installed in the VM."
213 enum
=> ['off', 'all', 'filter'],
216 description
=> "Enable video streaming. Uses compression for detected video streams."
223 enum
=> ['/dev/urandom', '/dev/random', '/dev/hwrng'],
225 description
=> "The file on the host to gather entropy from. In most"
226 . " cases /dev/urandom should be preferred over /dev/random"
227 . " to avoid entropy-starvation issues on the host. Using"
228 . " urandom does *not* decrease security in any meaningful"
229 . " way, as it's still seeded from real entropy, and the"
230 . " bytes provided will most likely be mixed with real"
231 . " entropy on the guest as well. /dev/hwrng can be used"
232 . " to pass through a hardware RNG from the host.",
236 description
=> "Maximum bytes of entropy injected into the guest every"
237 . " 'period' milliseconds. Prefer a lower value when using"
238 . " /dev/random as source. Use 0 to disable limiting"
239 . " (potentially dangerous!).",
242 # default is 1 KiB/s, provides enough entropy to the guest to avoid
243 # boot-starvation issues (e.g. systemd etc...) while allowing no chance
244 # of overwhelming the host, provided we're reading from /dev/urandom
249 description
=> "Every 'period' milliseconds the entropy-injection quota"
250 . " is reset, allowing the guest to retrieve another"
251 . " 'max_bytes' of entropy.",
261 description
=> "Specifies whether a VM will be started during system bootup.",
267 description
=> "Automatic restart after crash (currently ignored).",
272 type
=> 'string', format
=> 'pve-hotplug-features',
273 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'.",
274 default => 'network,disk,usb',
279 description
=> "Allow reboot. If set to '0' the VM exit on reboot.",
285 description
=> "Lock/unlock the VM.",
286 enum
=> [qw(backup clone create migrate rollback snapshot snapshot-delete suspending suspended)],
291 description
=> "Limit of CPU usage.",
292 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.",
300 description
=> "CPU weight for a VM.",
301 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.",
309 description
=> "Amount of RAM for the VM in MB. This is the maximum available memory when you use the balloon device.",
316 description
=> "Amount of target RAM for the VM in MB. Using zero disables the ballon driver.",
322 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.",
330 description
=> "Keybord layout for vnc server. Default is read from the '/etc/pve/datacenter.cfg' configuration file.".
331 "It should not be necessary to set it.",
332 enum
=> PVE
::Tools
::kvmkeymaplist
(),
337 type
=> 'string', format
=> 'dns-name',
338 description
=> "Set a name for the VM. Only used on the configuration web interface.",
343 description
=> "SCSI controller model",
344 enum
=> [qw(lsi lsi53c810 virtio-scsi-pci virtio-scsi-single megasas pvscsi)],
350 description
=> "Description for the VM. Only used on the configuration web interface. This is saved as comment inside the configuration file.",
355 enum
=> [qw(other wxp w2k w2k3 w2k8 wvista win7 win8 win10 l24 l26 solaris)],
356 description
=> "Specify guest operating system.",
357 verbose_description
=> <<EODESC,
358 Specify guest operating system. This is used to enable special
359 optimization/features for specific operating systems:
362 other;; unspecified OS
363 wxp;; Microsoft Windows XP
364 w2k;; Microsoft Windows 2000
365 w2k3;; Microsoft Windows 2003
366 w2k8;; Microsoft Windows 2008
367 wvista;; Microsoft Windows Vista
368 win7;; Microsoft Windows 7
369 win8;; Microsoft Windows 8/2012/2012r2
370 win10;; Microsoft Windows 10/2016
371 l24;; Linux 2.4 Kernel
372 l26;; Linux 2.6 - 5.X Kernel
373 solaris;; Solaris/OpenSolaris/OpenIndiania kernel
379 description
=> "Boot on floppy (a), hard disk (c), CD-ROM (d), or network (n).",
380 pattern
=> '[acdn]{1,4}',
385 type
=> 'string', format
=> 'pve-qm-bootdisk',
386 description
=> "Enable booting from specified disk.",
387 pattern
=> '(ide|sata|scsi|virtio)\d+',
392 description
=> "The number of CPUs. Please use option -sockets instead.",
399 description
=> "The number of CPU sockets.",
406 description
=> "The number of cores per socket.",
413 description
=> "Enable/disable NUMA.",
419 description
=> "Enable/disable hugepages memory.",
420 enum
=> [qw(any 2 1024)],
425 description
=> "Number of hotplugged vcpus.",
432 description
=> "Enable/disable ACPI.",
437 description
=> "Enable/disable Qemu GuestAgent and its properties.",
439 format
=> $agent_fmt,
444 description
=> "Enable/disable KVM hardware virtualization.",
450 description
=> "Enable/disable time drift fix.",
456 description
=> "Set the real time clock to local time. This is enabled by default if ostype indicates a Microsoft OS.",
461 description
=> "Freeze CPU at startup (use 'c' monitor command to start execution).",
465 type
=> 'string', format
=> $vga_fmt,
466 description
=> "Configure the VGA hardware.",
467 verbose_description
=> "Configure the VGA Hardware. If you want to use ".
468 "high resolution modes (>= 1280x1024x16) you may need to increase " .
469 "the vga memory option. Since QEMU 2.9 the default VGA display type " .
470 "is 'std' for all OS types besides some Windows versions (XP and " .
471 "older) which use 'cirrus'. The 'qxl' option enables the SPICE " .
472 "display server. For win* OS you can select how many independent " .
473 "displays you want, Linux guests can add displays them self.\n".
474 "You can also run without any graphic card, using a serial device as terminal.",
478 type
=> 'string', format
=> 'pve-qm-watchdog',
479 description
=> "Create a virtual hardware watchdog device.",
480 verbose_description
=> "Create a virtual hardware watchdog device. Once enabled" .
481 " (by a guest action), the watchdog must be periodically polled " .
482 "by an agent inside the guest or else the watchdog will reset " .
483 "the guest (or execute the respective action specified)",
488 typetext
=> "(now | YYYY-MM-DD | YYYY-MM-DDTHH:MM:SS)",
489 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'.",
490 pattern
=> '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
493 startup
=> get_standard_option
('pve-startup-order'),
497 description
=> "Enable/disable Template.",
503 description
=> "Arbitrary arguments passed to kvm.",
504 verbose_description
=> <<EODESCR,
505 Arbitrary arguments passed to kvm, for example:
507 args: -no-reboot -no-hpet
509 NOTE: this option is for experts only.
516 description
=> "Enable/disable the USB tablet device.",
517 verbose_description
=> "Enable/disable the USB tablet device. This device is " .
518 "usually needed to allow absolute mouse positioning with VNC. " .
519 "Else the mouse runs out of sync with normal VNC clients. " .
520 "If you're running lots of console-only guests on one host, " .
521 "you may consider disabling this to save some context switches. " .
522 "This is turned off by default if you use spice (-vga=qxl).",
527 description
=> "Set maximum speed (in MB/s) for migrations. Value 0 is no limit.",
531 migrate_downtime
=> {
534 description
=> "Set maximum tolerated downtime (in seconds) for migrations.",
540 type
=> 'string', format
=> 'pve-qm-ide',
541 typetext
=> '<volume>',
542 description
=> "This is an alias for option -ide2",
546 description
=> "Emulated CPU type.",
548 format
=> $PVE::QemuServer
::CPUConfig
::cpu_fmt
,
550 parent
=> get_standard_option
('pve-snapshot-name', {
552 description
=> "Parent snapshot name. This is used internally, and should not be modified.",
556 description
=> "Timestamp for snapshots.",
562 type
=> 'string', format
=> 'pve-volume-id',
563 description
=> "Reference to a volume which stores the VM state. This is used internally for snapshots.",
565 vmstatestorage
=> get_standard_option
('pve-storage-id', {
566 description
=> "Default storage for VM state volumes/files.",
569 runningmachine
=> get_standard_option
('pve-qemu-machine', {
570 description
=> "Specifies the Qemu machine type of the running vm. This is used internally for snapshots.",
572 machine
=> get_standard_option
('pve-qemu-machine'),
574 description
=> "Virtual processor architecture. Defaults to the host.",
577 enum
=> [qw(x86_64 aarch64)],
580 description
=> "Specify SMBIOS type 1 fields.",
581 type
=> 'string', format
=> 'pve-qm-smbios1',
588 description
=> "Sets the protection flag of the VM. This will disable the remove VM and remove disk operations.",
594 enum
=> [ qw(seabios ovmf) ],
595 description
=> "Select BIOS implementation.",
596 default => 'seabios',
600 pattern
=> '(?:[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}|[01])',
601 format_description
=> 'UUID',
602 description
=> "Set VM Generation ID. Use '1' to autogenerate on create or update, pass '0' to disable explicitly.",
603 verbose_description
=> "The VM generation ID (vmgenid) device exposes a".
604 " 128-bit integer value identifier to the guest OS. This allows to".
605 " notify the guest operating system when the virtual machine is".
606 " executed with a different configuration (e.g. snapshot execution".
607 " or creation from a template). The guest operating system notices".
608 " the change, and is then able to react as appropriate by marking".
609 " its copies of distributed databases as dirty, re-initializing its".
610 " random number generator, etc.\n".
611 "Note that auto-creation only works when done throug API/CLI create".
612 " or update methods, but not when manually editing the config file.",
613 default => "1 (autogenerated)",
618 format
=> 'pve-volume-id',
620 description
=> "Script that will be executed during various steps in the vms lifetime.",
624 format
=> $ivshmem_fmt,
625 description
=> "Inter-VM shared memory. Useful for direct communication between VMs, or to the host.",
630 format
=> $audio_fmt,
631 description
=> "Configure a audio device, useful in combination with QXL/Spice.",
634 spice_enhancements
=> {
636 format
=> $spice_enhancements_fmt,
637 description
=> "Configure additional enhancements for SPICE.",
641 type
=> 'string', format
=> 'pve-tag-list',
642 description
=> 'Tags of the VM. This is only meta information.',
648 description
=> "Configure a VirtIO-based Random Number Generator.",
657 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.',
658 format
=> 'pve-volume-id',
659 format_description
=> 'volume',
664 description
=> 'Specify a custom file containing all network data passed to the VM via cloud-init.',
665 format
=> 'pve-volume-id',
666 format_description
=> 'volume',
671 description
=> 'Specify a custom file containing all user data passed to the VM via cloud-init.',
672 format
=> 'pve-volume-id',
673 format_description
=> 'volume',
676 PVE
::JSONSchema
::register_format
('pve-qm-cicustom', $cicustom_fmt);
678 my $confdesc_cloudinit = {
682 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.',
683 enum
=> ['configdrive2', 'nocloud'],
688 description
=> "cloud-init: User name to change ssh keys and password for instead of the image's configured default user.",
693 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.',
698 description
=> 'cloud-init: Specify custom files to replace the automatically generated ones at start.',
699 format
=> 'pve-qm-cicustom',
704 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.",
708 type
=> 'string', format
=> 'address-list',
709 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.",
714 format
=> 'urlencoded',
715 description
=> "cloud-init: Setup public SSH keys (one key per line, OpenSSH format).",
719 # what about other qemu settings ?
721 #machine => 'string',
734 ##soundhw => 'string',
736 while (my ($k, $v) = each %$confdesc) {
737 PVE
::JSONSchema
::register_standard_option
("pve-qm-$k", $v);
740 my $MAX_USB_DEVICES = 5;
742 my $MAX_HOSTPCI_DEVICES = 16;
743 my $MAX_SERIAL_PORTS = 4;
744 my $MAX_PARALLEL_PORTS = 3;
750 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
751 description
=> "CPUs accessing this NUMA node.",
752 format_description
=> "id[-id];...",
756 description
=> "Amount of memory this NUMA node provides.",
761 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
762 description
=> "Host NUMA nodes to use.",
763 format_description
=> "id[-id];...",
768 enum
=> [qw(preferred bind interleave)],
769 description
=> "NUMA allocation policy.",
773 PVE
::JSONSchema
::register_format
('pve-qm-numanode', $numa_fmt);
776 type
=> 'string', format
=> $numa_fmt,
777 description
=> "NUMA topology.",
779 PVE
::JSONSchema
::register_standard_option
("pve-qm-numanode", $numadesc);
781 for (my $i = 0; $i < $MAX_NUMA; $i++) {
782 $confdesc->{"numa$i"} = $numadesc;
785 my $nic_model_list = ['rtl8139', 'ne2k_pci', 'e1000', 'pcnet', 'virtio',
786 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3',
787 'e1000-82540em', 'e1000-82544gc', 'e1000-82545em'];
788 my $nic_model_list_txt = join(' ', sort @$nic_model_list);
790 my $net_fmt_bridge_descr = <<__EOD__;
791 Bridge to attach the network device to. The Proxmox VE standard bridge
794 If you do not specify a bridge, we create a kvm user (NATed) network
795 device, which provides DHCP and DNS services. The following addresses
802 The DHCP server assign addresses to the guest starting from 10.0.2.15.
806 macaddr
=> get_standard_option
('mac-addr', {
807 description
=> "MAC address. That address must be unique withing your network. This is automatically generated if not specified.",
811 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'.",
812 enum
=> $nic_model_list,
815 (map { $_ => { keyAlias
=> 'model', alias
=> 'macaddr' }} @$nic_model_list),
818 description
=> $net_fmt_bridge_descr,
819 format_description
=> 'bridge',
824 minimum
=> 0, maximum
=> 16,
825 description
=> 'Number of packet queues to be used on the device.',
831 description
=> "Rate limit in mbps (megabytes per second) as floating point number.",
836 minimum
=> 1, maximum
=> 4094,
837 description
=> 'VLAN tag to apply to packets on this interface.',
842 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
843 description
=> 'VLAN trunks to pass through this interface.',
844 format_description
=> 'vlanid[;vlanid...]',
849 description
=> 'Whether this interface should be protected by the firewall.',
854 description
=> 'Whether this interface should be disconnected (like pulling the plug).',
861 type
=> 'string', format
=> $net_fmt,
862 description
=> "Specify network devices.",
865 PVE
::JSONSchema
::register_standard_option
("pve-qm-net", $netdesc);
870 format
=> 'pve-ipv4-config',
871 format_description
=> 'IPv4Format/CIDR',
872 description
=> 'IPv4 address in CIDR format.',
879 format_description
=> 'GatewayIPv4',
880 description
=> 'Default gateway for IPv4 traffic.',
886 format
=> 'pve-ipv6-config',
887 format_description
=> 'IPv6Format/CIDR',
888 description
=> 'IPv6 address in CIDR format.',
895 format_description
=> 'GatewayIPv6',
896 description
=> 'Default gateway for IPv6 traffic.',
901 PVE
::JSONSchema
::register_format
('pve-qm-ipconfig', $ipconfig_fmt);
904 type
=> 'string', format
=> 'pve-qm-ipconfig',
905 description
=> <<'EODESCR',
906 cloud-init: Specify IP addresses and gateways for the corresponding interface.
908 IP addresses use CIDR notation, gateways are optional but need an IP of the same type specified.
910 The special string 'dhcp' can be used for IP addresses to use DHCP, in which case no explicit gateway should be provided.
911 For IPv6 the special string 'auto' can be used to use stateless autoconfiguration.
913 If cloud-init is enabled and neither an IPv4 nor an IPv6 address is specified, it defaults to using dhcp on IPv4.
916 PVE
::JSONSchema
::register_standard_option
("pve-qm-ipconfig", $netdesc);
918 for (my $i = 0; $i < $MAX_NETS; $i++) {
919 $confdesc->{"net$i"} = $netdesc;
920 $confdesc_cloudinit->{"ipconfig$i"} = $ipconfigdesc;
923 foreach my $key (keys %$confdesc_cloudinit) {
924 $confdesc->{$key} = $confdesc_cloudinit->{$key};
927 PVE
::JSONSchema
::register_format
('pve-volume-id-or-qm-path', \
&verify_volume_id_or_qm_path
);
928 sub verify_volume_id_or_qm_path
{
929 my ($volid, $noerr) = @_;
931 if ($volid eq 'none' || $volid eq 'cdrom' || $volid =~ m
|^/|) {
935 # if its neither 'none' nor 'cdrom' nor a path, check if its a volume-id
936 $volid = eval { PVE
::JSONSchema
::check_format
('pve-volume-id', $volid, '') };
938 return undef if $noerr;
947 type
=> 'string', format
=> 'pve-qm-usb-device',
948 format_description
=> 'HOSTUSBDEVICE|spice',
949 description
=> <<EODESCR,
950 The Host USB device or port or the value 'spice'. HOSTUSBDEVICE syntax is:
952 'bus-port(.port)*' (decimal numbers) or
953 'vendor_id:product_id' (hexadeciaml numbers) or
956 You can use the 'lsusb -t' command to list existing usb devices.
958 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
960 The value 'spice' can be used to add a usb redirection devices for spice.
966 description
=> "Specifies whether if given host option is a USB3 device or port.",
973 type
=> 'string', format
=> $usb_fmt,
974 description
=> "Configure an USB device (n is 0 to 4).",
976 PVE
::JSONSchema
::register_standard_option
("pve-qm-usb", $usbdesc);
978 my $PCIRE = qr/([a-f0-9]{4}:)?[a-f0-9]{2}:[a-f0-9]{2}(?:\.[a-f0-9])?/;
983 pattern
=> qr/$PCIRE(;$PCIRE)*/,
984 format_description
=> 'HOSTPCIID[;HOSTPCIID2...]',
985 description
=> <<EODESCR,
986 Host PCI device pass through. The PCI ID of a host's PCI device or a list
987 of PCI virtual functions of the host. HOSTPCIID syntax is:
989 'bus:dev.func' (hexadecimal numbers)
991 You can us the 'lspci' command to list existing PCI devices.
996 description
=> "Specify whether or not the device's ROM will be visible in the guest's memory map.",
1002 pattern
=> '[^,;]+',
1003 format_description
=> 'string',
1004 description
=> "Custom pci device rom filename (must be located in /usr/share/kvm/).",
1009 description
=> "Choose the PCI-express bus (needs the 'q35' machine model).",
1015 description
=> "Enable vfio-vga device support.",
1021 format_description
=> 'string',
1022 pattern
=> '[^/\.:]+',
1024 description
=> <<EODESCR
1025 The type of mediated device to use.
1026 An instance of this type will be created on startup of the VM and
1027 will be cleaned up when the VM stops.
1031 PVE
::JSONSchema
::register_format
('pve-qm-hostpci', $hostpci_fmt);
1035 type
=> 'string', format
=> 'pve-qm-hostpci',
1036 description
=> "Map host PCI devices into guest.",
1037 verbose_description
=> <<EODESCR,
1038 Map host PCI devices into guest.
1040 NOTE: This option allows direct access to host hardware. So it is no longer
1041 possible to migrate such machines - use with special care.
1043 CAUTION: Experimental! User reported problems with this option.
1046 PVE
::JSONSchema
::register_standard_option
("pve-qm-hostpci", $hostpcidesc);
1051 pattern
=> '(/dev/.+|socket)',
1052 description
=> "Create a serial device inside the VM (n is 0 to 3)",
1053 verbose_description
=> <<EODESCR,
1054 Create a serial device inside the VM (n is 0 to 3), and pass through a
1055 host serial device (i.e. /dev/ttyS0), or create a unix socket on the
1056 host side (use 'qm terminal' to open a terminal connection).
1058 NOTE: If you pass through a host serial device, it is no longer possible to migrate such machines - use with special care.
1060 CAUTION: Experimental! User reported problems with this option.
1067 pattern
=> '/dev/parport\d+|/dev/usb/lp\d+',
1068 description
=> "Map host parallel devices (n is 0 to 2).",
1069 verbose_description
=> <<EODESCR,
1070 Map host parallel devices (n is 0 to 2).
1072 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
1074 CAUTION: Experimental! User reported problems with this option.
1078 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
1079 $confdesc->{"parallel$i"} = $paralleldesc;
1082 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
1083 $confdesc->{"serial$i"} = $serialdesc;
1086 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
1087 $confdesc->{"hostpci$i"} = $hostpcidesc;
1090 for my $key (keys %{$PVE::QemuServer
::Drive
::drivedesc_hash
}) {
1091 $confdesc->{$key} = $PVE::QemuServer
::Drive
::drivedesc_hash-
>{$key};
1094 for (my $i = 0; $i < $PVE::QemuServer
::Drive
::MAX_UNUSED_DISKS
; $i++) {
1095 $confdesc->{"unused$i"} = $PVE::QemuServer
::Drive
::unuseddesc
;
1098 for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
1099 $confdesc->{"usb$i"} = $usbdesc;
1102 my $kvm_api_version = 0;
1105 return $kvm_api_version if $kvm_api_version;
1107 open my $fh, '<', '/dev/kvm'
1110 # 0xae00 => KVM_GET_API_VERSION
1111 $kvm_api_version = ioctl($fh, 0xae00, 0);
1113 return $kvm_api_version;
1116 my $kvm_user_version = {};
1119 sub kvm_user_version
{
1122 $binary //= get_command_for_arch
(get_host_arch
()); # get the native arch by default
1123 my $st = stat($binary);
1125 my $cachedmtime = $kvm_mtime->{$binary} // -1;
1126 return $kvm_user_version->{$binary} if $kvm_user_version->{$binary} &&
1127 $cachedmtime == $st->mtime;
1129 $kvm_user_version->{$binary} = 'unknown';
1130 $kvm_mtime->{$binary} = $st->mtime;
1134 if ($line =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)(\.\d+)?[,\s]/) {
1135 $kvm_user_version->{$binary} = $2;
1139 eval { run_command
([$binary, '--version'], outfunc
=> $code); };
1142 return $kvm_user_version->{$binary};
1146 sub kernel_has_vhost_net
{
1147 return -c
'/dev/vhost-net';
1152 return defined($confdesc->{$key});
1156 sub get_cdrom_path
{
1158 return $cdrom_path if $cdrom_path;
1160 return $cdrom_path = "/dev/cdrom" if -l
"/dev/cdrom";
1161 return $cdrom_path = "/dev/cdrom1" if -l
"/dev/cdrom1";
1162 return $cdrom_path = "/dev/cdrom2" if -l
"/dev/cdrom2";
1166 my ($storecfg, $vmid, $cdrom) = @_;
1168 if ($cdrom eq 'cdrom') {
1169 return get_cdrom_path
();
1170 } elsif ($cdrom eq 'none') {
1172 } elsif ($cdrom =~ m
|^/|) {
1175 return PVE
::Storage
::path
($storecfg, $cdrom);
1179 # try to convert old style file names to volume IDs
1180 sub filename_to_volume_id
{
1181 my ($vmid, $file, $media) = @_;
1183 if (!($file eq 'none' || $file eq 'cdrom' ||
1184 $file =~ m
|^/dev/.+| || $file =~ m/^([^:]+):(.+)$/)) {
1186 return undef if $file =~ m
|/|;
1188 if ($media && $media eq 'cdrom') {
1189 $file = "local:iso/$file";
1191 $file = "local:$vmid/$file";
1198 sub verify_media_type
{
1199 my ($opt, $vtype, $media) = @_;
1204 if ($media eq 'disk') {
1206 } elsif ($media eq 'cdrom') {
1209 die "internal error";
1212 return if ($vtype eq $etype);
1214 raise_param_exc
({ $opt => "unexpected media type ($vtype != $etype)" });
1217 sub cleanup_drive_path
{
1218 my ($opt, $storecfg, $drive) = @_;
1220 # try to convert filesystem paths to volume IDs
1222 if (($drive->{file
} !~ m/^(cdrom|none)$/) &&
1223 ($drive->{file
} !~ m
|^/dev/.+|) &&
1224 ($drive->{file
} !~ m/^([^:]+):(.+)$/) &&
1225 ($drive->{file
} !~ m/^\d+$/)) {
1226 my ($vtype, $volid) = PVE
::Storage
::path_to_volume_id
($storecfg, $drive->{file
});
1227 raise_param_exc
({ $opt => "unable to associate path '$drive->{file}' to any storage"}) if !$vtype;
1228 $drive->{media
} = 'cdrom' if !$drive->{media
} && $vtype eq 'iso';
1229 verify_media_type
($opt, $vtype, $drive->{media
});
1230 $drive->{file
} = $volid;
1233 $drive->{media
} = 'cdrom' if !$drive->{media
} && $drive->{file
} =~ m/^(cdrom|none)$/;
1236 sub parse_hotplug_features
{
1241 return $res if $data eq '0';
1243 $data = $confdesc->{hotplug
}->{default} if $data eq '1';
1245 foreach my $feature (PVE
::Tools
::split_list
($data)) {
1246 if ($feature =~ m/^(network|disk|cpu|memory|usb)$/) {
1249 die "invalid hotplug feature '$feature'\n";
1255 PVE
::JSONSchema
::register_format
('pve-hotplug-features', \
&pve_verify_hotplug_features
);
1256 sub pve_verify_hotplug_features
{
1257 my ($value, $noerr) = @_;
1259 return $value if parse_hotplug_features
($value);
1261 return undef if $noerr;
1263 die "unable to parse hotplug option\n";
1267 my($fh, $noerr) = @_;
1270 my $SG_GET_VERSION_NUM = 0x2282;
1272 my $versionbuf = "\x00" x
8;
1273 my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
1275 die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
1278 my $version = unpack("I", $versionbuf);
1279 if ($version < 30000) {
1280 die "scsi generic interface too old\n" if !$noerr;
1284 my $buf = "\x00" x
36;
1285 my $sensebuf = "\x00" x
8;
1286 my $cmd = pack("C x3 C x1", 0x12, 36);
1288 # see /usr/include/scsi/sg.h
1289 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";
1291 my $packet = pack($sg_io_hdr_t, ord('S'), -3, length($cmd),
1292 length($sensebuf), 0, length($buf), $buf,
1293 $cmd, $sensebuf, 6000);
1295 $ret = ioctl($fh, $SG_IO, $packet);
1297 die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
1301 my @res = unpack($sg_io_hdr_t, $packet);
1302 if ($res[17] || $res[18]) {
1303 die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
1308 (my $byte0, my $byte1, $res->{vendor
},
1309 $res->{product
}, $res->{revision
}) = unpack("C C x6 A8 A16 A4", $buf);
1311 $res->{removable
} = $byte1 & 128 ?
1 : 0;
1312 $res->{type
} = $byte0 & 31;
1320 my $fh = IO
::File-
>new("+<$path") || return undef;
1321 my $res = scsi_inquiry
($fh, 1);
1327 sub print_tabletdevice_full
{
1328 my ($conf, $arch) = @_;
1330 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
1332 # we use uhci for old VMs because tablet driver was buggy in older qemu
1334 if (PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf) || $arch eq 'aarch64') {
1340 return "usb-tablet,id=tablet,bus=$usbbus.0,port=1";
1343 sub print_keyboarddevice_full
{
1344 my ($conf, $arch, $machine) = @_;
1346 return undef if $arch ne 'aarch64';
1348 return "usb-kbd,id=keyboard,bus=ehci.0,port=2";
1351 sub print_drivedevice_full
{
1352 my ($storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type) = @_;
1357 if ($drive->{interface
} eq 'virtio') {
1358 my $pciaddr = print_pci_addr
("$drive->{interface}$drive->{index}", $bridges, $arch, $machine_type);
1359 $device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
1360 $device .= ",iothread=iothread-$drive->{interface}$drive->{index}" if $drive->{iothread
};
1361 } elsif ($drive->{interface
} eq 'scsi') {
1363 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
1364 my $unit = $drive->{index} % $maxdev;
1365 my $devicetype = 'hd';
1367 if (drive_is_cdrom
($drive)) {
1370 if ($drive->{file
} =~ m
|^/|) {
1371 $path = $drive->{file
};
1372 if (my $info = path_is_scsi
($path)) {
1373 if ($info->{type
} == 0 && $drive->{scsiblock
}) {
1374 $devicetype = 'block';
1375 } elsif ($info->{type
} == 1) { # tape
1376 $devicetype = 'generic';
1380 $path = PVE
::Storage
::path
($storecfg, $drive->{file
});
1383 # for compatibility only, we prefer scsi-hd (#2408, #2355, #2380)
1384 my $version = PVE
::QemuServer
::Machine
::extract_version
($machine_type, kvm_user_version
());
1385 if ($path =~ m/^iscsi\:\/\
// &&
1386 !min_version
($version, 4, 1)) {
1387 $devicetype = 'generic';
1391 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)){
1392 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,scsi-id=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1394 $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}";
1397 if ($drive->{ssd
} && ($devicetype eq 'block' || $devicetype eq 'hd')) {
1398 $device .= ",rotation_rate=1";
1400 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1402 } elsif ($drive->{interface
} eq 'ide' || $drive->{interface
} eq 'sata') {
1403 my $maxdev = ($drive->{interface
} eq 'sata') ?
$PVE::QemuServer
::Drive
::MAX_SATA_DISKS
: 2;
1404 my $controller = int($drive->{index} / $maxdev);
1405 my $unit = $drive->{index} % $maxdev;
1406 my $devicetype = ($drive->{media
} && $drive->{media
} eq 'cdrom') ?
"cd" : "hd";
1408 $device = "ide-$devicetype";
1409 if ($drive->{interface
} eq 'ide') {
1410 $device .= ",bus=ide.$controller,unit=$unit";
1412 $device .= ",bus=ahci$controller.$unit";
1414 $device .= ",drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1416 if ($devicetype eq 'hd') {
1417 if (my $model = $drive->{model
}) {
1418 $model = URI
::Escape
::uri_unescape
($model);
1419 $device .= ",model=$model";
1421 if ($drive->{ssd
}) {
1422 $device .= ",rotation_rate=1";
1425 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1426 } elsif ($drive->{interface
} eq 'usb') {
1428 # -device ide-drive,bus=ide.1,unit=0,drive=drive-ide0-1-0,id=ide0-1-0
1430 die "unsupported interface type";
1433 $device .= ",bootindex=$drive->{bootindex}" if $drive->{bootindex
};
1435 if (my $serial = $drive->{serial
}) {
1436 $serial = URI
::Escape
::uri_unescape
($serial);
1437 $device .= ",serial=$serial";
1444 sub get_initiator_name
{
1447 my $fh = IO
::File-
>new('/etc/iscsi/initiatorname.iscsi') || return undef;
1448 while (defined(my $line = <$fh>)) {
1449 next if $line !~ m/^\s*InitiatorName\s*=\s*([\.\-:\w]+)/;
1458 sub print_drive_commandline_full
{
1459 my ($storecfg, $vmid, $drive) = @_;
1462 my $volid = $drive->{file
};
1465 if (drive_is_cdrom
($drive)) {
1466 $path = get_iso_path
($storecfg, $vmid, $volid);
1468 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
1470 $path = PVE
::Storage
::path
($storecfg, $volid);
1471 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
1472 $format = qemu_img_format
($scfg, $volname);
1480 my @qemu_drive_options = qw(heads secs cyls trans media format cache rerror werror aio discard);
1481 foreach my $o (@qemu_drive_options) {
1482 $opts .= ",$o=$drive->{$o}" if defined($drive->{$o});
1485 # snapshot only accepts on|off
1486 if (defined($drive->{snapshot
})) {
1487 my $v = $drive->{snapshot
} ?
'on' : 'off';
1488 $opts .= ",snapshot=$v";
1491 foreach my $type (['', '-total'], [_rd
=> '-read'], [_wr
=> '-write']) {
1492 my ($dir, $qmpname) = @$type;
1493 if (my $v = $drive->{"mbps$dir"}) {
1494 $opts .= ",throttling.bps$qmpname=".int($v*1024*1024);
1496 if (my $v = $drive->{"mbps${dir}_max"}) {
1497 $opts .= ",throttling.bps$qmpname-max=".int($v*1024*1024);
1499 if (my $v = $drive->{"bps${dir}_max_length"}) {
1500 $opts .= ",throttling.bps$qmpname-max-length=$v";
1502 if (my $v = $drive->{"iops${dir}"}) {
1503 $opts .= ",throttling.iops$qmpname=$v";
1505 if (my $v = $drive->{"iops${dir}_max"}) {
1506 $opts .= ",throttling.iops$qmpname-max=$v";
1508 if (my $v = $drive->{"iops${dir}_max_length"}) {
1509 $opts .= ",throttling.iops$qmpname-max-length=$v";
1513 $opts .= ",format=$format" if $format && !$drive->{format
};
1515 my $cache_direct = 0;
1517 if (my $cache = $drive->{cache
}) {
1518 $cache_direct = $cache =~ /^(?:off|none|directsync)$/;
1519 } elsif (!drive_is_cdrom
($drive)) {
1520 $opts .= ",cache=none";
1524 # aio native works only with O_DIRECT
1525 if (!$drive->{aio
}) {
1527 $opts .= ",aio=native";
1529 $opts .= ",aio=threads";
1533 if (!drive_is_cdrom
($drive)) {
1535 if (defined($drive->{detect_zeroes
}) && !$drive->{detect_zeroes
}) {
1536 $detectzeroes = 'off';
1537 } elsif ($drive->{discard
}) {
1538 $detectzeroes = $drive->{discard
} eq 'on' ?
'unmap' : 'on';
1540 # This used to be our default with discard not being specified:
1541 $detectzeroes = 'on';
1543 $opts .= ",detect-zeroes=$detectzeroes" if $detectzeroes;
1546 my $pathinfo = $path ?
"file=$path," : '';
1548 return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
1551 sub print_netdevice_full
{
1552 my ($vmid, $conf, $net, $netid, $bridges, $use_old_bios_files, $arch, $machine_type) = @_;
1554 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
1556 my $device = $net->{model
};
1557 if ($net->{model
} eq 'virtio') {
1558 $device = 'virtio-net-pci';
1561 my $pciaddr = print_pci_addr
("$netid", $bridges, $arch, $machine_type);
1562 my $tmpstr = "$device,mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
1563 if ($net->{queues
} && $net->{queues
} > 1 && $net->{model
} eq 'virtio'){
1564 #Consider we have N queues, the number of vectors needed is 2*N + 2 (plus one config interrupt and control vq)
1565 my $vectors = $net->{queues
} * 2 + 2;
1566 $tmpstr .= ",vectors=$vectors,mq=on";
1568 $tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex
} ;
1570 if ($use_old_bios_files) {
1572 if ($device eq 'virtio-net-pci') {
1573 $romfile = 'pxe-virtio.rom';
1574 } elsif ($device eq 'e1000') {
1575 $romfile = 'pxe-e1000.rom';
1576 } elsif ($device eq 'ne2k') {
1577 $romfile = 'pxe-ne2k_pci.rom';
1578 } elsif ($device eq 'pcnet') {
1579 $romfile = 'pxe-pcnet.rom';
1580 } elsif ($device eq 'rtl8139') {
1581 $romfile = 'pxe-rtl8139.rom';
1583 $tmpstr .= ",romfile=$romfile" if $romfile;
1589 sub print_netdev_full
{
1590 my ($vmid, $conf, $arch, $net, $netid, $hotplug) = @_;
1593 if ($netid =~ m/^net(\d+)$/) {
1597 die "got strange net id '$i'\n" if $i >= ${MAX_NETS
};
1599 my $ifname = "tap${vmid}i$i";
1601 # kvm uses TUNSETIFF ioctl, and that limits ifname length
1602 die "interface name '$ifname' is too long (max 15 character)\n"
1603 if length($ifname) >= 16;
1605 my $vhostparam = '';
1606 if (is_native
($arch)) {
1607 $vhostparam = ',vhost=on' if kernel_has_vhost_net
() && $net->{model
} eq 'virtio';
1610 my $vmname = $conf->{name
} || "vm$vmid";
1613 my $script = $hotplug ?
"pve-bridge-hotplug" : "pve-bridge";
1615 if ($net->{bridge
}) {
1616 $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/$script,downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
1618 $netdev = "type=user,id=$netid,hostname=$vmname";
1621 $netdev .= ",queues=$net->{queues}" if ($net->{queues
} && $net->{model
} eq 'virtio');
1627 'cirrus' => 'cirrus-vga',
1629 'vmware' => 'vmware-svga',
1630 'virtio' => 'virtio-vga',
1633 sub print_vga_device
{
1634 my ($conf, $vga, $arch, $machine_version, $machine, $id, $qxlnum, $bridges) = @_;
1636 my $type = $vga_map->{$vga->{type
}};
1637 if ($arch eq 'aarch64' && defined($type) && $type eq 'virtio-vga') {
1638 $type = 'virtio-gpu';
1640 my $vgamem_mb = $vga->{memory
};
1642 my $max_outputs = '';
1644 $type = $id ?
'qxl' : 'qxl-vga';
1646 if (!$conf->{ostype
} || $conf->{ostype
} =~ m/^(?:l\d\d)|(?:other)$/) {
1647 # set max outputs so linux can have up to 4 qxl displays with one device
1648 if (min_version
($machine_version, 4, 1)) {
1649 $max_outputs = ",max_outputs=4";
1654 die "no devicetype for $vga->{type}\n" if !$type;
1658 if ($vga->{type
} eq 'virtio') {
1659 my $bytes = PVE
::Tools
::convert_size
($vgamem_mb, "mb" => "b");
1660 $memory = ",max_hostmem=$bytes";
1662 # from https://www.spice-space.org/multiple-monitors.html
1663 $memory = ",vgamem_mb=$vga->{memory}";
1664 my $ram = $vgamem_mb * 4;
1665 my $vram = $vgamem_mb * 2;
1666 $memory .= ",ram_size_mb=$ram,vram_size_mb=$vram";
1668 $memory = ",vgamem_mb=$vga->{memory}";
1670 } elsif ($qxlnum && $id) {
1671 $memory = ",ram_size=67108864,vram_size=33554432";
1674 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
1675 my $vgaid = "vga" . ($id // '');
1678 if ($q35 && $vgaid eq 'vga') {
1679 # the first display uses pcie.0 bus on q35 machines
1680 $pciaddr = print_pcie_addr
($vgaid, $bridges, $arch, $machine);
1682 $pciaddr = print_pci_addr
($vgaid, $bridges, $arch, $machine);
1685 return "$type,id=${vgaid}${memory}${max_outputs}${pciaddr}";
1688 sub parse_number_sets
{
1691 foreach my $part (split(/;/, $set)) {
1692 if ($part =~ /^\s*(\d+)(?:-(\d+))?\s*$/) {
1693 die "invalid range: $part ($2 < $1)\n" if defined($2) && $2 < $1;
1694 push @$res, [ $1, $2 ];
1696 die "invalid range: $part\n";
1705 my $res = PVE
::JSONSchema
::parse_property_string
($numa_fmt, $data);
1706 $res->{cpus
} = parse_number_sets
($res->{cpus
}) if defined($res->{cpus
});
1707 $res->{hostnodes
} = parse_number_sets
($res->{hostnodes
}) if defined($res->{hostnodes
});
1714 return undef if !$value;
1716 my $res = PVE
::JSONSchema
::parse_property_string
($hostpci_fmt, $value);
1718 my @idlist = split(/;/, $res->{host
});
1719 delete $res->{host
};
1720 foreach my $id (@idlist) {
1721 my $devs = PVE
::SysFSTools
::lspci
($id);
1722 die "no PCI device found for '$id'\n" if !scalar(@$devs);
1723 push @{$res->{pciid
}}, @$devs;
1728 # netX: e1000=XX:XX:XX:XX:XX:XX,bridge=vmbr0,rate=<mbps>
1732 my $res = eval { PVE
::JSONSchema
::parse_property_string
($net_fmt, $data) };
1737 if (!defined($res->{macaddr
})) {
1738 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
1739 $res->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
});
1744 # ipconfigX ip=cidr,gw=ip,ip6=cidr,gw6=ip
1745 sub parse_ipconfig
{
1748 my $res = eval { PVE
::JSONSchema
::parse_property_string
($ipconfig_fmt, $data) };
1754 if ($res->{gw
} && !$res->{ip
}) {
1755 warn 'gateway specified without specifying an IP address';
1758 if ($res->{gw6
} && !$res->{ip6
}) {
1759 warn 'IPv6 gateway specified without specifying an IPv6 address';
1762 if ($res->{gw
} && $res->{ip
} eq 'dhcp') {
1763 warn 'gateway specified together with DHCP';
1766 if ($res->{gw6
} && $res->{ip6
} !~ /^$IPV6RE/) {
1768 warn "IPv6 gateway specified together with $res->{ip6} address";
1772 if (!$res->{ip
} && !$res->{ip6
}) {
1773 return { ip
=> 'dhcp', ip6
=> 'dhcp' };
1782 return PVE
::JSONSchema
::print_property_string
($net, $net_fmt);
1785 sub add_random_macs
{
1786 my ($settings) = @_;
1788 foreach my $opt (keys %$settings) {
1789 next if $opt !~ m/^net(\d+)$/;
1790 my $net = parse_net
($settings->{$opt});
1792 $settings->{$opt} = print_net
($net);
1796 sub vm_is_volid_owner
{
1797 my ($storecfg, $vmid, $volid) = @_;
1799 if ($volid !~ m
|^/|) {
1801 eval { ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid); };
1802 if ($owner && ($owner == $vmid)) {
1810 sub vmconfig_register_unused_drive
{
1811 my ($storecfg, $vmid, $conf, $drive) = @_;
1813 if (drive_is_cloudinit
($drive)) {
1814 eval { PVE
::Storage
::vdisk_free
($storecfg, $drive->{file
}) };
1816 } elsif (!drive_is_cdrom
($drive)) {
1817 my $volid = $drive->{file
};
1818 if (vm_is_volid_owner
($storecfg, $vmid, $volid)) {
1819 PVE
::QemuConfig-
>add_unused_volume($conf, $volid, $vmid);
1824 # smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str][,base64=bool]
1828 pattern
=> '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
1829 format_description
=> 'UUID',
1830 description
=> "Set SMBIOS1 UUID.",
1835 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1836 format_description
=> 'Base64 encoded string',
1837 description
=> "Set SMBIOS1 version.",
1842 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1843 format_description
=> 'Base64 encoded string',
1844 description
=> "Set SMBIOS1 serial number.",
1849 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1850 format_description
=> 'Base64 encoded string',
1851 description
=> "Set SMBIOS1 manufacturer.",
1856 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1857 format_description
=> 'Base64 encoded string',
1858 description
=> "Set SMBIOS1 product ID.",
1863 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1864 format_description
=> 'Base64 encoded string',
1865 description
=> "Set SMBIOS1 SKU string.",
1870 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1871 format_description
=> 'Base64 encoded string',
1872 description
=> "Set SMBIOS1 family string.",
1877 description
=> 'Flag to indicate that the SMBIOS values are base64 encoded',
1885 my $res = eval { PVE
::JSONSchema
::parse_property_string
($smbios1_fmt, $data) };
1892 return PVE
::JSONSchema
::print_property_string
($smbios1, $smbios1_fmt);
1895 PVE
::JSONSchema
::register_format
('pve-qm-smbios1', $smbios1_fmt);
1897 sub parse_watchdog
{
1900 return undef if !$value;
1902 my $res = eval { PVE
::JSONSchema
::parse_property_string
($watchdog_fmt, $value) };
1907 sub parse_guest_agent
{
1910 return {} if !defined($value->{agent
});
1912 my $res = eval { PVE
::JSONSchema
::parse_property_string
($agent_fmt, $value->{agent
}) };
1915 # if the agent is disabled ignore the other potentially set properties
1916 return {} if !$res->{enabled
};
1923 return {} if !$value;
1924 my $res = eval { PVE
::JSONSchema
::parse_property_string
($vga_fmt, $value) };
1932 return undef if !$value;
1934 my $res = eval { PVE
::JSONSchema
::parse_property_string
($rng_fmt, $value) };
1939 PVE
::JSONSchema
::register_format
('pve-qm-usb-device', \
&verify_usb_device
);
1940 sub verify_usb_device
{
1941 my ($value, $noerr) = @_;
1943 return $value if parse_usb_device
($value);
1945 return undef if $noerr;
1947 die "unable to parse usb device\n";
1950 # add JSON properties for create and set function
1951 sub json_config_properties
{
1954 foreach my $opt (keys %$confdesc) {
1955 next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate' || $opt eq 'runningmachine';
1956 $prop->{$opt} = $confdesc->{$opt};
1962 # return copy of $confdesc_cloudinit to generate documentation
1963 sub cloudinit_config_properties
{
1965 return dclone
($confdesc_cloudinit);
1969 my ($key, $value) = @_;
1971 die "unknown setting '$key'\n" if !$confdesc->{$key};
1973 my $type = $confdesc->{$key}->{type
};
1975 if (!defined($value)) {
1976 die "got undefined value\n";
1979 if ($value =~ m/[\n\r]/) {
1980 die "property contains a line feed\n";
1983 if ($type eq 'boolean') {
1984 return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
1985 return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
1986 die "type check ('boolean') failed - got '$value'\n";
1987 } elsif ($type eq 'integer') {
1988 return int($1) if $value =~ m/^(\d+)$/;
1989 die "type check ('integer') failed - got '$value'\n";
1990 } elsif ($type eq 'number') {
1991 return $value if $value =~ m/^(\d+)(\.\d+)?$/;
1992 die "type check ('number') failed - got '$value'\n";
1993 } elsif ($type eq 'string') {
1994 if (my $fmt = $confdesc->{$key}->{format
}) {
1995 PVE
::JSONSchema
::check_format
($fmt, $value);
1998 $value =~ s/^\"(.*)\"$/$1/;
2001 die "internal error"
2006 my ($storecfg, $vmid, $skiplock, $replacement_conf) = @_;
2008 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2010 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
2012 if ($conf->{template
}) {
2013 # check if any base image is still used by a linked clone
2014 foreach_drive
($conf, sub {
2015 my ($ds, $drive) = @_;
2016 return if drive_is_cdrom
($drive);
2018 my $volid = $drive->{file
};
2019 return if !$volid || $volid =~ m
|^/|;
2021 die "base volume '$volid' is still in use by linked cloned\n"
2022 if PVE
::Storage
::volume_is_base_and_used
($storecfg, $volid);
2027 # only remove disks owned by this VM
2028 foreach_drive
($conf, sub {
2029 my ($ds, $drive) = @_;
2030 return if drive_is_cdrom
($drive, 1);
2032 my $volid = $drive->{file
};
2033 return if !$volid || $volid =~ m
|^/|;
2035 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
2036 return if !$path || !$owner || ($owner != $vmid);
2038 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid) };
2039 warn "Could not remove disk '$volid', check manually: $@" if $@;
2042 # also remove unused disk
2043 my $vmdisks = PVE
::Storage
::vdisk_list
($storecfg, undef, $vmid);
2044 PVE
::Storage
::foreach_volid
($vmdisks, sub {
2045 my ($volid, $sid, $volname, $d) = @_;
2046 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid) };
2050 if (defined $replacement_conf) {
2051 PVE
::QemuConfig-
>write_config($vmid, $replacement_conf);
2053 PVE
::QemuConfig-
>destroy_config($vmid);
2057 sub parse_vm_config
{
2058 my ($filename, $raw) = @_;
2060 return undef if !defined($raw);
2063 digest
=> Digest
::SHA
::sha1_hex
($raw),
2068 $filename =~ m
|/qemu-server/(\d
+)\
.conf
$|
2069 || die "got strange filename '$filename'";
2077 my @lines = split(/\n/, $raw);
2078 foreach my $line (@lines) {
2079 next if $line =~ m/^\s*$/;
2081 if ($line =~ m/^\[PENDING\]\s*$/i) {
2082 $section = 'pending';
2083 if (defined($descr)) {
2085 $conf->{description
} = $descr;
2088 $conf = $res->{$section} = {};
2091 } elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
2093 if (defined($descr)) {
2095 $conf->{description
} = $descr;
2098 $conf = $res->{snapshots
}->{$section} = {};
2102 if ($line =~ m/^\#(.*)\s*$/) {
2103 $descr = '' if !defined($descr);
2104 $descr .= PVE
::Tools
::decode_text
($1) . "\n";
2108 if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
2109 $descr = '' if !defined($descr);
2110 $descr .= PVE
::Tools
::decode_text
($2);
2111 } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
2112 $conf->{snapstate
} = $1;
2113 } elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
2116 $conf->{$key} = $value;
2117 } elsif ($line =~ m/^delete:\s*(.*\S)\s*$/) {
2119 if ($section eq 'pending') {
2120 $conf->{delete} = $value; # we parse this later
2122 warn "vm $vmid - propertry 'delete' is only allowed in [PENDING]\n";
2124 } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(.+?)\s*$/) {
2127 eval { $value = check_type
($key, $value); };
2129 warn "vm $vmid - unable to parse value of '$key' - $@";
2131 $key = 'ide2' if $key eq 'cdrom';
2132 my $fmt = $confdesc->{$key}->{format
};
2133 if ($fmt && $fmt =~ /^pve-qm-(?:ide|scsi|virtio|sata)$/) {
2134 my $v = parse_drive
($key, $value);
2135 if (my $volid = filename_to_volume_id
($vmid, $v->{file
}, $v->{media
})) {
2136 $v->{file
} = $volid;
2137 $value = print_drive
($v);
2139 warn "vm $vmid - unable to parse value of '$key'\n";
2144 $conf->{$key} = $value;
2149 if (defined($descr)) {
2151 $conf->{description
} = $descr;
2153 delete $res->{snapstate
}; # just to be sure
2158 sub write_vm_config
{
2159 my ($filename, $conf) = @_;
2161 delete $conf->{snapstate
}; # just to be sure
2163 if ($conf->{cdrom
}) {
2164 die "option ide2 conflicts with cdrom\n" if $conf->{ide2
};
2165 $conf->{ide2
} = $conf->{cdrom
};
2166 delete $conf->{cdrom
};
2169 # we do not use 'smp' any longer
2170 if ($conf->{sockets
}) {
2171 delete $conf->{smp
};
2172 } elsif ($conf->{smp
}) {
2173 $conf->{sockets
} = $conf->{smp
};
2174 delete $conf->{cores
};
2175 delete $conf->{smp
};
2178 my $used_volids = {};
2180 my $cleanup_config = sub {
2181 my ($cref, $pending, $snapname) = @_;
2183 foreach my $key (keys %$cref) {
2184 next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots' ||
2185 $key eq 'snapstate' || $key eq 'pending';
2186 my $value = $cref->{$key};
2187 if ($key eq 'delete') {
2188 die "propertry 'delete' is only allowed in [PENDING]\n"
2190 # fixme: check syntax?
2193 eval { $value = check_type
($key, $value); };
2194 die "unable to parse value of '$key' - $@" if $@;
2196 $cref->{$key} = $value;
2198 if (!$snapname && is_valid_drivename
($key)) {
2199 my $drive = parse_drive
($key, $value);
2200 $used_volids->{$drive->{file
}} = 1 if $drive && $drive->{file
};
2205 &$cleanup_config($conf);
2207 &$cleanup_config($conf->{pending
}, 1);
2209 foreach my $snapname (keys %{$conf->{snapshots
}}) {
2210 die "internal error: snapshot name '$snapname' is forbidden" if lc($snapname) eq 'pending';
2211 &$cleanup_config($conf->{snapshots
}->{$snapname}, undef, $snapname);
2214 # remove 'unusedX' settings if we re-add a volume
2215 foreach my $key (keys %$conf) {
2216 my $value = $conf->{$key};
2217 if ($key =~ m/^unused/ && $used_volids->{$value}) {
2218 delete $conf->{$key};
2222 my $generate_raw_config = sub {
2223 my ($conf, $pending) = @_;
2227 # add description as comment to top of file
2228 if (defined(my $descr = $conf->{description
})) {
2230 foreach my $cl (split(/\n/, $descr)) {
2231 $raw .= '#' . PVE
::Tools
::encode_text
($cl) . "\n";
2234 $raw .= "#\n" if $pending;
2238 foreach my $key (sort keys %$conf) {
2239 next if $key eq 'digest' || $key eq 'description' || $key eq 'pending' || $key eq 'snapshots';
2240 $raw .= "$key: $conf->{$key}\n";
2245 my $raw = &$generate_raw_config($conf);
2247 if (scalar(keys %{$conf->{pending
}})){
2248 $raw .= "\n[PENDING]\n";
2249 $raw .= &$generate_raw_config($conf->{pending
}, 1);
2252 foreach my $snapname (sort keys %{$conf->{snapshots
}}) {
2253 $raw .= "\n[$snapname]\n";
2254 $raw .= &$generate_raw_config($conf->{snapshots
}->{$snapname});
2264 # we use static defaults from our JSON schema configuration
2265 foreach my $key (keys %$confdesc) {
2266 if (defined(my $default = $confdesc->{$key}->{default})) {
2267 $res->{$key} = $default;
2275 my $vmlist = PVE
::Cluster
::get_vmlist
();
2277 return $res if !$vmlist || !$vmlist->{ids
};
2278 my $ids = $vmlist->{ids
};
2279 my $nodename = nodename
();
2281 foreach my $vmid (keys %$ids) {
2282 my $d = $ids->{$vmid};
2283 next if !$d->{node
} || $d->{node
} ne $nodename;
2284 next if !$d->{type
} || $d->{type
} ne 'qemu';
2285 $res->{$vmid}->{exists} = 1;
2290 # test if VM uses local resources (to prevent migration)
2291 sub check_local_resources
{
2292 my ($conf, $noerr) = @_;
2296 push @loc_res, "hostusb" if $conf->{hostusb
}; # old syntax
2297 push @loc_res, "hostpci" if $conf->{hostpci
}; # old syntax
2299 push @loc_res, "ivshmem" if $conf->{ivshmem
};
2301 foreach my $k (keys %$conf) {
2302 next if $k =~ m/^usb/ && ($conf->{$k} =~ m/^spice(?![^,])/);
2303 # sockets are safe: they will recreated be on the target side post-migrate
2304 next if $k =~ m/^serial/ && ($conf->{$k} eq 'socket');
2305 push @loc_res, $k if $k =~ m/^(usb|hostpci|serial|parallel)\d+$/;
2308 die "VM uses local resources\n" if scalar @loc_res && !$noerr;
2313 # check if used storages are available on all nodes (use by migrate)
2314 sub check_storage_availability
{
2315 my ($storecfg, $conf, $node) = @_;
2317 foreach_drive
($conf, sub {
2318 my ($ds, $drive) = @_;
2320 my $volid = $drive->{file
};
2323 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2326 # check if storage is available on both nodes
2327 my $scfg = PVE
::Storage
::storage_check_node
($storecfg, $sid);
2328 PVE
::Storage
::storage_check_node
($storecfg, $sid, $node);
2332 # list nodes where all VM images are available (used by has_feature API)
2334 my ($conf, $storecfg) = @_;
2336 my $nodelist = PVE
::Cluster
::get_nodelist
();
2337 my $nodehash = { map { $_ => 1 } @$nodelist };
2338 my $nodename = nodename
();
2340 foreach_drive
($conf, sub {
2341 my ($ds, $drive) = @_;
2343 my $volid = $drive->{file
};
2346 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2348 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2349 if ($scfg->{disable
}) {
2351 } elsif (my $avail = $scfg->{nodes
}) {
2352 foreach my $node (keys %$nodehash) {
2353 delete $nodehash->{$node} if !$avail->{$node};
2355 } elsif (!$scfg->{shared
}) {
2356 foreach my $node (keys %$nodehash) {
2357 delete $nodehash->{$node} if $node ne $nodename
2366 sub check_local_storage_availability
{
2367 my ($conf, $storecfg) = @_;
2369 my $nodelist = PVE
::Cluster
::get_nodelist
();
2370 my $nodehash = { map { $_ => {} } @$nodelist };
2372 foreach_drive
($conf, sub {
2373 my ($ds, $drive) = @_;
2375 my $volid = $drive->{file
};
2378 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2380 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2382 if ($scfg->{disable
}) {
2383 foreach my $node (keys %$nodehash) {
2384 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
2386 } elsif (my $avail = $scfg->{nodes
}) {
2387 foreach my $node (keys %$nodehash) {
2388 if (!$avail->{$node}) {
2389 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
2396 foreach my $node (values %$nodehash) {
2397 if (my $unavail = $node->{unavailable_storages
}) {
2398 $node->{unavailable_storages
} = [ sort keys %$unavail ];
2405 # Compat only, use assert_config_exists_on_node and vm_running_locally where possible
2407 my ($vmid, $nocheck, $node) = @_;
2409 PVE
::QemuConfig
::assert_config_exists_on_node
($vmid, $node) if !$nocheck;
2410 return PVE
::QemuServer
::Helpers
::vm_running_locally
($vmid);
2415 my $vzlist = config_list
();
2417 my $fd = IO
::Dir-
>new($PVE::QemuServer
::Helpers
::var_run_tmpdir
) || return $vzlist;
2419 while (defined(my $de = $fd->read)) {
2420 next if $de !~ m/^(\d+)\.pid$/;
2422 next if !defined($vzlist->{$vmid});
2423 if (my $pid = check_running
($vmid)) {
2424 $vzlist->{$vmid}->{pid
} = $pid;
2431 our $vmstatus_return_properties = {
2432 vmid
=> get_standard_option
('pve-vmid'),
2434 description
=> "Qemu process status.",
2436 enum
=> ['stopped', 'running'],
2439 description
=> "Maximum memory in bytes.",
2442 renderer
=> 'bytes',
2445 description
=> "Root disk size in bytes.",
2448 renderer
=> 'bytes',
2451 description
=> "VM name.",
2456 description
=> "Qemu QMP agent status.",
2461 description
=> "PID of running qemu process.",
2466 description
=> "Uptime.",
2469 renderer
=> 'duration',
2472 description
=> "Maximum usable CPUs.",
2477 description
=> "The current config lock, if any.",
2482 description
=> "The current configured tags, if any",
2488 my $last_proc_pid_stat;
2490 # get VM status information
2491 # This must be fast and should not block ($full == false)
2492 # We only query KVM using QMP if $full == true (this can be slow)
2494 my ($opt_vmid, $full) = @_;
2498 my $storecfg = PVE
::Storage
::config
();
2500 my $list = vzlist
();
2501 my $defaults = load_defaults
();
2503 my ($uptime) = PVE
::ProcFSTools
::read_proc_uptime
(1);
2505 my $cpucount = $cpuinfo->{cpus
} || 1;
2507 foreach my $vmid (keys %$list) {
2508 next if $opt_vmid && ($vmid ne $opt_vmid);
2510 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2512 my $d = { vmid
=> $vmid };
2513 $d->{pid
} = $list->{$vmid}->{pid
};
2515 # fixme: better status?
2516 $d->{status
} = $list->{$vmid}->{pid
} ?
'running' : 'stopped';
2518 my $size = PVE
::QemuServer
::Drive
::bootdisk_size
($storecfg, $conf);
2519 if (defined($size)) {
2520 $d->{disk
} = 0; # no info available
2521 $d->{maxdisk
} = $size;
2527 $d->{cpus
} = ($conf->{sockets
} || $defaults->{sockets
})
2528 * ($conf->{cores
} || $defaults->{cores
});
2529 $d->{cpus
} = $cpucount if $d->{cpus
} > $cpucount;
2530 $d->{cpus
} = $conf->{vcpus
} if $conf->{vcpus
};
2532 $d->{name
} = $conf->{name
} || "VM $vmid";
2533 $d->{maxmem
} = $conf->{memory
} ?
$conf->{memory
}*(1024*1024)
2534 : $defaults->{memory
}*(1024*1024);
2536 if ($conf->{balloon
}) {
2537 $d->{balloon_min
} = $conf->{balloon
}*(1024*1024);
2538 $d->{shares
} = defined($conf->{shares
}) ?
$conf->{shares
}
2539 : $defaults->{shares
};
2550 $d->{diskwrite
} = 0;
2552 $d->{template
} = PVE
::QemuConfig-
>is_template($conf);
2554 $d->{serial
} = 1 if conf_has_serial
($conf);
2555 $d->{lock} = $conf->{lock} if $conf->{lock};
2556 $d->{tags
} = $conf->{tags
} if defined($conf->{tags
});
2561 my $netdev = PVE
::ProcFSTools
::read_proc_net_dev
();
2562 foreach my $dev (keys %$netdev) {
2563 next if $dev !~ m/^tap([1-9]\d*)i/;
2565 my $d = $res->{$vmid};
2568 $d->{netout
} += $netdev->{$dev}->{receive
};
2569 $d->{netin
} += $netdev->{$dev}->{transmit
};
2572 $d->{nics
}->{$dev}->{netout
} = $netdev->{$dev}->{receive
};
2573 $d->{nics
}->{$dev}->{netin
} = $netdev->{$dev}->{transmit
};
2578 my $ctime = gettimeofday
;
2580 foreach my $vmid (keys %$list) {
2582 my $d = $res->{$vmid};
2583 my $pid = $d->{pid
};
2586 my $pstat = PVE
::ProcFSTools
::read_proc_pid_stat
($pid);
2587 next if !$pstat; # not running
2589 my $used = $pstat->{utime} + $pstat->{stime
};
2591 $d->{uptime
} = int(($uptime - $pstat->{starttime
})/$cpuinfo->{user_hz
});
2593 if ($pstat->{vsize
}) {
2594 $d->{mem
} = int(($pstat->{rss
}/$pstat->{vsize
})*$d->{maxmem
});
2597 my $old = $last_proc_pid_stat->{$pid};
2599 $last_proc_pid_stat->{$pid} = {
2607 my $dtime = ($ctime - $old->{time}) * $cpucount * $cpuinfo->{user_hz
};
2609 if ($dtime > 1000) {
2610 my $dutime = $used - $old->{used
};
2612 $d->{cpu
} = (($dutime/$dtime)* $cpucount) / $d->{cpus
};
2613 $last_proc_pid_stat->{$pid} = {
2619 $d->{cpu
} = $old->{cpu
};
2623 return $res if !$full;
2625 my $qmpclient = PVE
::QMPClient-
>new();
2627 my $ballooncb = sub {
2628 my ($vmid, $resp) = @_;
2630 my $info = $resp->{'return'};
2631 return if !$info->{max_mem
};
2633 my $d = $res->{$vmid};
2635 # use memory assigned to VM
2636 $d->{maxmem
} = $info->{max_mem
};
2637 $d->{balloon
} = $info->{actual
};
2639 if (defined($info->{total_mem
}) && defined($info->{free_mem
})) {
2640 $d->{mem
} = $info->{total_mem
} - $info->{free_mem
};
2641 $d->{freemem
} = $info->{free_mem
};
2644 $d->{ballooninfo
} = $info;
2647 my $blockstatscb = sub {
2648 my ($vmid, $resp) = @_;
2649 my $data = $resp->{'return'} || [];
2650 my $totalrdbytes = 0;
2651 my $totalwrbytes = 0;
2653 for my $blockstat (@$data) {
2654 $totalrdbytes = $totalrdbytes + $blockstat->{stats
}->{rd_bytes
};
2655 $totalwrbytes = $totalwrbytes + $blockstat->{stats
}->{wr_bytes
};
2657 $blockstat->{device
} =~ s/drive-//;
2658 $res->{$vmid}->{blockstat
}->{$blockstat->{device
}} = $blockstat->{stats
};
2660 $res->{$vmid}->{diskread
} = $totalrdbytes;
2661 $res->{$vmid}->{diskwrite
} = $totalwrbytes;
2664 my $statuscb = sub {
2665 my ($vmid, $resp) = @_;
2667 $qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
2668 # this fails if ballon driver is not loaded, so this must be
2669 # the last commnand (following command are aborted if this fails).
2670 $qmpclient->queue_cmd($vmid, $ballooncb, 'query-balloon');
2672 my $status = 'unknown';
2673 if (!defined($status = $resp->{'return'}->{status
})) {
2674 warn "unable to get VM status\n";
2678 $res->{$vmid}->{qmpstatus
} = $resp->{'return'}->{status
};
2681 foreach my $vmid (keys %$list) {
2682 next if $opt_vmid && ($vmid ne $opt_vmid);
2683 next if !$res->{$vmid}->{pid
}; # not running
2684 $qmpclient->queue_cmd($vmid, $statuscb, 'query-status');
2687 $qmpclient->queue_execute(undef, 2);
2689 foreach my $vmid (keys %$list) {
2690 next if $opt_vmid && ($vmid ne $opt_vmid);
2691 $res->{$vmid}->{qmpstatus
} = $res->{$vmid}->{status
} if !$res->{$vmid}->{qmpstatus
};
2697 sub conf_has_serial
{
2700 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
2701 if ($conf->{"serial$i"}) {
2709 sub conf_has_audio
{
2710 my ($conf, $id) = @_;
2713 my $audio = $conf->{"audio$id"};
2714 return undef if !defined($audio);
2716 my $audioproperties = PVE
::JSONSchema
::parse_property_string
($audio_fmt, $audio);
2717 my $audiodriver = $audioproperties->{driver
} // 'spice';
2720 dev
=> $audioproperties->{device
},
2721 dev_id
=> "audiodev$id",
2722 backend
=> $audiodriver,
2723 backend_id
=> "$audiodriver-backend${id}",
2727 sub vga_conf_has_spice
{
2730 my $vgaconf = parse_vga
($vga);
2731 my $vgatype = $vgaconf->{type
};
2732 return 0 if !$vgatype || $vgatype !~ m/^qxl([234])?$/;
2739 return get_host_arch
() eq $arch;
2744 return $conf->{arch
} // get_host_arch
();
2747 my $default_machines = {
2752 sub get_vm_machine
{
2753 my ($conf, $forcemachine, $arch, $add_pve_version, $kvmversion) = @_;
2755 my $machine = $forcemachine || $conf->{machine
};
2757 if (!$machine || $machine =~ m/^(?:pc|q35|virt)$/) {
2759 $machine ||= $default_machines->{$arch};
2760 if ($add_pve_version) {
2761 $kvmversion //= kvm_user_version
();
2762 my $pvever = PVE
::QemuServer
::Machine
::get_pve_version
($kvmversion);
2763 $machine .= "+pve$pvever";
2767 if ($add_pve_version && $machine !~ m/\+pve\d+$/) {
2768 # for version-pinned machines that do not include a pve-version (e.g.
2769 # pc-q35-4.1), we assume 0 to keep them stable in case we bump
2770 $machine .= '+pve0';
2776 sub get_ovmf_files
($) {
2779 my $ovmf = $OVMF->{$arch}
2780 or die "no OVMF images known for architecture '$arch'\n";
2786 aarch64
=> '/usr/bin/qemu-system-aarch64',
2787 x86_64
=> '/usr/bin/qemu-system-x86_64',
2789 sub get_command_for_arch
($) {
2791 return '/usr/bin/kvm' if is_native
($arch);
2793 my $cmd = $Arch2Qemu->{$arch}
2794 or die "don't know how to emulate architecture '$arch'\n";
2798 # To use query_supported_cpu_flags and query_understood_cpu_flags to get flags
2799 # to use in a QEMU command line (-cpu element), first array_intersect the result
2800 # of query_supported_ with query_understood_. This is necessary because:
2802 # a) query_understood_ returns flags the host cannot use and
2803 # b) query_supported_ (rather the QMP call) doesn't actually return CPU
2804 # flags, but CPU settings - with most of them being flags. Those settings
2805 # (and some flags, curiously) cannot be specified as a "-cpu" argument.
2807 # query_supported_ needs to start up to 2 temporary VMs and is therefore rather
2808 # expensive. If you need the value returned from this, you can get it much
2809 # cheaper from pmxcfs using PVE::Cluster::get_node_kv('cpuflags-$accel') with
2810 # $accel being 'kvm' or 'tcg'.
2812 # pvestatd calls this function on startup and whenever the QEMU/KVM version
2813 # changes, automatically populating pmxcfs.
2815 # Returns: { kvm => [ flagX, flagY, ... ], tcg => [ flag1, flag2, ... ] }
2816 # since kvm and tcg machines support different flags
2818 sub query_supported_cpu_flags
{
2821 $arch //= get_host_arch
();
2822 my $default_machine = $default_machines->{$arch};
2826 # FIXME: Once this is merged, the code below should work for ARM as well:
2827 # https://lists.nongnu.org/archive/html/qemu-devel/2019-06/msg04947.html
2828 die "QEMU/KVM cannot detect CPU flags on ARM (aarch64)\n" if
2831 my $kvm_supported = defined(kvm_version
());
2832 my $qemu_cmd = get_command_for_arch
($arch);
2834 my $pidfile = PVE
::QemuServer
::Helpers
::pidfile_name
($fakevmid);
2836 # Start a temporary (frozen) VM with vmid -1 to allow sending a QMP command
2837 my $query_supported_run_qemu = sub {
2843 '-machine', $default_machine,
2845 '-chardev', "socket,id=qmp,path=/var/run/qemu-server/$fakevmid.qmp,server,nowait",
2846 '-mon', 'chardev=qmp,mode=control',
2847 '-pidfile', $pidfile,
2852 push @$cmd, '-accel', 'tcg';
2855 my $rc = run_command
($cmd, noerr
=> 1, quiet
=> 0);
2856 die "QEMU flag querying VM exited with code " . $rc if $rc;
2859 my $cmd_result = mon_cmd
(
2861 'query-cpu-model-expansion',
2863 model
=> { name
=> 'host' }
2866 my $props = $cmd_result->{model
}->{props
};
2867 foreach my $prop (keys %$props) {
2868 next if $props->{$prop} ne '1';
2869 # QEMU returns some flags multiple times, with '_', '.' or '-'
2870 # (e.g. lahf_lm and lahf-lm; sse4.2, sse4-2 and sse4_2; ...).
2871 # We only keep those with underscores, to match /proc/cpuinfo
2872 $prop =~ s/\.|-/_/g;
2873 $flags->{$prop} = 1;
2878 # force stop with 10 sec timeout and 'nocheck'
2879 # always stop, even if QMP failed
2880 vm_stop
(undef, $fakevmid, 1, 1, 10, 0, 1);
2884 return [ sort keys %$flags ];
2887 # We need to query QEMU twice, since KVM and TCG have different supported flags
2888 PVE
::QemuConfig-
>lock_config($fakevmid, sub {
2889 $flags->{tcg
} = eval { $query_supported_run_qemu->(0) };
2890 warn "warning: failed querying supported tcg flags: $@\n" if $@;
2892 if ($kvm_supported) {
2893 $flags->{kvm
} = eval { $query_supported_run_qemu->(1) };
2894 warn "warning: failed querying supported kvm flags: $@\n" if $@;
2901 # Understood CPU flags are written to a file at 'pve-qemu' compile time
2902 my $understood_cpu_flag_dir = "/usr/share/kvm";
2903 sub query_understood_cpu_flags
{
2904 my $arch = get_host_arch
();
2905 my $filepath = "$understood_cpu_flag_dir/recognized-CPUID-flags-$arch";
2907 die "Cannot query understood QEMU CPU flags for architecture: $arch (file not found)\n"
2910 my $raw = file_get_contents
($filepath);
2911 $raw =~ s/^\s+|\s+$//g;
2912 my @flags = split(/\s+/, $raw);
2917 sub config_to_command
{
2918 my ($storecfg, $vmid, $conf, $defaults, $forcemachine) = @_;
2921 my $globalFlags = [];
2922 my $machineFlags = [];
2927 my $ostype = $conf->{ostype
};
2928 my $winversion = windows_version
($ostype);
2929 my $kvm = $conf->{kvm
};
2930 my $nodename = nodename
();
2932 my $arch = get_vm_arch
($conf);
2933 my $kvm_binary = get_command_for_arch
($arch);
2934 my $kvmver = kvm_user_version
($kvm_binary);
2936 if (!$kvmver || $kvmver !~ m/^(\d+)\.(\d+)/ || $1 < 3) {
2937 $kvmver //= "undefined";
2938 die "Detected old QEMU binary ('$kvmver', at least 3.0 is required)\n";
2941 my $add_pve_version = min_version
($kvmver, 4, 1);
2943 my $machine_type = get_vm_machine
($conf, $forcemachine, $arch, $add_pve_version);
2944 my $machine_version = PVE
::QemuServer
::Machine
::extract_version
($machine_type, $kvmver);
2945 $kvm //= 1 if is_native
($arch);
2947 $machine_version =~ m/(\d+)\.(\d+)/;
2948 my ($machine_major, $machine_minor) = ($1, $2);
2949 die "Installed QEMU version '$kvmver' is too old to run machine type '$machine_type', please upgrade node '$nodename'\n"
2950 if !PVE
::QemuServer
::min_version
($kvmver, $machine_major, $machine_minor);
2952 if (!PVE
::QemuServer
::Machine
::can_run_pve_machine_version
($machine_version, $kvmver)) {
2953 my $max_pve_version = PVE
::QemuServer
::Machine
::get_pve_version
($machine_version);
2954 die "Installed qemu-server (max feature level for $machine_major.$machine_minor is pve$max_pve_version)"
2955 . " is too old to run machine type '$machine_type', please upgrade node '$nodename'\n";
2958 # if a specific +pve version is required for a feature, use $version_guard
2959 # instead of min_version to allow machines to be run with the minimum
2961 my $required_pve_version = 0;
2962 my $version_guard = sub {
2963 my ($major, $minor, $pve) = @_;
2964 return 0 if !min_version
($machine_version, $major, $minor, $pve);
2965 $required_pve_version = $pve if $pve && $pve > $required_pve_version;
2970 die "KVM virtualisation configured, but not available. Either disable in VM configuration or enable in BIOS.\n"
2971 if !defined kvm_version
();
2974 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
2975 my $hotplug_features = parse_hotplug_features
(defined($conf->{hotplug
}) ?
$conf->{hotplug
} : '1');
2976 my $use_old_bios_files = undef;
2977 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
2979 my $cpuunits = defined($conf->{cpuunits
}) ?
2980 $conf->{cpuunits
} : $defaults->{cpuunits
};
2982 push @$cmd, $kvm_binary;
2984 push @$cmd, '-id', $vmid;
2986 my $vmname = $conf->{name
} || "vm$vmid";
2988 push @$cmd, '-name', $vmname;
2992 my $qmpsocket = PVE
::QemuServer
::Helpers
::qmp_socket
($vmid);
2993 push @$cmd, '-chardev', "socket,id=qmp,path=$qmpsocket,server,nowait";
2994 push @$cmd, '-mon', "chardev=qmp,mode=control";
2996 if (min_version
($machine_version, 2, 12)) {
2997 push @$cmd, '-chardev', "socket,id=qmp-event,path=/var/run/qmeventd.sock,reconnect=5";
2998 push @$cmd, '-mon', "chardev=qmp-event,mode=control";
3001 push @$cmd, '-pidfile' , PVE
::QemuServer
::Helpers
::pidfile_name
($vmid);
3003 push @$cmd, '-daemonize';
3005 if ($conf->{smbios1
}) {
3006 my $smbios_conf = parse_smbios1
($conf->{smbios1
});
3007 if ($smbios_conf->{base64
}) {
3008 # Do not pass base64 flag to qemu
3009 delete $smbios_conf->{base64
};
3010 my $smbios_string = "";
3011 foreach my $key (keys %$smbios_conf) {
3013 if ($key eq "uuid") {
3014 $value = $smbios_conf->{uuid
}
3016 $value = decode_base64
($smbios_conf->{$key});
3018 # qemu accepts any binary data, only commas need escaping by double comma
3020 $smbios_string .= "," . $key . "=" . $value if $value;
3022 push @$cmd, '-smbios', "type=1" . $smbios_string;
3024 push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
3028 my ($ovmf_code, $ovmf_vars) = get_ovmf_files
($arch);
3029 if ($conf->{bios
} && $conf->{bios
} eq 'ovmf') {
3030 die "uefi base image not found\n" if ! -f
$ovmf_code;
3034 if (my $efidisk = $conf->{efidisk0
}) {
3035 my $d = parse_drive
('efidisk0', $efidisk);
3036 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($d->{file
}, 1);
3037 $format = $d->{format
};
3039 $path = PVE
::Storage
::path
($storecfg, $d->{file
});
3040 if (!defined($format)) {
3041 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
3042 $format = qemu_img_format
($scfg, $volname);
3046 die "efidisk format must be specified\n"
3047 if !defined($format);
3050 warn "no efidisk configured! Using temporary efivars disk.\n";
3051 $path = "/tmp/$vmid-ovmf.fd";
3052 PVE
::Tools
::file_copy
($ovmf_vars, $path, -s
$ovmf_vars);
3056 push @$cmd, '-drive', "if=pflash,unit=0,format=raw,readonly,file=$ovmf_code";
3057 push @$cmd, '-drive', "if=pflash,unit=1,format=$format,id=drive-efidisk0,file=$path";
3062 # we use different pcie-port hardware for qemu >= 4.0 for passthrough
3063 if (min_version
($machine_version, 4, 0)) {
3064 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35-4.0.cfg';
3066 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35.cfg';
3070 if ($conf->{vmgenid
}) {
3071 push @$devices, '-device', 'vmgenid,guid='.$conf->{vmgenid
};
3074 # add usb controllers
3075 my @usbcontrollers = PVE
::QemuServer
::USB
::get_usb_controllers
($conf, $bridges, $arch, $machine_type, $usbdesc->{format
}, $MAX_USB_DEVICES);
3076 push @$devices, @usbcontrollers if @usbcontrollers;
3077 my $vga = parse_vga
($conf->{vga
});
3079 my $qxlnum = vga_conf_has_spice
($conf->{vga
});
3080 $vga->{type
} = 'qxl' if $qxlnum;
3082 if (!$vga->{type
}) {
3083 if ($arch eq 'aarch64') {
3084 $vga->{type
} = 'virtio';
3085 } elsif (min_version
($machine_version, 2, 9)) {
3086 $vga->{type
} = (!$winversion || $winversion >= 6) ?
'std' : 'cirrus';
3088 $vga->{type
} = ($winversion >= 6) ?
'std' : 'cirrus';
3092 # enable absolute mouse coordinates (needed by vnc)
3094 if (defined($conf->{tablet
})) {
3095 $tablet = $conf->{tablet
};
3097 $tablet = $defaults->{tablet
};
3098 $tablet = 0 if $qxlnum; # disable for spice because it is not needed
3099 $tablet = 0 if $vga->{type
} =~ m/^serial\d+$/; # disable if we use serial terminal (no vga card)
3103 push @$devices, '-device', print_tabletdevice_full
($conf, $arch) if $tablet;
3104 my $kbd = print_keyboarddevice_full
($conf, $arch);
3105 push @$devices, '-device', $kbd if defined($kbd);
3109 my $gpu_passthrough;
3112 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
3113 my $id = "hostpci$i";
3114 my $d = parse_hostpci
($conf->{$id});
3117 if (my $pcie = $d->{pcie
}) {
3118 die "q35 machine model is not enabled" if !$q35;
3119 # win7 wants to have the pcie devices directly on the pcie bus
3120 # instead of in the root port
3121 if ($winversion == 7) {
3122 $pciaddr = print_pcie_addr
("${id}bus0");
3124 # add more root ports if needed, 4 are present by default
3125 # by pve-q35 cfgs, rest added here on demand.
3127 push @$devices, '-device', print_pcie_root_port
($i);
3129 $pciaddr = print_pcie_addr
($id);
3132 $pciaddr = print_pci_addr
($id, $bridges, $arch, $machine_type);
3136 if ($d->{'x-vga'}) {
3137 $xvga = ',x-vga=on' if !($conf->{bios
} && $conf->{bios
} eq 'ovmf');
3139 $vga->{type
} = 'none' if !defined($conf->{vga
});
3140 $gpu_passthrough = 1;
3143 my $pcidevices = $d->{pciid
};
3144 my $multifunction = 1 if @$pcidevices > 1;
3147 if ($d->{mdev
} && scalar(@$pcidevices) == 1) {
3148 my $pci_id = $pcidevices->[0]->{id
};
3149 my $uuid = PVE
::SysFSTools
::generate_mdev_uuid
($vmid, $i);
3150 $sysfspath = "/sys/bus/pci/devices/$pci_id/$uuid";
3151 } elsif ($d->{mdev
}) {
3152 warn "ignoring mediated device '$id' with multifunction device\n";
3156 foreach my $pcidevice (@$pcidevices) {
3157 my $devicestr = "vfio-pci";
3160 $devicestr .= ",sysfsdev=$sysfspath";
3162 $devicestr .= ",host=$pcidevice->{id}";
3165 my $mf_addr = $multifunction ?
".$j" : '';
3166 $devicestr .= ",id=${id}${mf_addr}${pciaddr}${mf_addr}";
3169 $devicestr .= ',rombar=0' if defined($d->{rombar
}) && !$d->{rombar
};
3170 $devicestr .= "$xvga";
3171 $devicestr .= ",multifunction=on" if $multifunction;
3172 $devicestr .= ",romfile=/usr/share/kvm/$d->{romfile}" if $d->{romfile
};
3175 push @$devices, '-device', $devicestr;
3181 my $usb_dev_features = {};
3182 $usb_dev_features->{spice_usb3
} = 1 if min_version
($machine_version, 4, 0);
3184 my @usbdevices = PVE
::QemuServer
::USB
::get_usb_devices
($conf, $usbdesc->{format
}, $MAX_USB_DEVICES, $usb_dev_features);
3185 push @$devices, @usbdevices if @usbdevices;
3187 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
3188 if (my $path = $conf->{"serial$i"}) {
3189 if ($path eq 'socket') {
3190 my $socket = "/var/run/qemu-server/${vmid}.serial$i";
3191 push @$devices, '-chardev', "socket,id=serial$i,path=$socket,server,nowait";
3192 # On aarch64, serial0 is the UART device. Qemu only allows
3193 # connecting UART devices via the '-serial' command line, as
3194 # the device has a fixed slot on the hardware...
3195 if ($arch eq 'aarch64' && $i == 0) {
3196 push @$devices, '-serial', "chardev:serial$i";
3198 push @$devices, '-device', "isa-serial,chardev=serial$i";
3201 die "no such serial device\n" if ! -c
$path;
3202 push @$devices, '-chardev', "tty,id=serial$i,path=$path";
3203 push @$devices, '-device', "isa-serial,chardev=serial$i";
3209 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
3210 if (my $path = $conf->{"parallel$i"}) {
3211 die "no such parallel device\n" if ! -c
$path;
3212 my $devtype = $path =~ m!^/dev/usb/lp! ?
'tty' : 'parport';
3213 push @$devices, '-chardev', "$devtype,id=parallel$i,path=$path";
3214 push @$devices, '-device', "isa-parallel,chardev=parallel$i";
3218 if (my $audio = conf_has_audio
($conf)) {
3220 my $audiopciaddr = print_pci_addr
("audio0", $bridges, $arch, $machine_type);
3222 my $id = $audio->{dev_id
};
3223 if ($audio->{dev
} eq 'AC97') {
3224 push @$devices, '-device', "AC97,id=${id}${audiopciaddr}";
3225 } elsif ($audio->{dev
} =~ /intel\-hda$/) {
3226 push @$devices, '-device', "$audio->{dev},id=${id}${audiopciaddr}";
3227 push @$devices, '-device', "hda-micro,id=${id}-codec0,bus=${id}.0,cad=0";
3228 push @$devices, '-device', "hda-duplex,id=${id}-codec1,bus=${id}.0,cad=1";
3230 die "unkown audio device '$audio->{dev}', implement me!";
3233 push @$devices, '-audiodev', "$audio->{backend},id=$audio->{backend_id}";
3237 $sockets = $conf->{smp
} if $conf->{smp
}; # old style - no longer iused
3238 $sockets = $conf->{sockets
} if $conf->{sockets
};
3240 my $cores = $conf->{cores
} || 1;
3242 my $maxcpus = $sockets * $cores;
3244 my $vcpus = $conf->{vcpus
} ?
$conf->{vcpus
} : $maxcpus;
3246 my $allowed_vcpus = $cpuinfo->{cpus
};
3248 die "MAX $allowed_vcpus vcpus allowed per VM on this node\n"
3249 if ($allowed_vcpus < $maxcpus);
3251 if($hotplug_features->{cpu
} && min_version
($machine_version, 2, 7)) {
3253 push @$cmd, '-smp', "1,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3254 for (my $i = 2; $i <= $vcpus; $i++) {
3255 my $cpustr = print_cpu_device
($conf,$i);
3256 push @$cmd, '-device', $cpustr;
3261 push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3263 push @$cmd, '-nodefaults';
3265 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
3267 my $bootindex_hash = {};
3269 foreach my $o (split(//, $bootorder)) {
3270 $bootindex_hash->{$o} = $i*100;
3274 push @$cmd, '-boot', "menu=on,strict=on,reboot-timeout=1000,splash=/usr/share/qemu-server/bootsplash.jpg";
3276 push @$cmd, '-no-acpi' if defined($conf->{acpi
}) && $conf->{acpi
} == 0;
3278 push @$cmd, '-no-reboot' if defined($conf->{reboot
}) && $conf->{reboot
} == 0;
3280 if ($vga->{type
} && $vga->{type
} !~ m/^serial\d+$/ && $vga->{type
} ne 'none'){
3281 push @$devices, '-device', print_vga_device
($conf, $vga, $arch, $machine_version, $machine_type, undef, $qxlnum, $bridges);
3282 my $socket = PVE
::QemuServer
::Helpers
::vnc_socket
($vmid);
3283 push @$cmd, '-vnc', "unix:$socket,password";
3285 push @$cmd, '-vga', 'none' if $vga->{type
} eq 'none';
3286 push @$cmd, '-nographic';
3290 my $tdf = defined($conf->{tdf
}) ?
$conf->{tdf
} : $defaults->{tdf
};
3292 my $useLocaltime = $conf->{localtime};
3294 if ($winversion >= 5) { # windows
3295 $useLocaltime = 1 if !defined($conf->{localtime});
3297 # use time drift fix when acpi is enabled
3298 if (!(defined($conf->{acpi
}) && $conf->{acpi
} == 0)) {
3299 $tdf = 1 if !defined($conf->{tdf
});
3303 if ($winversion >= 6) {
3304 push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
3305 push @$cmd, '-no-hpet';
3308 push @$rtcFlags, 'driftfix=slew' if $tdf;
3310 if (($conf->{startdate
}) && ($conf->{startdate
} ne 'now')) {
3311 push @$rtcFlags, "base=$conf->{startdate}";
3312 } elsif ($useLocaltime) {
3313 push @$rtcFlags, 'base=localtime';
3316 push @$cmd, get_cpu_options
($conf, $arch, $kvm, $kvm_off, $machine_version, $winversion, $gpu_passthrough);
3318 PVE
::QemuServer
::Memory
::config
($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd);
3320 push @$cmd, '-S' if $conf->{freeze
};
3322 push @$cmd, '-k', $conf->{keyboard
} if defined($conf->{keyboard
});
3324 my $guest_agent = parse_guest_agent
($conf);
3326 if ($guest_agent->{enabled
}) {
3327 my $qgasocket = PVE
::QemuServer
::Helpers
::qmp_socket
($vmid, 1);
3328 push @$devices, '-chardev', "socket,path=$qgasocket,server,nowait,id=qga0";
3330 if (!$guest_agent->{type
} || $guest_agent->{type
} eq 'virtio') {
3331 my $pciaddr = print_pci_addr
("qga0", $bridges, $arch, $machine_type);
3332 push @$devices, '-device', "virtio-serial,id=qga0$pciaddr";
3333 push @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
3334 } elsif ($guest_agent->{type
} eq 'isa') {
3335 push @$devices, '-device', "isa-serial,chardev=qga0";
3339 my $rng = parse_rng
($conf->{rng0
}) if $conf->{rng0
};
3340 if ($rng && &$version_guard(4, 1, 2)) {
3341 my $max_bytes = $rng->{max_bytes
} // $rng_fmt->{max_bytes
}->{default};
3342 my $period = $rng->{period
} // $rng_fmt->{period
}->{default};
3344 my $limiter_str = "";
3346 $limiter_str = ",max-bytes=$max_bytes,period=$period";
3349 # mostly relevant for /dev/hwrng, but doesn't hurt to check others too
3350 die "cannot create VirtIO RNG device: source file '$rng->{source}' doesn't exist\n"
3351 if ! -e
$rng->{source
};
3353 my $rng_addr = print_pci_addr
("rng0", $bridges, $arch, $machine_type);
3355 push @$devices, '-object', "rng-random,filename=$rng->{source},id=rng0";
3356 push @$devices, '-device', "virtio-rng-pci,rng=rng0$limiter_str$rng_addr";
3364 for(my $i = 1; $i < $qxlnum; $i++){
3365 push @$devices, '-device', print_vga_device
($conf, $vga, $arch, $machine_version, $machine_type, $i, $qxlnum, $bridges);
3368 # assume other OS works like Linux
3369 my ($ram, $vram) = ("134217728", "67108864");
3370 if ($vga->{memory
}) {
3371 $ram = PVE
::Tools
::convert_size
($qxlnum*4*$vga->{memory
}, 'mb' => 'b');
3372 $vram = PVE
::Tools
::convert_size
($qxlnum*2*$vga->{memory
}, 'mb' => 'b');
3374 push @$cmd, '-global', "qxl-vga.ram_size=$ram";
3375 push @$cmd, '-global', "qxl-vga.vram_size=$vram";
3379 my $pciaddr = print_pci_addr
("spice", $bridges, $arch, $machine_type);
3381 my $pfamily = PVE
::Tools
::get_host_address_family
($nodename);
3382 my @nodeaddrs = PVE
::Tools
::getaddrinfo_all
('localhost', family
=> $pfamily);
3383 die "failed to get an ip address of type $pfamily for 'localhost'\n" if !@nodeaddrs;
3385 push @$devices, '-device', "virtio-serial,id=spice$pciaddr";
3386 push @$devices, '-chardev', "spicevmc,id=vdagent,name=vdagent";
3387 push @$devices, '-device', "virtserialport,chardev=vdagent,name=com.redhat.spice.0";
3389 my $localhost = PVE
::Network
::addr_to_ip
($nodeaddrs[0]->{addr
});
3390 $spice_port = PVE
::Tools
::next_spice_port
($pfamily, $localhost);
3392 my $spice_enhancement = PVE
::JSONSchema
::parse_property_string
($spice_enhancements_fmt, $conf->{spice_enhancements
} // '');
3393 if ($spice_enhancement->{foldersharing
}) {
3394 push @$devices, '-chardev', "spiceport,id=foldershare,name=org.spice-space.webdav.0";
3395 push @$devices, '-device', "virtserialport,chardev=foldershare,name=org.spice-space.webdav.0";
3398 my $spice_opts = "tls-port=${spice_port},addr=$localhost,tls-ciphers=HIGH,seamless-migration=on";
3399 $spice_opts .= ",streaming-video=$spice_enhancement->{videostreaming}" if $spice_enhancement->{videostreaming
};
3400 push @$devices, '-spice', "$spice_opts";
3403 # enable balloon by default, unless explicitly disabled
3404 if (!defined($conf->{balloon
}) || $conf->{balloon
}) {
3405 $pciaddr = print_pci_addr
("balloon0", $bridges, $arch, $machine_type);
3406 push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr";
3409 if ($conf->{watchdog
}) {
3410 my $wdopts = parse_watchdog
($conf->{watchdog
});
3411 $pciaddr = print_pci_addr
("watchdog", $bridges, $arch, $machine_type);
3412 my $watchdog = $wdopts->{model
} || 'i6300esb';
3413 push @$devices, '-device', "$watchdog$pciaddr";
3414 push @$devices, '-watchdog-action', $wdopts->{action
} if $wdopts->{action
};
3418 my $scsicontroller = {};
3419 my $ahcicontroller = {};
3420 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : $defaults->{scsihw
};
3422 # Add iscsi initiator name if available
3423 if (my $initiator = get_initiator_name
()) {
3424 push @$devices, '-iscsi', "initiator-name=$initiator";
3427 foreach_drive
($conf, sub {
3428 my ($ds, $drive) = @_;
3430 if (PVE
::Storage
::parse_volume_id
($drive->{file
}, 1)) {
3431 push @$vollist, $drive->{file
};
3434 # ignore efidisk here, already added in bios/fw handling code above
3435 return if $drive->{interface
} eq 'efidisk';
3437 $use_virtio = 1 if $ds =~ m/^virtio/;
3439 if (drive_is_cdrom
($drive)) {
3440 if ($bootindex_hash->{d
}) {
3441 $drive->{bootindex
} = $bootindex_hash->{d
};
3442 $bootindex_hash->{d
} += 1;
3445 if ($bootindex_hash->{c
}) {
3446 $drive->{bootindex
} = $bootindex_hash->{c
} if $conf->{bootdisk
} && ($conf->{bootdisk
} eq $ds);
3447 $bootindex_hash->{c
} += 1;
3451 if($drive->{interface
} eq 'virtio'){
3452 push @$cmd, '-object', "iothread,id=iothread-$ds" if $drive->{iothread
};
3455 if ($drive->{interface
} eq 'scsi') {
3457 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
3459 die "scsi$drive->{index}: machine version 4.1~pve2 or higher is required to use more than 14 SCSI disks\n"
3460 if $drive->{index} > 13 && !&$version_guard(4, 1, 2);
3462 $pciaddr = print_pci_addr
("$controller_prefix$controller", $bridges, $arch, $machine_type);
3463 my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ?
"virtio-scsi-pci" : $scsihw;
3466 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{iothread
}){
3467 $iothread .= ",iothread=iothread-$controller_prefix$controller";
3468 push @$cmd, '-object', "iothread,id=iothread-$controller_prefix$controller";
3469 } elsif ($drive->{iothread
}) {
3470 warn "iothread is only valid with virtio disk or virtio-scsi-single controller, ignoring\n";
3474 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{queues
}){
3475 $queues = ",num_queues=$drive->{queues}";
3478 push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr$iothread$queues" if !$scsicontroller->{$controller};
3479 $scsicontroller->{$controller}=1;
3482 if ($drive->{interface
} eq 'sata') {
3483 my $controller = int($drive->{index} / $PVE::QemuServer
::Drive
::MAX_SATA_DISKS
);
3484 $pciaddr = print_pci_addr
("ahci$controller", $bridges, $arch, $machine_type);
3485 push @$devices, '-device', "ahci,id=ahci$controller,multifunction=on$pciaddr" if !$ahcicontroller->{$controller};
3486 $ahcicontroller->{$controller}=1;
3489 my $drive_cmd = print_drive_commandline_full
($storecfg, $vmid, $drive);
3490 push @$devices, '-drive',$drive_cmd;
3491 push @$devices, '-device', print_drivedevice_full
($storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type);
3494 for (my $i = 0; $i < $MAX_NETS; $i++) {
3495 next if !$conf->{"net$i"};
3496 my $d = parse_net
($conf->{"net$i"});
3499 $use_virtio = 1 if $d->{model
} eq 'virtio';
3501 if ($bootindex_hash->{n
}) {
3502 $d->{bootindex
} = $bootindex_hash->{n
};
3503 $bootindex_hash->{n
} += 1;
3506 my $netdevfull = print_netdev_full
($vmid, $conf, $arch, $d, "net$i");
3507 push @$devices, '-netdev', $netdevfull;
3509 my $netdevicefull = print_netdevice_full
($vmid, $conf, $d, "net$i", $bridges, $use_old_bios_files, $arch, $machine_type);
3510 push @$devices, '-device', $netdevicefull;
3513 if ($conf->{ivshmem
}) {
3514 my $ivshmem = PVE
::JSONSchema
::parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
3518 $bus = print_pcie_addr
("ivshmem");
3520 $bus = print_pci_addr
("ivshmem", $bridges, $arch, $machine_type);
3523 my $ivshmem_name = $ivshmem->{name
} // $vmid;
3524 my $path = '/dev/shm/pve-shm-' . $ivshmem_name;
3526 push @$devices, '-device', "ivshmem-plain,memdev=ivshmem$bus,";
3527 push @$devices, '-object', "memory-backend-file,id=ivshmem,share=on,mem-path=$path,size=$ivshmem->{size}M";
3530 # pci.4 is nested in pci.1
3531 $bridges->{1} = 1 if $bridges->{4};
3535 if (min_version
($machine_version, 2, 3)) {
3540 $bridges->{3} = 1 if $scsihw =~ m/^virtio-scsi-single/;
3544 for my $k (sort {$b cmp $a} keys %$bridges) {
3545 next if $q35 && $k < 4; # q35.cfg already includes bridges up to 3
3546 $pciaddr = print_pci_addr
("pci.$k", undef, $arch, $machine_type);
3547 my $devstr = "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr";
3549 # add after -readconfig pve-q35.cfg
3550 splice @$devices, 2, 0, '-device', $devstr;
3552 unshift @$devices, '-device', $devstr if $k > 0;
3557 push @$machineFlags, 'accel=tcg';
3560 my $machine_type_min = $machine_type;
3561 if ($add_pve_version) {
3562 $machine_type_min =~ s/\+pve\d+$//;
3563 $machine_type_min .= "+pve$required_pve_version";
3565 push @$machineFlags, "type=${machine_type_min}";
3567 push @$cmd, @$devices;
3568 push @$cmd, '-rtc', join(',', @$rtcFlags)
3569 if scalar(@$rtcFlags);
3570 push @$cmd, '-machine', join(',', @$machineFlags)
3571 if scalar(@$machineFlags);
3572 push @$cmd, '-global', join(',', @$globalFlags)
3573 if scalar(@$globalFlags);
3575 if (my $vmstate = $conf->{vmstate
}) {
3576 my $statepath = PVE
::Storage
::path
($storecfg, $vmstate);
3577 push @$vollist, $vmstate;
3578 push @$cmd, '-loadstate', $statepath;
3579 print "activating and using '$vmstate' as vmstate\n";
3583 if ($conf->{args
}) {
3584 my $aa = PVE
::Tools
::split_args
($conf->{args
});
3588 return wantarray ?
($cmd, $vollist, $spice_port) : $cmd;
3594 my $res = mon_cmd
($vmid, 'query-spice');
3596 return $res->{'tls-port'} || $res->{'port'} || die "no spice port\n";
3599 sub vm_devices_list
{
3602 my $res = mon_cmd
($vmid, 'query-pci');
3603 my $devices_to_check = [];
3605 foreach my $pcibus (@$res) {
3606 push @$devices_to_check, @{$pcibus->{devices
}},
3609 while (@$devices_to_check) {
3611 for my $d (@$devices_to_check) {
3612 $devices->{$d->{'qdev_id'}} = 1 if $d->{'qdev_id'};
3613 next if !$d->{'pci_bridge'};
3615 $devices->{$d->{'qdev_id'}} += scalar(@{$d->{'pci_bridge'}->{devices
}});
3616 push @$to_check, @{$d->{'pci_bridge'}->{devices
}};
3618 $devices_to_check = $to_check;
3621 my $resblock = mon_cmd
($vmid, 'query-block');
3622 foreach my $block (@$resblock) {
3623 if($block->{device
} =~ m/^drive-(\S+)/){
3628 my $resmice = mon_cmd
($vmid, 'query-mice');
3629 foreach my $mice (@$resmice) {
3630 if ($mice->{name
} eq 'QEMU HID Tablet') {
3631 $devices->{tablet
} = 1;
3636 # for usb devices there is no query-usb
3637 # but we can iterate over the entries in
3638 # qom-list path=/machine/peripheral
3639 my $resperipheral = mon_cmd
($vmid, 'qom-list', path
=> '/machine/peripheral');
3640 foreach my $per (@$resperipheral) {
3641 if ($per->{name
} =~ m/^usb\d+$/) {
3642 $devices->{$per->{name
}} = 1;
3650 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
3652 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
3654 my $devices_list = vm_devices_list
($vmid);
3655 return 1 if defined($devices_list->{$deviceid});
3657 qemu_add_pci_bridge
($storecfg, $conf, $vmid, $deviceid, $arch, $machine_type); # add PCI bridge if we need it for the device
3659 if ($deviceid eq 'tablet') {
3661 qemu_deviceadd
($vmid, print_tabletdevice_full
($conf, $arch));
3663 } elsif ($deviceid eq 'keyboard') {
3665 qemu_deviceadd
($vmid, print_keyboarddevice_full
($conf, $arch));
3667 } elsif ($deviceid =~ m/^usb(\d+)$/) {
3669 die "usb hotplug currently not reliable\n";
3670 # since we can't reliably hot unplug all added usb devices
3671 # and usb passthrough disables live migration
3672 # we disable usb hotplugging for now
3673 qemu_deviceadd
($vmid, PVE
::QemuServer
::USB
::print_usbdevice_full
($conf, $deviceid, $device));
3675 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3677 qemu_iothread_add
($vmid, $deviceid, $device);
3679 qemu_driveadd
($storecfg, $vmid, $device);
3680 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, $arch, $machine_type);
3682 qemu_deviceadd
($vmid, $devicefull);
3683 eval { qemu_deviceaddverify
($vmid, $deviceid); };
3685 eval { qemu_drivedel
($vmid, $deviceid); };
3690 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3693 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : "lsi";
3694 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
3695 my $scsihw_type = $scsihw eq 'virtio-scsi-single' ?
"virtio-scsi-pci" : $scsihw;
3697 my $devicefull = "$scsihw_type,id=$deviceid$pciaddr";
3699 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{iothread
}) {
3700 qemu_iothread_add
($vmid, $deviceid, $device);
3701 $devicefull .= ",iothread=iothread-$deviceid";
3704 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{queues
}) {
3705 $devicefull .= ",num_queues=$device->{queues}";
3708 qemu_deviceadd
($vmid, $devicefull);
3709 qemu_deviceaddverify
($vmid, $deviceid);
3711 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3713 qemu_findorcreatescsihw
($storecfg,$conf, $vmid, $device, $arch, $machine_type);
3714 qemu_driveadd
($storecfg, $vmid, $device);
3716 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, $arch, $machine_type);
3717 eval { qemu_deviceadd
($vmid, $devicefull); };
3719 eval { qemu_drivedel
($vmid, $deviceid); };
3724 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3726 return undef if !qemu_netdevadd
($vmid, $conf, $arch, $device, $deviceid);
3728 my $machine_type = PVE
::QemuServer
::Machine
::qemu_machine_pxe
($vmid, $conf);
3729 my $use_old_bios_files = undef;
3730 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
3732 my $netdevicefull = print_netdevice_full
($vmid, $conf, $device, $deviceid, undef, $use_old_bios_files, $arch, $machine_type);
3733 qemu_deviceadd
($vmid, $netdevicefull);
3735 qemu_deviceaddverify
($vmid, $deviceid);
3736 qemu_set_link_status
($vmid, $deviceid, !$device->{link_down
});
3739 eval { qemu_netdevdel
($vmid, $deviceid); };
3744 } elsif (!$q35 && $deviceid =~ m/^(pci\.)(\d+)$/) {
3747 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
3748 my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
3750 qemu_deviceadd
($vmid, $devicefull);
3751 qemu_deviceaddverify
($vmid, $deviceid);
3754 die "can't hotplug device '$deviceid'\n";
3760 # fixme: this should raise exceptions on error!
3761 sub vm_deviceunplug
{
3762 my ($vmid, $conf, $deviceid) = @_;
3764 my $devices_list = vm_devices_list
($vmid);
3765 return 1 if !defined($devices_list->{$deviceid});
3767 die "can't unplug bootdisk" if $conf->{bootdisk
} && $conf->{bootdisk
} eq $deviceid;
3769 if ($deviceid eq 'tablet' || $deviceid eq 'keyboard') {
3771 qemu_devicedel
($vmid, $deviceid);
3773 } elsif ($deviceid =~ m/^usb\d+$/) {
3775 die "usb hotplug currently not reliable\n";
3776 # when unplugging usb devices this way,
3777 # there may be remaining usb controllers/hubs
3778 # so we disable it for now
3779 qemu_devicedel
($vmid, $deviceid);
3780 qemu_devicedelverify
($vmid, $deviceid);
3782 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3784 qemu_devicedel
($vmid, $deviceid);
3785 qemu_devicedelverify
($vmid, $deviceid);
3786 qemu_drivedel
($vmid, $deviceid);
3787 qemu_iothread_del
($conf, $vmid, $deviceid);
3789 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3791 qemu_devicedel
($vmid, $deviceid);
3792 qemu_devicedelverify
($vmid, $deviceid);
3793 qemu_iothread_del
($conf, $vmid, $deviceid);
3795 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3797 qemu_devicedel
($vmid, $deviceid);
3798 qemu_drivedel
($vmid, $deviceid);
3799 qemu_deletescsihw
($conf, $vmid, $deviceid);
3801 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3803 qemu_devicedel
($vmid, $deviceid);
3804 qemu_devicedelverify
($vmid, $deviceid);
3805 qemu_netdevdel
($vmid, $deviceid);
3808 die "can't unplug device '$deviceid'\n";
3814 sub qemu_deviceadd
{
3815 my ($vmid, $devicefull) = @_;
3817 $devicefull = "driver=".$devicefull;
3818 my %options = split(/[=,]/, $devicefull);
3820 mon_cmd
($vmid, "device_add" , %options);
3823 sub qemu_devicedel
{
3824 my ($vmid, $deviceid) = @_;
3826 my $ret = mon_cmd
($vmid, "device_del", id
=> $deviceid);
3829 sub qemu_iothread_add
{
3830 my($vmid, $deviceid, $device) = @_;
3832 if ($device->{iothread
}) {
3833 my $iothreads = vm_iothreads_list
($vmid);
3834 qemu_objectadd
($vmid, "iothread-$deviceid", "iothread") if !$iothreads->{"iothread-$deviceid"};
3838 sub qemu_iothread_del
{
3839 my($conf, $vmid, $deviceid) = @_;
3841 my $confid = $deviceid;
3842 if ($deviceid =~ m/^(?:virtioscsi|scsihw)(\d+)$/) {
3843 $confid = 'scsi' . $1;
3845 my $device = parse_drive
($confid, $conf->{$confid});
3846 if ($device->{iothread
}) {
3847 my $iothreads = vm_iothreads_list
($vmid);
3848 qemu_objectdel
($vmid, "iothread-$deviceid") if $iothreads->{"iothread-$deviceid"};
3852 sub qemu_objectadd
{
3853 my($vmid, $objectid, $qomtype) = @_;
3855 mon_cmd
($vmid, "object-add", id
=> $objectid, "qom-type" => $qomtype);
3860 sub qemu_objectdel
{
3861 my($vmid, $objectid) = @_;
3863 mon_cmd
($vmid, "object-del", id
=> $objectid);
3869 my ($storecfg, $vmid, $device) = @_;
3871 my $drive = print_drive_commandline_full
($storecfg, $vmid, $device);
3872 $drive =~ s/\\/\\\\/g;
3873 my $ret = PVE
::QemuServer
::Monitor
::hmp_cmd
($vmid, "drive_add auto \"$drive\"");
3875 # If the command succeeds qemu prints: "OK
"
3876 return 1 if $ret =~ m/OK/s;
3878 die "adding drive failed
: $ret\n";
3882 my($vmid, $deviceid) = @_;
3884 my $ret = PVE::QemuServer::Monitor::hmp_cmd($vmid, "drive_del drive-
$deviceid");
3887 return 1 if $ret eq "";
3889 # NB: device not found errors mean the drive was auto-deleted and we ignore the error
3890 return 1 if $ret =~ m/Device \'.*?\' not found/s;
3892 die "deleting drive
$deviceid failed
: $ret\n";
3895 sub qemu_deviceaddverify {
3896 my ($vmid, $deviceid) = @_;
3898 for (my $i = 0; $i <= 5; $i++) {
3899 my $devices_list = vm_devices_list($vmid);
3900 return 1 if defined($devices_list->{$deviceid});
3904 die "error on hotplug device
'$deviceid'\n";
3908 sub qemu_devicedelverify {
3909 my ($vmid, $deviceid) = @_;
3911 # need to verify that the device is correctly removed as device_del
3912 # is async and empty return is not reliable
3914 for (my $i = 0; $i <= 5; $i++) {
3915 my $devices_list = vm_devices_list($vmid);
3916 return 1 if !defined($devices_list->{$deviceid});
3920 die "error on hot-unplugging device
'$deviceid'\n";
3923 sub qemu_findorcreatescsihw {
3924 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
3926 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
3928 my $scsihwid="$controller_prefix$controller";
3929 my $devices_list = vm_devices_list($vmid);
3931 if(!defined($devices_list->{$scsihwid})) {
3932 vm_deviceplug($storecfg, $conf, $vmid, $scsihwid, $device, $arch, $machine_type);
3938 sub qemu_deletescsihw {
3939 my ($conf, $vmid, $opt) = @_;
3941 my $device = parse_drive($opt, $conf->{$opt});
3943 if ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
3944 vm_deviceunplug($vmid, $conf, "virtioscsi
$device->{index}");
3948 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
3950 my $devices_list = vm_devices_list($vmid);
3951 foreach my $opt (keys %{$devices_list}) {
3952 if (is_valid_drivename($opt)) {
3953 my $drive = parse_drive($opt, $conf->{$opt});
3954 if($drive->{interface} eq 'scsi' && $drive->{index} < (($maxdev-1)*($controller+1))) {
3960 my $scsihwid="scsihw
$controller";
3962 vm_deviceunplug($vmid, $conf, $scsihwid);
3967 sub qemu_add_pci_bridge {
3968 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
3974 print_pci_addr($device, $bridges, $arch, $machine_type);
3976 while (my ($k, $v) = each %$bridges) {
3979 return 1 if !defined($bridgeid) || $bridgeid < 1;
3981 my $bridge = "pci
.$bridgeid";
3982 my $devices_list = vm_devices_list($vmid);
3984 if (!defined($devices_list->{$bridge})) {
3985 vm_deviceplug($storecfg, $conf, $vmid, $bridge, $arch, $machine_type);
3991 sub qemu_set_link_status {
3992 my ($vmid, $device, $up) = @_;
3994 mon_cmd($vmid, "set_link
", name => $device,
3995 up => $up ? JSON::true : JSON::false);
3998 sub qemu_netdevadd {
3999 my ($vmid, $conf, $arch, $device, $deviceid) = @_;
4001 my $netdev = print_netdev_full($vmid, $conf, $arch, $device, $deviceid, 1);
4002 my %options = split(/[=,]/, $netdev);
4004 mon_cmd($vmid, "netdev_add
", %options);
4008 sub qemu_netdevdel {
4009 my ($vmid, $deviceid) = @_;
4011 mon_cmd($vmid, "netdev_del
", id => $deviceid);
4014 sub qemu_usb_hotplug {
4015 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
4019 # remove the old one first
4020 vm_deviceunplug($vmid, $conf, $deviceid);
4022 # check if xhci controller is necessary and available
4023 if ($device->{usb3}) {
4025 my $devicelist = vm_devices_list($vmid);
4027 if (!$devicelist->{xhci}) {
4028 my $pciaddr = print_pci_addr("xhci
", undef, $arch, $machine_type);
4029 qemu_deviceadd($vmid, "nec-usb-xhci
,id
=xhci
$pciaddr");
4032 my $d = parse_usb_device($device->{host});
4033 $d->{usb3} = $device->{usb3};
4036 vm_deviceplug($storecfg, $conf, $vmid, $deviceid, $d, $arch, $machine_type);
4039 sub qemu_cpu_hotplug {
4040 my ($vmid, $conf, $vcpus) = @_;
4042 my $machine_type = PVE::QemuServer::Machine::get_current_qemu_machine($vmid);
4045 $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
4046 $sockets = $conf->{sockets} if $conf->{sockets};
4047 my $cores = $conf->{cores} || 1;
4048 my $maxcpus = $sockets * $cores;
4050 $vcpus = $maxcpus if !$vcpus;
4052 die "you can
't add more vcpus than maxcpus\n"
4053 if $vcpus > $maxcpus;
4055 my $currentvcpus = $conf->{vcpus} || $maxcpus;
4057 if ($vcpus < $currentvcpus) {
4059 if (PVE::QemuServer::Machine::machine_version($machine_type, 2, 7)) {
4061 for (my $i = $currentvcpus; $i > $vcpus; $i--) {
4062 qemu_devicedel($vmid, "cpu$i");
4064 my $currentrunningvcpus = undef;
4066 $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4067 last if scalar(@{$currentrunningvcpus}) == $i-1;
4068 raise_param_exc({ vcpus => "error unplugging cpu$i" }) if $retry > 5;
4072 #update conf after each succesfull cpu unplug
4073 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4074 PVE::QemuConfig->write_config($vmid, $conf);
4077 die "cpu hot-unplugging requires qemu version 2.7 or higher\n";
4083 my $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4084 die "vcpus in running vm does not match its configuration\n"
4085 if scalar(@{$currentrunningvcpus}) != $currentvcpus;
4087 if (PVE::QemuServer::Machine::machine_version($machine_type, 2, 7)) {
4089 for (my $i = $currentvcpus+1; $i <= $vcpus; $i++) {
4090 my $cpustr = print_cpu_device($conf, $i);
4091 qemu_deviceadd($vmid, $cpustr);
4094 my $currentrunningvcpus = undef;
4096 $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4097 last if scalar(@{$currentrunningvcpus}) == $i;
4098 raise_param_exc({ vcpus => "error hotplugging cpu$i" }) if $retry > 10;
4102 #update conf after each succesfull cpu hotplug
4103 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4104 PVE::QemuConfig->write_config($vmid, $conf);
4108 for (my $i = $currentvcpus; $i < $vcpus; $i++) {
4109 mon_cmd($vmid, "cpu-add", id => int($i));
4114 sub qemu_block_set_io_throttle {
4115 my ($vmid, $deviceid,
4116 $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr,
4117 $bps_max, $bps_rd_max, $bps_wr_max, $iops_max, $iops_rd_max, $iops_wr_max,
4118 $bps_max_length, $bps_rd_max_length, $bps_wr_max_length,
4119 $iops_max_length, $iops_rd_max_length, $iops_wr_max_length) = @_;
4121 return if !check_running($vmid) ;
4123 mon_cmd($vmid, "block_set_io_throttle", device => $deviceid,
4125 bps_rd => int($bps_rd),
4126 bps_wr => int($bps_wr),
4128 iops_rd => int($iops_rd),
4129 iops_wr => int($iops_wr),
4130 bps_max => int($bps_max),
4131 bps_rd_max => int($bps_rd_max),
4132 bps_wr_max => int($bps_wr_max),
4133 iops_max => int($iops_max),
4134 iops_rd_max => int($iops_rd_max),
4135 iops_wr_max => int($iops_wr_max),
4136 bps_max_length => int($bps_max_length),
4137 bps_rd_max_length => int($bps_rd_max_length),
4138 bps_wr_max_length => int($bps_wr_max_length),
4139 iops_max_length => int($iops_max_length),
4140 iops_rd_max_length => int($iops_rd_max_length),
4141 iops_wr_max_length => int($iops_wr_max_length),
4146 # old code, only used to shutdown old VM after update
4148 my ($fh, $timeout) = @_;
4150 my $sel = new IO::Select;
4157 while (scalar (@ready = $sel->can_read($timeout))) {
4159 if ($count = $fh->sysread($buf, 8192)) {
4160 if ($buf =~ /^(.*)\(qemu\) $/s) {
4167 if (!defined($count)) {
4174 die "monitor read timeout\n" if !scalar(@ready);
4179 sub qemu_block_resize {
4180 my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
4182 my $running = check_running($vmid);
4184 $size = 0 if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
4186 return if !$running;
4188 my $padding = (1024 - $size % 1024) % 1024;
4189 $size = $size + $padding;
4191 mon_cmd($vmid, "block_resize", device => $deviceid, size => int($size));
4195 sub qemu_volume_snapshot {
4196 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4198 my $running = check_running($vmid);
4200 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4201 mon_cmd($vmid, 'blockdev-snapshot-internal-sync
', device => $deviceid, name => $snap);
4203 PVE::Storage::volume_snapshot($storecfg, $volid, $snap);
4207 sub qemu_volume_snapshot_delete {
4208 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4210 my $running = check_running($vmid);
4215 my $conf = PVE::QemuConfig->load_config($vmid);
4216 foreach_drive($conf, sub {
4217 my ($ds, $drive) = @_;
4218 $running = 1 if $drive->{file} eq $volid;
4222 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4223 mon_cmd($vmid, 'blockdev-snapshot-delete-internal-sync
', device => $deviceid, name => $snap);
4225 PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
4229 sub set_migration_caps {
4235 "auto-converge" => 1,
4237 "x-rdma-pin-all" => 0,
4242 my $supported_capabilities = mon_cmd($vmid, "query-migrate-capabilities");
4244 for my $supported_capability (@$supported_capabilities) {
4246 capability => $supported_capability->{capability},
4247 state => $enabled_cap->{$supported_capability->{capability}} ? JSON::true : JSON::false,
4251 mon_cmd($vmid, "migrate-set-capabilities", capabilities => $cap_ref);
4254 my $fast_plug_option = {
4262 'vmstatestorage
' => 1,
4267 # hotplug changes in [PENDING]
4268 # $selection hash can be used to only apply specified options, for
4269 # example: { cores => 1 } (only apply changed 'cores
')
4270 # $errors ref is used to return error messages
4271 sub vmconfig_hotplug_pending {
4272 my ($vmid, $conf, $storecfg, $selection, $errors) = @_;
4274 my $defaults = load_defaults();
4275 my $arch = get_vm_arch($conf);
4276 my $machine_type = get_vm_machine($conf, undef, $arch);
4278 # commit values which do not have any impact on running VM first
4279 # Note: those option cannot raise errors, we we do not care about
4280 # $selection and always apply them.
4282 my $add_error = sub {
4283 my ($opt, $msg) = @_;
4284 $errors->{$opt} = "hotplug problem - $msg";
4288 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4289 if ($fast_plug_option->{$opt}) {
4290 $conf->{$opt} = $conf->{pending}->{$opt};
4291 delete $conf->{pending}->{$opt};
4297 PVE::QemuConfig->write_config($vmid, $conf);
4300 my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
4302 my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete});
4303 foreach my $opt (sort keys %$pending_delete_hash) {
4304 next if $selection && !$selection->{$opt};
4305 my $force = $pending_delete_hash->{$opt}->{force};
4307 if ($opt eq 'hotplug
') {
4308 die "skip\n" if ($conf->{hotplug} =~ /memory/);
4309 } elsif ($opt eq 'tablet
') {
4310 die "skip\n" if !$hotplug_features->{usb};
4311 if ($defaults->{tablet}) {
4312 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
4313 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
4314 if $arch eq 'aarch64
';
4316 vm_deviceunplug($vmid, $conf, 'tablet
');
4317 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
4319 } elsif ($opt =~ m/^usb\d+/) {
4321 # since we cannot reliably hot unplug usb devices
4322 # we are disabling it
4323 die "skip\n" if !$hotplug_features->{usb} || $conf->{$opt} =~ m/spice/i;
4324 vm_deviceunplug($vmid, $conf, $opt);
4325 } elsif ($opt eq 'vcpus
') {
4326 die "skip\n" if !$hotplug_features->{cpu};
4327 qemu_cpu_hotplug($vmid, $conf, undef);
4328 } elsif ($opt eq 'balloon
') {
4329 # enable balloon device is not hotpluggable
4330 die "skip\n" if defined($conf->{balloon}) && $conf->{balloon} == 0;
4331 # here we reset the ballooning value to memory
4332 my $balloon = $conf->{memory} || $defaults->{memory};
4333 mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4334 } elsif ($fast_plug_option->{$opt}) {
4336 } elsif ($opt =~ m/^net(\d+)$/) {
4337 die "skip\n" if !$hotplug_features->{network};
4338 vm_deviceunplug($vmid, $conf, $opt);
4339 } elsif (is_valid_drivename($opt)) {
4340 die "skip\n" if !$hotplug_features->{disk} || $opt =~ m/(ide|sata)(\d+)/;
4341 vm_deviceunplug($vmid, $conf, $opt);
4342 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4343 } elsif ($opt =~ m/^memory$/) {
4344 die "skip\n" if !$hotplug_features->{memory};
4345 PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
4346 } elsif ($opt eq 'cpuunits
') {
4347 cgroups_write("cpu", $vmid, "cpu.shares", $defaults->{cpuunits});
4348 } elsif ($opt eq 'cpulimit
') {
4349 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", -1);
4355 &$add_error($opt, $err) if $err ne "skip\n";
4357 delete $conf->{$opt};
4358 PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
4362 my ($apply_pending_cloudinit, $apply_pending_cloudinit_done);
4363 $apply_pending_cloudinit = sub {
4364 return if $apply_pending_cloudinit_done; # once is enough
4365 $apply_pending_cloudinit_done = 1; # once is enough
4367 my ($key, $value) = @_;
4369 my @cloudinit_opts = keys %$confdesc_cloudinit;
4370 foreach my $opt (keys %{$conf->{pending}}) {
4371 next if !grep { $_ eq $opt } @cloudinit_opts;
4372 $conf->{$opt} = delete $conf->{pending}->{$opt};
4375 my $new_conf = { %$conf };
4376 $new_conf->{$key} = $value;
4377 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($new_conf, $vmid);
4380 foreach my $opt (keys %{$conf->{pending}}) {
4381 next if $selection && !$selection->{$opt};
4382 my $value = $conf->{pending}->{$opt};
4384 if ($opt eq 'hotplug
') {
4385 die "skip\n" if ($value =~ /memory/) || ($value !~ /memory/ && $conf->{hotplug} =~ /memory/);
4386 } elsif ($opt eq 'tablet
') {
4387 die "skip\n" if !$hotplug_features->{usb};
4389 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
4390 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
4391 if $arch eq 'aarch64
';
4392 } elsif ($value == 0) {
4393 vm_deviceunplug($vmid, $conf, 'tablet
');
4394 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
4396 } elsif ($opt =~ m/^usb\d+$/) {
4398 # since we cannot reliably hot unplug usb devices
4399 # we are disabling it
4400 die "skip\n" if !$hotplug_features->{usb} || $value =~ m/spice/i;
4401 my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format}, $value) };
4402 die "skip\n" if !$d;
4403 qemu_usb_hotplug($storecfg, $conf, $vmid, $opt, $d, $arch, $machine_type);
4404 } elsif ($opt eq 'vcpus
') {
4405 die "skip\n" if !$hotplug_features->{cpu};
4406 qemu_cpu_hotplug($vmid, $conf, $value);
4407 } elsif ($opt eq 'balloon
') {
4408 # enable/disable balloning device is not hotpluggable
4409 my $old_balloon_enabled = !!(!defined($conf->{balloon}) || $conf->{balloon});
4410 my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
4411 die "skip\n" if $old_balloon_enabled != $new_balloon_enabled;
4413 # allow manual ballooning if shares is set to zero
4414 if ((defined($conf->{shares}) && ($conf->{shares} == 0))) {
4415 my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
4416 mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4418 } elsif ($opt =~ m/^net(\d+)$/) {
4419 # some changes can be done without hotplug
4420 vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
4421 $vmid, $opt, $value, $arch, $machine_type);
4422 } elsif (is_valid_drivename($opt)) {
4423 die "skip\n" if $opt eq 'efidisk0
';
4424 # some changes can be done without hotplug
4425 my $drive = parse_drive($opt, $value);
4426 if (drive_is_cloudinit($drive)) {
4427 &$apply_pending_cloudinit($opt, $value);
4429 vmconfig_update_disk($storecfg, $conf, $hotplug_features->{disk},
4430 $vmid, $opt, $value, $arch, $machine_type);
4431 } elsif ($opt =~ m/^memory$/) { #dimms
4432 die "skip\n" if !$hotplug_features->{memory};
4433 $value = PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
4434 } elsif ($opt eq 'cpuunits
') {
4435 cgroups_write("cpu", $vmid, "cpu.shares", $conf->{pending}->{$opt});
4436 } elsif ($opt eq 'cpulimit
') {
4437 my $cpulimit = $conf->{pending}->{$opt} == 0 ? -1 : int($conf->{pending}->{$opt} * 100000);
4438 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", $cpulimit);
4440 die "skip\n"; # skip non-hot-pluggable options
4444 &$add_error($opt, $err) if $err ne "skip\n";
4446 $conf->{$opt} = $value;
4447 delete $conf->{pending}->{$opt};
4451 PVE::QemuConfig->write_config($vmid, $conf);
4454 sub try_deallocate_drive {
4455 my ($storecfg, $vmid, $conf, $key, $drive, $rpcenv, $authuser, $force) = @_;
4457 if (($force || $key =~ /^unused/) && !drive_is_cdrom($drive, 1)) {
4458 my $volid = $drive->{file};
4459 if (vm_is_volid_owner($storecfg, $vmid, $volid)) {
4460 my $sid = PVE::Storage::parse_volume_id($volid);
4461 $rpcenv->check($authuser, "/storage/$sid", ['Datastore
.AllocateSpace
']);
4463 # check if the disk is really unused
4464 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
4465 if PVE::QemuServer::Drive::is_volume_in_use($storecfg, $conf, $key, $volid);
4466 PVE::Storage::vdisk_free($storecfg, $volid);
4469 # If vm is not owner of this disk remove from config
4477 sub vmconfig_delete_or_detach_drive {
4478 my ($vmid, $storecfg, $conf, $opt, $force) = @_;
4480 my $drive = parse_drive($opt, $conf->{$opt});
4482 my $rpcenv = PVE::RPCEnvironment::get();
4483 my $authuser = $rpcenv->get_user();
4486 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM
.Config
.Disk
']);
4487 try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser, $force);
4489 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $drive);
4495 sub vmconfig_apply_pending {
4496 my ($vmid, $conf, $storecfg, $errors) = @_;
4498 my $add_apply_error = sub {
4499 my ($opt, $msg) = @_;
4500 my $err_msg = "unable to apply pending change $opt : $msg";
4501 $errors->{$opt} = $err_msg;
4507 my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete});
4508 foreach my $opt (sort keys %$pending_delete_hash) {
4509 my $force = $pending_delete_hash->{$opt}->{force};
4511 if ($opt =~ m/^unused/) {
4512 die "internal error";
4513 } elsif (defined($conf->{$opt}) && is_valid_drivename($opt)) {
4514 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4518 $add_apply_error->($opt, $err);
4520 PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
4521 delete $conf->{$opt};
4525 PVE::QemuConfig->cleanup_pending($conf);
4527 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4528 next if $opt eq 'delete'; # just to be sure
4530 if (defined($conf->{$opt}) && is_valid_drivename($opt)) {
4531 vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}))
4535 $add_apply_error->($opt, $err);
4537 $conf->{$opt} = delete $conf->{pending}->{$opt};
4541 # write all changes at once to avoid unnecessary i/o
4542 PVE::QemuConfig->write_config($vmid, $conf);
4545 sub vmconfig_update_net {
4546 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $arch, $machine_type) = @_;
4548 my $newnet = parse_net($value);
4550 if ($conf->{$opt}) {
4551 my $oldnet = parse_net($conf->{$opt});
4553 if (safe_string_ne($oldnet->{model}, $newnet->{model}) ||
4554 safe_string_ne($oldnet->{macaddr}, $newnet->{macaddr}) ||
4555 safe_num_ne($oldnet->{queues}, $newnet->{queues}) ||
4556 !($newnet->{bridge} && $oldnet->{bridge})) { # bridge/nat mode change
4558 # for non online change, we try to hot-unplug
4559 die "skip\n" if !$hotplug;
4560 vm_deviceunplug($vmid, $conf, $opt);
4563 die "internal error" if $opt !~ m/net(\d+)/;
4564 my $iface = "tap${vmid}i$1";
4566 if (safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
4567 safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
4568 safe_string_ne($oldnet->{trunks}, $newnet->{trunks}) ||
4569 safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
4570 PVE::Network::tap_unplug($iface);
4573 PVE::Network::SDN::Zones::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
4575 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
4577 } elsif (safe_num_ne($oldnet->{rate}, $newnet->{rate})) {
4578 # Rate can be applied on its own but any change above needs to
4579 # include the rate in tap_plug since OVS resets everything.
4580 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
4583 if (safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
4584 qemu_set_link_status($vmid, $opt, !$newnet->{link_down});
4592 vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet, $arch, $machine_type);
4598 sub vmconfig_update_disk {
4599 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $arch, $machine_type) = @_;
4601 my $drive = parse_drive($opt, $value);
4603 if ($conf->{$opt}) {
4605 if (my $old_drive = parse_drive($opt, $conf->{$opt})) {
4607 my $media = $drive->{media} || 'disk
';
4608 my $oldmedia = $old_drive->{media} || 'disk
';
4609 die "unable to change media type\n" if $media ne $oldmedia;
4611 if (!drive_is_cdrom($old_drive)) {
4613 if ($drive->{file} ne $old_drive->{file}) {
4615 die "skip\n" if !$hotplug;
4617 # unplug and register as unused
4618 vm_deviceunplug($vmid, $conf, $opt);
4619 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive)
4622 # update existing disk
4624 # skip non hotpluggable value
4625 if (safe_string_ne($drive->{discard}, $old_drive->{discard}) ||
4626 safe_string_ne($drive->{iothread}, $old_drive->{iothread}) ||
4627 safe_string_ne($drive->{queues}, $old_drive->{queues}) ||
4628 safe_string_ne($drive->{cache}, $old_drive->{cache}) ||
4629 safe_string_ne($drive->{ssd}, $old_drive->{ssd})) {
4634 if (safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
4635 safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
4636 safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
4637 safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
4638 safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
4639 safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr}) ||
4640 safe_num_ne($drive->{mbps_max}, $old_drive->{mbps_max}) ||
4641 safe_num_ne($drive->{mbps_rd_max}, $old_drive->{mbps_rd_max}) ||
4642 safe_num_ne($drive->{mbps_wr_max}, $old_drive->{mbps_wr_max}) ||
4643 safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
4644 safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
4645 safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max}) ||
4646 safe_num_ne($drive->{bps_max_length}, $old_drive->{bps_max_length}) ||
4647 safe_num_ne($drive->{bps_rd_max_length}, $old_drive->{bps_rd_max_length}) ||
4648 safe_num_ne($drive->{bps_wr_max_length}, $old_drive->{bps_wr_max_length}) ||
4649 safe_num_ne($drive->{iops_max_length}, $old_drive->{iops_max_length}) ||
4650 safe_num_ne($drive->{iops_rd_max_length}, $old_drive->{iops_rd_max_length}) ||
4651 safe_num_ne($drive->{iops_wr_max_length}, $old_drive->{iops_wr_max_length})) {
4653 qemu_block_set_io_throttle($vmid,"drive-$opt",
4654 ($drive->{mbps} || 0)*1024*1024,
4655 ($drive->{mbps_rd} || 0)*1024*1024,
4656 ($drive->{mbps_wr} || 0)*1024*1024,
4657 $drive->{iops} || 0,
4658 $drive->{iops_rd} || 0,
4659 $drive->{iops_wr} || 0,
4660 ($drive->{mbps_max} || 0)*1024*1024,
4661 ($drive->{mbps_rd_max} || 0)*1024*1024,
4662 ($drive->{mbps_wr_max} || 0)*1024*1024,
4663 $drive->{iops_max} || 0,
4664 $drive->{iops_rd_max} || 0,
4665 $drive->{iops_wr_max} || 0,
4666 $drive->{bps_max_length} || 1,
4667 $drive->{bps_rd_max_length} || 1,
4668 $drive->{bps_wr_max_length} || 1,
4669 $drive->{iops_max_length} || 1,
4670 $drive->{iops_rd_max_length} || 1,
4671 $drive->{iops_wr_max_length} || 1);
4680 if ($drive->{file} eq 'none
') {
4681 mon_cmd($vmid, "eject", force => JSON::true, id => "$opt");
4682 if (drive_is_cloudinit($old_drive)) {
4683 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive);
4686 my $path = get_iso_path($storecfg, $vmid, $drive->{file});
4688 # force eject if locked
4689 mon_cmd($vmid, "eject", force => JSON::true, id => "$opt");
4692 mon_cmd($vmid, "blockdev-change-medium",
4693 id => "$opt", filename => "$path");
4702 die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
4704 PVE::Storage::activate_volumes($storecfg, [$drive->{file}]) if $drive->{file} !~ m|^/dev/.+|;
4705 vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive, $arch, $machine_type);
4709 my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused,
4710 $forcemachine, $spice_ticket, $migration_network, $migration_type,
4711 $targetstorage, $timeout, $nbd_protocol_version) = @_;
4713 PVE::QemuConfig->lock_config($vmid, sub {
4714 my $conf = PVE::QemuConfig->load_config($vmid, $migratedfrom);
4716 die "you can't start a vm
if it
's a template\n" if PVE::QemuConfig->is_template($conf);
4718 my $is_suspended = PVE::QemuConfig->has_lock($conf, 'suspended
');
4720 PVE::QemuConfig->check_lock($conf)
4721 if !($skiplock || $is_suspended);
4723 die "VM $vmid already running\n" if check_running($vmid, undef, $migratedfrom);
4725 # clean up leftover reboot request files
4726 eval { clear_reboot_request($vmid); };
4729 if (!$statefile && scalar(keys %{$conf->{pending}})) {
4730 vmconfig_apply_pending($vmid, $conf, $storecfg);
4731 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4734 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($conf, $vmid);
4736 my $defaults = load_defaults();
4738 # set environment variable useful inside network script
4739 $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
4741 my $local_volumes = {};
4743 if ($targetstorage) {
4744 foreach_drive($conf, sub {
4745 my ($ds, $drive) = @_;
4747 return if drive_is_cdrom($drive);
4749 my $volid = $drive->{file};
4753 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
4755 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4756 return if $scfg->{shared};
4757 $local_volumes->{$ds} = [$volid, $storeid, $volname];
4762 foreach my $opt (sort keys %$local_volumes) {
4764 my ($volid, $storeid, $volname) = @{$local_volumes->{$opt}};
4765 my $drive = parse_drive($opt, $conf->{$opt});
4767 # If a remote storage is specified and the format of the original
4768 # volume is not available there, fall back to the default format.
4769 # Otherwise use the same format as the original.
4770 if ($targetstorage && $targetstorage ne "1") {
4771 $storeid = $targetstorage;
4772 my ($defFormat, $validFormats) = PVE::Storage::storage_default_format($storecfg, $storeid);
4773 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4774 my $fileFormat = qemu_img_format($scfg, $volname);
4775 $format = (grep {$fileFormat eq $_} @{$validFormats}) ? $fileFormat : $defFormat;
4777 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4778 $format = qemu_img_format($scfg, $volname);
4781 my $newvolid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $format, undef, ($drive->{size}/1024));
4782 my $newdrive = $drive;
4783 $newdrive->{format} = $format;
4784 $newdrive->{file} = $newvolid;
4785 my $drivestr = print_drive($newdrive);
4786 $local_volumes->{$opt} = $drivestr;
4787 #pass drive to conf for command line
4788 $conf->{$opt} = $drivestr;
4792 PVE::GuestHelpers::exec_hookscript($conf, $vmid, 'pre-start
', 1);
4794 if ($is_suspended) {
4795 # enforce machine type on suspended vm to ensure HW compatibility
4796 $forcemachine = $conf->{runningmachine};
4797 print "Resuming suspended VM\n";
4800 my ($cmd, $vollist, $spice_port) = config_to_command($storecfg, $vmid, $conf, $defaults, $forcemachine);
4803 my $get_migration_ip = sub {
4804 my ($cidr, $nodename) = @_;
4806 return $migration_ip if defined($migration_ip);
4808 if (!defined($cidr)) {
4809 my $dc_conf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
4810 $cidr = $dc_conf->{migration}->{network};
4813 if (defined($cidr)) {
4814 my $ips = PVE::Network::get_local_ip_from_cidr($cidr);
4816 die "could not get IP: no address configured on local " .
4817 "node for network '$cidr'\n" if scalar(@$ips) == 0;
4819 die "could not get IP: multiple addresses configured on local " .
4820 "node for network '$cidr'\n" if scalar(@$ips) > 1;
4822 $migration_ip = @$ips[0];
4825 $migration_ip = PVE::Cluster::remote_node_ip($nodename, 1)
4826 if !defined($migration_ip);
4828 return $migration_ip;
4833 if ($statefile eq 'tcp
') {
4834 my $localip = "localhost";
4835 my $datacenterconf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
4836 my $nodename = nodename();
4838 if (!defined($migration_type)) {
4839 if (defined($datacenterconf->{migration}->{type})) {
4840 $migration_type = $datacenterconf->{migration}->{type};
4842 $migration_type = 'secure
';
4846 if ($migration_type eq 'insecure
') {
4847 $localip = $get_migration_ip->($migration_network, $nodename);
4848 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
4851 my $pfamily = PVE::Tools::get_host_address_family($nodename);
4852 my $migrate_port = PVE::Tools::next_migrate_port($pfamily);
4853 $migrate_uri = "tcp:${localip}:${migrate_port}";
4854 push @$cmd, '-incoming
', $migrate_uri;
4857 } elsif ($statefile eq 'unix
') {
4858 # should be default for secure migrations as a ssh TCP forward
4859 # tunnel is not deterministic reliable ready and fails regurarly
4860 # to set up in time, so use UNIX socket forwards
4861 my $socket_addr = "/run/qemu-server/$vmid.migrate";
4862 unlink $socket_addr;
4864 $migrate_uri = "unix:$socket_addr";
4866 push @$cmd, '-incoming
', $migrate_uri;
4869 } elsif (-e $statefile) {
4870 push @$cmd, '-loadstate
', $statefile;
4872 my $statepath = PVE::Storage::path($storecfg, $statefile);
4873 push @$vollist, $statefile;
4874 push @$cmd, '-loadstate
', $statepath;
4881 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
4882 my $d = parse_hostpci($conf->{"hostpci$i"});
4884 my $pcidevices = $d->{pciid};
4885 foreach my $pcidevice (@$pcidevices) {
4886 my $pciid = $pcidevice->{id};
4888 my $info = PVE::SysFSTools::pci_device_info("$pciid");
4889 die "IOMMU not present\n" if !PVE::SysFSTools::check_iommu_support();
4890 die "no pci device info for device '$pciid'\n" if !$info;
4893 my $uuid = PVE::SysFSTools::generate_mdev_uuid($vmid, $i);
4894 PVE::SysFSTools::pci_create_mdev_device($pciid, $uuid, $d->{mdev});
4896 die "can't unbind
/bind pci group to vfio
'$pciid'\n"
4897 if !PVE::SysFSTools::pci_dev_group_bind_to_vfio($pciid);
4898 die "can
't reset pci device '$pciid'\n"
4899 if $info->{has_fl_reset} and !PVE::SysFSTools::pci_dev_reset($info);
4904 PVE::Storage::activate_volumes($storecfg, $vollist);
4907 run_command(['/bin/systemctl
', 'stop
', "$vmid.scope"],
4908 outfunc => sub {}, errfunc => sub {});
4910 # Issues with the above 'stop
' not being fully completed are extremely rare, a very low
4911 # timeout should be more than enough here...
4912 PVE::Systemd::wait_for_unit_removed("$vmid.scope", 5);
4914 my $cpuunits = defined($conf->{cpuunits}) ? $conf->{cpuunits}
4915 : $defaults->{cpuunits};
4917 my $start_timeout = $timeout // config_aware_timeout($conf, $is_suspended);
4919 timeout => $statefile ? undef : $start_timeout,
4924 # when migrating, prefix QEMU output so other side can pick up any
4925 # errors that might occur and show the user
4926 if ($migratedfrom) {
4927 $run_params{quiet} = 1;
4928 $run_params{logfunc} = sub { print "QEMU: $_[0]\n" };
4932 Slice => 'qemu
.slice
',
4934 CPUShares => $cpuunits
4937 if (my $cpulimit = $conf->{cpulimit}) {
4938 $properties{CPUQuota} = int($cpulimit * 100);
4940 $properties{timeout} = 10 if $statefile; # setting up the scope shoul be quick
4942 my $run_qemu = sub {
4943 PVE::Tools::run_fork sub {
4944 PVE::Systemd::enter_systemd_scope($vmid, "Proxmox VE VM $vmid", %properties);
4946 my $exitcode = run_command($cmd, %run_params);
4947 die "QEMU exited with code $exitcode\n" if $exitcode;
4951 if ($conf->{hugepages}) {
4954 my $hugepages_topology = PVE::QemuServer::Memory::hugepages_topology($conf);
4955 my $hugepages_host_topology = PVE::QemuServer::Memory::hugepages_host_topology();
4957 PVE::QemuServer::Memory::hugepages_mount();
4958 PVE::QemuServer::Memory::hugepages_allocate($hugepages_topology, $hugepages_host_topology);
4960 eval { $run_qemu->() };
4962 PVE::QemuServer::Memory::hugepages_reset($hugepages_host_topology);
4966 PVE::QemuServer::Memory::hugepages_pre_deallocate($hugepages_topology);
4968 eval { PVE::QemuServer::Memory::hugepages_update_locked($code); };
4971 eval { $run_qemu->() };
4975 # deactivate volumes if start fails
4976 eval { PVE::Storage::deactivate_volumes($storecfg, $vollist); };
4977 die "start failed: $err";
4980 print "migration listens on $migrate_uri\n" if $migrate_uri;
4982 if ($statefile && $statefile ne 'tcp
' && $statefile ne 'unix
') {
4983 eval { mon_cmd($vmid, "cont"); };
4987 #start nbd server for storage migration
4988 if ($targetstorage) {
4989 $nbd_protocol_version //= 0;
4991 my $migrate_storage_uri;
4992 # nbd_protocol_version > 0 for unix socket support
4993 if ($nbd_protocol_version > 0 && $migration_type eq 'secure
') {
4994 my $socket_path = "/run/qemu-server/$vmid\_nbd.migrate";
4995 mon_cmd($vmid, "nbd-server-start", addr => { type => 'unix
', data => { path => $socket_path } } );
4996 $migrate_storage_uri = "nbd:unix:$socket_path";
4998 my $nodename = nodename();
4999 my $localip = $get_migration_ip->($migration_network, $nodename);
5000 my $pfamily = PVE::Tools::get_host_address_family($nodename);
5001 my $storage_migrate_port = PVE::Tools::next_migrate_port($pfamily);
5003 mon_cmd($vmid, "nbd-server-start", addr => { type => 'inet
', data => { host => "${localip}", port => "${storage_migrate_port}" } } );
5004 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
5005 $migrate_storage_uri = "nbd:${localip}:${storage_migrate_port}";
5008 foreach my $opt (sort keys %$local_volumes) {
5009 my $drivestr = $local_volumes->{$opt};
5010 mon_cmd($vmid, "nbd-server-add", device => "drive-$opt", writable => JSON::true );
5011 if ($nbd_protocol_version > 0 && $migration_type eq 'secure
') {
5012 print "storage migration listens on $migrate_storage_uri:exportname=drive-$opt volume:$drivestr\n";
5014 print "storage migration listens on $migrate_storage_uri:exportname=drive-$opt volume:$drivestr\n";
5019 if ($migratedfrom) {
5021 set_migration_caps($vmid);
5026 print "spice listens on port $spice_port\n";
5027 if ($spice_ticket) {
5028 mon_cmd($vmid, "set_password", protocol => 'spice
', password => $spice_ticket);
5029 mon_cmd($vmid, "expire_password", protocol => 'spice
', time => "+30");
5034 mon_cmd($vmid, "balloon", value => $conf->{balloon}*1024*1024)
5035 if !$statefile && $conf->{balloon};
5037 foreach my $opt (keys %$conf) {
5038 next if $opt !~ m/^net\d+$/;
5039 my $nicconf = parse_net($conf->{$opt});
5040 qemu_set_link_status($vmid, $opt, 0) if $nicconf->{link_down};
5044 mon_cmd($vmid, 'qom-set
',
5045 path => "machine/peripheral/balloon0",
5046 property => "guest-stats-polling-interval",
5047 value => 2) if (!defined($conf->{balloon}) || $conf->{balloon});
5049 if ($is_suspended) {
5050 print "Resumed VM, removing state\n";
5051 if (my $vmstate = $conf->{vmstate}) {
5052 PVE::Storage::deactivate_volumes($storecfg, [$vmstate]);
5053 PVE::Storage::vdisk_free($storecfg, $vmstate);
5055 delete $conf->@{qw(lock vmstate runningmachine)};
5056 PVE
::QemuConfig-
>write_config($vmid, $conf);
5059 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'post-start');
5063 sub vm_commandline
{
5064 my ($storecfg, $vmid, $snapname) = @_;
5066 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5070 my $snapshot = $conf->{snapshots
}->{$snapname};
5071 die "snapshot '$snapname' does not exist\n" if !defined($snapshot);
5073 # check for a 'runningmachine' in snapshot
5074 $forcemachine = $snapshot->{runningmachine
} if $snapshot->{runningmachine
};
5076 $snapshot->{digest
} = $conf->{digest
}; # keep file digest for API
5081 my $defaults = load_defaults
();
5083 my $cmd = config_to_command
($storecfg, $vmid, $conf, $defaults, $forcemachine);
5085 return PVE
::Tools
::cmd2string
($cmd);
5089 my ($vmid, $skiplock) = @_;
5091 PVE
::QemuConfig-
>lock_config($vmid, sub {
5093 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5095 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5097 mon_cmd
($vmid, "system_reset");
5101 sub get_vm_volumes
{
5105 foreach_volid
($conf, sub {
5106 my ($volid, $attr) = @_;
5108 return if $volid =~ m
|^/|;
5110 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
5113 push @$vollist, $volid;
5119 sub vm_stop_cleanup
{
5120 my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
5125 my $vollist = get_vm_volumes
($conf);
5126 PVE
::Storage
::deactivate_volumes
($storecfg, $vollist);
5129 foreach my $ext (qw(mon qmp pid vnc qga)) {
5130 unlink "/var/run/qemu-server/${vmid}.$ext";
5133 if ($conf->{ivshmem
}) {
5134 my $ivshmem = PVE
::JSONSchema
::parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
5135 # just delete it for now, VMs which have this already open do not
5136 # are affected, but new VMs will get a separated one. If this
5137 # becomes an issue we either add some sort of ref-counting or just
5138 # add a "don't delete on stop" flag to the ivshmem format.
5139 unlink '/dev/shm/pve-shm-' . ($ivshmem->{name
} // $vmid);
5142 foreach my $key (keys %$conf) {
5143 next if $key !~ m/^hostpci(\d+)$/;
5144 my $hostpciindex = $1;
5145 my $d = parse_hostpci
($conf->{$key});
5146 my $uuid = PVE
::SysFSTools
::generate_mdev_uuid
($vmid, $hostpciindex);
5148 foreach my $pci (@{$d->{pciid
}}) {
5149 my $pciid = $pci->{id
};
5150 PVE
::SysFSTools
::pci_cleanup_mdev_device
($pciid, $uuid);
5154 vmconfig_apply_pending
($vmid, $conf, $storecfg) if $apply_pending_changes;
5156 warn $@ if $@; # avoid errors - just warn
5159 # call only in locked context
5161 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive) = @_;
5163 my $pid = check_running
($vmid, $nocheck);
5168 $conf = PVE
::QemuConfig-
>load_config($vmid);
5169 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5170 if (!defined($timeout) && $shutdown && $conf->{startup
}) {
5171 my $opts = PVE
::JSONSchema
::pve_parse_startup_order
($conf->{startup
});
5172 $timeout = $opts->{down
} if $opts->{down
};
5174 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'pre-stop');
5179 if (defined($conf) && parse_guest_agent
($conf)->{enabled
}) {
5180 mon_cmd
($vmid, "guest-shutdown", timeout
=> $timeout);
5182 mon_cmd
($vmid, "system_powerdown");
5185 mon_cmd
($vmid, "quit");
5191 $timeout = 60 if !defined($timeout);
5194 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5199 if ($count >= $timeout) {
5201 warn "VM still running - terminating now with SIGTERM\n";
5204 die "VM quit/powerdown failed - got timeout\n";
5207 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5212 warn "VM quit/powerdown failed - terminating now with SIGTERM\n";
5215 die "VM quit/powerdown failed\n";
5223 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5228 if ($count >= $timeout) {
5229 warn "VM still running - terminating now with SIGKILL\n";
5234 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5237 # Note: use $nocheck to skip tests if VM configuration file exists.
5238 # We need that when migration VMs to other nodes (files already moved)
5239 # Note: we set $keepActive in vzdump stop mode - volumes need to stay active
5241 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
5243 $force = 1 if !defined($force) && !$shutdown;
5246 my $pid = check_running
($vmid, $nocheck, $migratedfrom);
5247 kill 15, $pid if $pid;
5248 my $conf = PVE
::QemuConfig-
>load_config($vmid, $migratedfrom);
5249 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 0);
5253 PVE
::QemuConfig-
>lock_config($vmid, sub {
5254 _do_vm_stop
($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive);
5259 my ($vmid, $timeout) = @_;
5261 PVE
::QemuConfig-
>lock_config($vmid, sub {
5264 # only reboot if running, as qmeventd starts it again on a stop event
5265 return if !check_running
($vmid);
5267 create_reboot_request
($vmid);
5269 my $storecfg = PVE
::Storage
::config
();
5270 _do_vm_stop
($storecfg, $vmid, undef, undef, $timeout, 1);
5274 # avoid that the next normal shutdown will be confused for a reboot
5275 clear_reboot_request
($vmid);
5281 # note: if using the statestorage parameter, the caller has to check privileges
5283 my ($vmid, $skiplock, $includestate, $statestorage) = @_;
5290 PVE
::QemuConfig-
>lock_config($vmid, sub {
5292 $conf = PVE
::QemuConfig-
>load_config($vmid);
5294 my $is_backing_up = PVE
::QemuConfig-
>has_lock($conf, 'backup');
5295 PVE
::QemuConfig-
>check_lock($conf)
5296 if !($skiplock || $is_backing_up);
5298 die "cannot suspend to disk during backup\n"
5299 if $is_backing_up && $includestate;
5301 if ($includestate) {
5302 $conf->{lock} = 'suspending';
5303 my $date = strftime
("%Y-%m-%d", localtime(time()));
5304 $storecfg = PVE
::Storage
::config
();
5305 if (!$statestorage) {
5306 $statestorage = find_vmstate_storage
($conf, $storecfg);
5307 # check permissions for the storage
5308 my $rpcenv = PVE
::RPCEnvironment
::get
();
5309 if ($rpcenv->{type
} ne 'cli') {
5310 my $authuser = $rpcenv->get_user();
5311 $rpcenv->check($authuser, "/storage/$statestorage", ['Datastore.AllocateSpace']);
5316 $vmstate = PVE
::QemuConfig-
>__snapshot_save_vmstate($vmid, $conf, "suspend-$date", $storecfg, $statestorage, 1);
5317 $path = PVE
::Storage
::path
($storecfg, $vmstate);
5318 PVE
::QemuConfig-
>write_config($vmid, $conf);
5320 mon_cmd
($vmid, "stop");
5324 if ($includestate) {
5326 PVE
::Storage
::activate_volumes
($storecfg, [$vmstate]);
5329 mon_cmd
($vmid, "savevm-start", statefile
=> $path);
5331 my $state = mon_cmd
($vmid, "query-savevm");
5332 if (!$state->{status
}) {
5333 die "savevm not active\n";
5334 } elsif ($state->{status
} eq 'active') {
5337 } elsif ($state->{status
} eq 'completed') {
5338 print "State saved, quitting\n";
5340 } elsif ($state->{status
} eq 'failed' && $state->{error
}) {
5341 die "query-savevm failed with error '$state->{error}'\n"
5343 die "query-savevm returned status '$state->{status}'\n";
5349 PVE
::QemuConfig-
>lock_config($vmid, sub {
5350 $conf = PVE
::QemuConfig-
>load_config($vmid);
5352 # cleanup, but leave suspending lock, to indicate something went wrong
5354 mon_cmd
($vmid, "savevm-end");
5355 PVE
::Storage
::deactivate_volumes
($storecfg, [$vmstate]);
5356 PVE
::Storage
::vdisk_free
($storecfg, $vmstate);
5357 delete $conf->@{qw(vmstate runningmachine)};
5358 PVE
::QemuConfig-
>write_config($vmid, $conf);
5364 die "lock changed unexpectedly\n"
5365 if !PVE
::QemuConfig-
>has_lock($conf, 'suspending');
5367 mon_cmd
($vmid, "quit");
5368 $conf->{lock} = 'suspended';
5369 PVE
::QemuConfig-
>write_config($vmid, $conf);
5375 my ($vmid, $skiplock, $nocheck) = @_;
5377 PVE
::QemuConfig-
>lock_config($vmid, sub {
5378 my $res = mon_cmd
($vmid, 'query-status');
5379 my $resume_cmd = 'cont';
5381 if ($res->{status
} && $res->{status
} eq 'suspended') {
5382 $resume_cmd = 'system_wakeup';
5387 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5389 PVE
::QemuConfig-
>check_lock($conf)
5390 if !($skiplock || PVE
::QemuConfig-
>has_lock($conf, 'backup'));
5393 mon_cmd
($vmid, $resume_cmd);
5398 my ($vmid, $skiplock, $key) = @_;
5400 PVE
::QemuConfig-
>lock_config($vmid, sub {
5402 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5404 # there is no qmp command, so we use the human monitor command
5405 my $res = PVE
::QemuServer
::Monitor
::hmp_cmd
($vmid, "sendkey $key");
5406 die $res if $res ne '';
5410 # vzdump restore implementaion
5412 sub tar_archive_read_firstfile
{
5413 my $archive = shift;
5415 die "ERROR: file '$archive' does not exist\n" if ! -f
$archive;
5417 # try to detect archive type first
5418 my $pid = open (my $fh, '-|', 'tar', 'tf', $archive) ||
5419 die "unable to open file '$archive'\n";
5420 my $firstfile = <$fh>;
5424 die "ERROR: archive contaions no data\n" if !$firstfile;
5430 sub tar_restore_cleanup
{
5431 my ($storecfg, $statfile) = @_;
5433 print STDERR
"starting cleanup\n";
5435 if (my $fd = IO
::File-
>new($statfile, "r")) {
5436 while (defined(my $line = <$fd>)) {
5437 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
5440 if ($volid =~ m
|^/|) {
5441 unlink $volid || die 'unlink failed\n';
5443 PVE
::Storage
::vdisk_free
($storecfg, $volid);
5445 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
5447 print STDERR
"unable to cleanup '$volid' - $@" if $@;
5449 print STDERR
"unable to parse line in statfile - $line";
5456 sub restore_file_archive
{
5457 my ($archive, $vmid, $user, $opts) = @_;
5459 my $format = $opts->{format
};
5462 if ($archive =~ m/\.tgz$/ || $archive =~ m/\.tar\.gz$/) {
5463 $format = 'tar' if !$format;
5465 } elsif ($archive =~ m/\.tar$/) {
5466 $format = 'tar' if !$format;
5467 } elsif ($archive =~ m/.tar.lzo$/) {
5468 $format = 'tar' if !$format;
5470 } elsif ($archive =~ m/\.vma$/) {
5471 $format = 'vma' if !$format;
5472 } elsif ($archive =~ m/\.vma\.gz$/) {
5473 $format = 'vma' if !$format;
5475 } elsif ($archive =~ m/\.vma\.lzo$/) {
5476 $format = 'vma' if !$format;
5479 $format = 'vma' if !$format; # default
5482 # try to detect archive format
5483 if ($format eq 'tar') {
5484 return restore_tar_archive
($archive, $vmid, $user, $opts);
5486 return restore_vma_archive
($archive, $vmid, $user, $opts, $comp);
5490 # hepler to remove disks that will not be used after restore
5491 my $restore_cleanup_oldconf = sub {
5492 my ($storecfg, $vmid, $oldconf, $virtdev_hash) = @_;
5494 foreach_drive
($oldconf, sub {
5495 my ($ds, $drive) = @_;
5497 return if drive_is_cdrom
($drive, 1);
5499 my $volid = $drive->{file
};
5500 return if !$volid || $volid =~ m
|^/|;
5502 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
5503 return if !$path || !$owner || ($owner != $vmid);
5505 # Note: only delete disk we want to restore
5506 # other volumes will become unused
5507 if ($virtdev_hash->{$ds}) {
5508 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid); };
5515 # delete vmstate files, after the restore we have no snapshots anymore
5516 foreach my $snapname (keys %{$oldconf->{snapshots
}}) {
5517 my $snap = $oldconf->{snapshots
}->{$snapname};
5518 if ($snap->{vmstate
}) {
5519 eval { PVE
::Storage
::vdisk_free
($storecfg, $snap->{vmstate
}); };
5527 # Helper to parse vzdump backup device hints
5529 # $rpcenv: Environment, used to ckeck storage permissions
5530 # $user: User ID, to check storage permissions
5531 # $storecfg: Storage configuration
5532 # $fh: the file handle for reading the configuration
5533 # $devinfo: should contain device sizes for all backu-up'ed devices
5534 # $options: backup options (pool, default storage)
5536 # Return: $virtdev_hash, updates $devinfo (add devname, virtdev, format, storeid)
5537 my $parse_backup_hints = sub {
5538 my ($rpcenv, $user, $storecfg, $fh, $devinfo, $options) = @_;
5540 my $virtdev_hash = {};
5542 while (defined(my $line = <$fh>)) {
5543 if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
5544 my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
5545 die "archive does not contain data for drive '$virtdev'\n"
5546 if !$devinfo->{$devname};
5548 if (defined($options->{storage
})) {
5549 $storeid = $options->{storage
} || 'local';
5550 } elsif (!$storeid) {
5553 $format = 'raw' if !$format;
5554 $devinfo->{$devname}->{devname
} = $devname;
5555 $devinfo->{$devname}->{virtdev
} = $virtdev;
5556 $devinfo->{$devname}->{format
} = $format;
5557 $devinfo->{$devname}->{storeid
} = $storeid;
5559 # check permission on storage
5560 my $pool = $options->{pool
}; # todo: do we need that?
5561 if ($user ne 'root@pam') {
5562 $rpcenv->check($user, "/storage/$storeid", ['Datastore.AllocateSpace']);
5565 $virtdev_hash->{$virtdev} = $devinfo->{$devname};
5566 } elsif ($line =~ m/^((?:ide|sata|scsi)\d+):\s*(.*)\s*$/) {
5568 my $drive = parse_drive
($virtdev, $2);
5569 if (drive_is_cloudinit
($drive)) {
5570 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
5571 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5572 my $format = qemu_img_format
($scfg, $volname); # has 'raw' fallback
5574 $virtdev_hash->{$virtdev} = {
5576 storeid
=> $options->{storage
} // $storeid,
5577 size
=> PVE
::QemuServer
::Cloudinit
::CLOUDINIT_DISK_SIZE
,
5584 return $virtdev_hash;
5587 # Helper to allocate and activate all volumes required for a restore
5589 # $storecfg: Storage configuration
5590 # $virtdev_hash: as returned by parse_backup_hints()
5592 # Returns: { $virtdev => $volid }
5593 my $restore_allocate_devices = sub {
5594 my ($storecfg, $virtdev_hash, $vmid) = @_;
5597 foreach my $virtdev (sort keys %$virtdev_hash) {
5598 my $d = $virtdev_hash->{$virtdev};
5599 my $alloc_size = int(($d->{size
} + 1024 - 1)/1024);
5600 my $storeid = $d->{storeid
};
5601 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5603 # test if requested format is supported
5604 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
5605 my $supported = grep { $_ eq $d->{format
} } @$validFormats;
5606 $d->{format
} = $defFormat if !$supported;
5609 if ($d->{is_cloudinit
}) {
5610 $name = "vm-$vmid-cloudinit";
5611 $name .= ".$d->{format}" if $d->{format
} ne 'raw';
5614 my $volid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $vmid, $d->{format
}, $name, $alloc_size);
5616 print STDERR
"new volume ID is '$volid'\n";
5617 $d->{volid
} = $volid;
5619 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
5621 $map->{$virtdev} = $volid;
5627 my $restore_update_config_line = sub {
5628 my ($outfd, $cookie, $vmid, $map, $line, $unique) = @_;
5630 return if $line =~ m/^\#qmdump\#/;
5631 return if $line =~ m/^\#vzdump\#/;
5632 return if $line =~ m/^lock:/;
5633 return if $line =~ m/^unused\d+:/;
5634 return if $line =~ m/^parent:/;
5636 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
5637 if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
5638 # try to convert old 1.X settings
5639 my ($id, $ind, $ethcfg) = ($1, $2, $3);
5640 foreach my $devconfig (PVE
::Tools
::split_list
($ethcfg)) {
5641 my ($model, $macaddr) = split(/\=/, $devconfig);
5642 $macaddr = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if !$macaddr || $unique;
5645 bridge
=> "vmbr$ind",
5646 macaddr
=> $macaddr,
5648 my $netstr = print_net
($net);
5650 print $outfd "net$cookie->{netcount}: $netstr\n";
5651 $cookie->{netcount
}++;
5653 } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && $unique) {
5654 my ($id, $netstr) = ($1, $2);
5655 my $net = parse_net
($netstr);
5656 $net->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if $net->{macaddr
};
5657 $netstr = print_net
($net);
5658 print $outfd "$id: $netstr\n";
5659 } elsif ($line =~ m/^((ide|scsi|virtio|sata|efidisk)\d+):\s*(\S+)\s*$/) {
5662 my $di = parse_drive
($virtdev, $value);
5663 if (defined($di->{backup
}) && !$di->{backup
}) {
5664 print $outfd "#$line";
5665 } elsif ($map->{$virtdev}) {
5666 delete $di->{format
}; # format can change on restore
5667 $di->{file
} = $map->{$virtdev};
5668 $value = print_drive
($di);
5669 print $outfd "$virtdev: $value\n";
5673 } elsif (($line =~ m/^vmgenid: (.*)/)) {
5675 if ($vmgenid ne '0') {
5676 # always generate a new vmgenid if there was a valid one setup
5677 $vmgenid = generate_uuid
();
5679 print $outfd "vmgenid: $vmgenid\n";
5680 } elsif (($line =~ m/^(smbios1: )(.*)/) && $unique) {
5681 my ($uuid, $uuid_str);
5682 UUID
::generate
($uuid);
5683 UUID
::unparse
($uuid, $uuid_str);
5684 my $smbios1 = parse_smbios1
($2);
5685 $smbios1->{uuid
} = $uuid_str;
5686 print $outfd $1.print_smbios1
($smbios1)."\n";
5692 my $restore_deactivate_volumes = sub {
5693 my ($storecfg, $devinfo) = @_;
5696 foreach my $devname (keys %$devinfo) {
5697 my $volid = $devinfo->{$devname}->{volid
};
5698 push @$vollist, $volid if $volid;
5701 PVE
::Storage
::deactivate_volumes
($storecfg, $vollist);
5704 my $restore_destroy_volumes = sub {
5705 my ($storecfg, $devinfo) = @_;
5707 foreach my $devname (keys %$devinfo) {
5708 my $volid = $devinfo->{$devname}->{volid
};
5711 if ($volid =~ m
|^/|) {
5712 unlink $volid || die 'unlink failed\n';
5714 PVE
::Storage
::vdisk_free
($storecfg, $volid);
5716 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
5718 print STDERR
"unable to cleanup '$volid' - $@" if $@;
5723 my ($cfg, $vmid) = @_;
5725 my $info = PVE
::Storage
::vdisk_list
($cfg, undef, $vmid);
5727 my $volid_hash = {};
5728 foreach my $storeid (keys %$info) {
5729 foreach my $item (@{$info->{$storeid}}) {
5730 next if !($item->{volid
} && $item->{size
});
5731 $item->{path
} = PVE
::Storage
::path
($cfg, $item->{volid
});
5732 $volid_hash->{$item->{volid
}} = $item;
5739 sub update_disk_config
{
5740 my ($vmid, $conf, $volid_hash) = @_;
5743 my $prefix = "VM $vmid:";
5745 # used and unused disks
5746 my $referenced = {};
5748 # Note: it is allowed to define multiple storages with same path (alias), so
5749 # we need to check both 'volid' and real 'path' (two different volid can point
5750 # to the same path).
5752 my $referencedpath = {};
5755 foreach my $opt (keys %$conf) {
5756 if (is_valid_drivename
($opt)) {
5757 my $drive = parse_drive
($opt, $conf->{$opt});
5758 my $volid = $drive->{file
};
5761 # mark volid as "in-use" for next step
5762 $referenced->{$volid} = 1;
5763 if ($volid_hash->{$volid} &&
5764 (my $path = $volid_hash->{$volid}->{path
})) {
5765 $referencedpath->{$path} = 1;
5768 next if drive_is_cdrom
($drive);
5769 next if !$volid_hash->{$volid};
5771 my ($updated, $old_size, $new_size) = PVE
::QemuServer
::Drive
::update_disksize
($drive, $volid_hash);
5772 if (defined($updated)) {
5774 $conf->{$opt} = print_drive
($updated);
5775 print "$prefix size of disk '$volid' ($opt) updated from $old_size to $new_size\n";
5780 # remove 'unusedX' entry if volume is used
5781 foreach my $opt (keys %$conf) {
5782 next if $opt !~ m/^unused\d+$/;
5783 my $volid = $conf->{$opt};
5784 my $path = $volid_hash->{$volid}->{path
} if $volid_hash->{$volid};
5785 if ($referenced->{$volid} || ($path && $referencedpath->{$path})) {
5786 print "$prefix remove entry '$opt', its volume '$volid' is in use\n";
5788 delete $conf->{$opt};
5791 $referenced->{$volid} = 1;
5792 $referencedpath->{$path} = 1 if $path;
5795 foreach my $volid (sort keys %$volid_hash) {
5796 next if $volid =~ m/vm-$vmid-state-/;
5797 next if $referenced->{$volid};
5798 my $path = $volid_hash->{$volid}->{path
};
5799 next if !$path; # just to be sure
5800 next if $referencedpath->{$path};
5802 my $key = PVE
::QemuConfig-
>add_unused_volume($conf, $volid);
5803 print "$prefix add unreferenced volume '$volid' as '$key' to config\n";
5804 $referencedpath->{$path} = 1; # avoid to add more than once (aliases)
5811 my ($vmid, $nolock, $dryrun) = @_;
5813 my $cfg = PVE
::Storage
::config
();
5815 # FIXME: Remove once our RBD plugin can handle CT and VM on a single storage
5816 # see: https://pve.proxmox.com/pipermail/pve-devel/2018-July/032900.html
5817 foreach my $stor (keys %{$cfg->{ids
}}) {
5818 delete($cfg->{ids
}->{$stor}) if ! $cfg->{ids
}->{$stor}->{content
}->{images
};
5821 print "rescan volumes...\n";
5822 my $volid_hash = scan_volids
($cfg, $vmid);
5824 my $updatefn = sub {
5827 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5829 PVE
::QemuConfig-
>check_lock($conf);
5832 foreach my $volid (keys %$volid_hash) {
5833 my $info = $volid_hash->{$volid};
5834 $vm_volids->{$volid} = $info if $info->{vmid
} && $info->{vmid
} == $vmid;
5837 my $changes = update_disk_config
($vmid, $conf, $vm_volids);
5839 PVE
::QemuConfig-
>write_config($vmid, $conf) if $changes && !$dryrun;
5842 if (defined($vmid)) {
5846 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
5849 my $vmlist = config_list
();
5850 foreach my $vmid (keys %$vmlist) {
5854 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
5860 sub restore_proxmox_backup_archive
{
5861 my ($archive, $vmid, $user, $options) = @_;
5863 my $storecfg = PVE
::Storage
::config
();
5865 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($archive);
5866 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5868 my $server = $scfg->{server
};
5869 my $datastore = $scfg->{datastore
};
5870 my $username = $scfg->{username
} // 'root@pam';
5871 my $fingerprint = $scfg->{fingerprint
};
5873 my $repo = "$username\@$server:$datastore";
5874 my $password = PVE
::Storage
::PBSPlugin
::pbs_get_password
($scfg, $storeid);
5875 local $ENV{PBS_PASSWORD
} = $password;
5876 local $ENV{PBS_FINGERPRINT
} = $fingerprint if defined($fingerprint);
5878 my ($vtype, $pbs_backup_name, undef, undef, undef, undef, $format) =
5879 PVE
::Storage
::parse_volname
($storecfg, $archive);
5881 die "got unexpected vtype '$vtype'\n" if $vtype ne 'backup';
5883 die "got unexpected backup format '$format'\n" if $format ne 'pbs-vm';
5885 my $tmpdir = "/var/tmp/vzdumptmp$$";
5889 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
5890 my $tmpfn = "$conffile.$$.tmp";
5891 # disable interrupts (always do cleanups)
5895 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
5897 # Note: $oldconf is undef if VM does not exists
5898 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
5899 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
5901 my $rpcenv = PVE
::RPCEnvironment
::get
();
5910 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
5912 my $cfgfn = "$tmpdir/qemu-server.conf";
5913 my $firewall_config_fn = "$tmpdir/fw.conf";
5914 my $index_fn = "$tmpdir/index.json";
5916 my $cmd = "restore";
5918 my $param = [$pbs_backup_name, "index.json", $index_fn];
5919 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
5920 my $index = PVE
::Tools
::file_get_contents
($index_fn);
5921 $index = decode_json
($index);
5923 # print Dumper($index);
5924 foreach my $info (@{$index->{files
}}) {
5925 if ($info->{filename
} =~ m/^(drive-\S+).img.fidx$/) {
5927 if ($info->{size
} =~ m/^(\d+)$/) { # untaint size
5928 $devinfo->{$devname}->{size
} = $1;
5930 die "unable to parse file size in 'index.json' - got '$info->{size}'\n";
5935 my $is_qemu_server_backup = scalar(grep { $_->{filename
} eq 'qemu-server.conf.blob' } @{$index->{files
}});
5936 if (!$is_qemu_server_backup) {
5937 die "backup does not look like a qemu-server backup (missing 'qemu-server.conf' file)\n";
5939 my $has_firewall_config = scalar(grep { $_->{filename
} eq 'fw.conf.blob' } @{$index->{files
}});
5941 $param = [$pbs_backup_name, "qemu-server.conf", $cfgfn];
5942 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
5944 if ($has_firewall_config) {
5945 $param = [$pbs_backup_name, "fw.conf", $firewall_config_fn];
5946 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
5948 my $pve_firewall_dir = '/etc/pve/firewall';
5949 mkdir $pve_firewall_dir; # make sure the dir exists
5950 PVE
::Tools
::file_copy
($firewall_config_fn, "${pve_firewall_dir}/$vmid.fw");
5953 my $fh = IO
::File-
>new($cfgfn, "r") ||
5954 "unable to read qemu-server.conf - $!\n";
5956 my $virtdev_hash = $parse_backup_hints->($rpcenv, $user, $storecfg, $fh, $devinfo, $options);
5958 # fixme: rate limit?
5960 # create empty/temp config
5961 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\nlock: create");
5963 $restore_cleanup_oldconf->($storecfg, $vmid, $oldconf, $virtdev_hash) if $oldconf;
5966 my $map = $restore_allocate_devices->($storecfg, $virtdev_hash, $vmid);
5968 foreach my $virtdev (sort keys %$virtdev_hash) {
5969 my $d = $virtdev_hash->{$virtdev};
5970 next if $d->{is_cloudinit
}; # no need to restore cloudinit
5972 my $volid = $d->{volid
};
5974 my $path = PVE
::Storage
::path
($storecfg, $volid);
5976 my $pbs_restore_cmd = [
5977 '/usr/bin/pbs-restore',
5978 '--repository', $repo,
5980 "$d->{devname}.img.fidx",
5985 if (PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $volid)) {
5986 push @$pbs_restore_cmd, '--skip-zero';
5989 my $dbg_cmdstring = PVE
::Tools
::cmd2string
($pbs_restore_cmd);
5990 print "restore proxmox backup image: $dbg_cmdstring\n";
5991 run_command
($pbs_restore_cmd);
5994 $fh->seek(0, 0) || die "seek failed - $!\n";
5996 my $outfd = new IO
::File
($tmpfn, "w") ||
5997 die "unable to write config for VM $vmid\n";
5999 my $cookie = { netcount
=> 0 };
6000 while (defined(my $line = <$fh>)) {
6001 $restore_update_config_line->($outfd, $cookie, $vmid, $map, $line, $options->{unique
});
6009 $restore_deactivate_volumes->($storecfg, $devinfo);
6015 $restore_destroy_volumes->($storecfg, $devinfo);
6019 rename($tmpfn, $conffile) ||
6020 die "unable to commit configuration file '$conffile'\n";
6022 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6024 eval { rescan
($vmid, 1); };
6028 sub restore_vma_archive
{
6029 my ($archive, $vmid, $user, $opts, $comp) = @_;
6031 my $readfrom = $archive;
6033 my $cfg = PVE
::Storage
::config
();
6035 my $bwlimit = $opts->{bwlimit
};
6037 my $dbg_cmdstring = '';
6038 my $add_pipe = sub {
6040 push @$commands, $cmd;
6041 $dbg_cmdstring .= ' | ' if length($dbg_cmdstring);
6042 $dbg_cmdstring .= PVE
::Tools
::cmd2string
($cmd);
6047 if ($archive eq '-') {
6050 # If we use a backup from a PVE defined storage we also consider that
6051 # storage's rate limit:
6052 my (undef, $volid) = PVE
::Storage
::path_to_volume_id
($cfg, $archive);
6053 if (defined($volid)) {
6054 my ($sid, undef) = PVE
::Storage
::parse_volume_id
($volid);
6055 my $readlimit = PVE
::Storage
::get_bandwidth_limit
('restore', [$sid], $bwlimit);
6057 print STDERR
"applying read rate limit: $readlimit\n";
6058 my $cstream = ['cstream', '-t', $readlimit*1024, '--', $readfrom];
6059 $add_pipe->($cstream);
6066 if ($comp eq 'gzip') {
6067 $cmd = ['zcat', $readfrom];
6068 } elsif ($comp eq 'lzop') {
6069 $cmd = ['lzop', '-d', '-c', $readfrom];
6071 die "unknown compression method '$comp'\n";
6076 my $tmpdir = "/var/tmp/vzdumptmp$$";
6079 # disable interrupts (always do cleanups)
6083 local $SIG{HUP
} = sub { warn "got interrupt - ignored\n"; };
6085 my $mapfifo = "/var/tmp/vzdumptmp$$.fifo";
6086 POSIX
::mkfifo
($mapfifo, 0600);
6089 my $openfifo = sub {
6090 open($fifofh, '>', $mapfifo) || die $!;
6093 $add_pipe->(['vma', 'extract', '-v', '-r', $mapfifo, $readfrom, $tmpdir]);
6100 my $rpcenv = PVE
::RPCEnvironment
::get
();
6102 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6103 my $tmpfn = "$conffile.$$.tmp";
6105 # Note: $oldconf is undef if VM does not exist
6106 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
6107 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
6111 my $print_devmap = sub {
6112 my $cfgfn = "$tmpdir/qemu-server.conf";
6114 # we can read the config - that is already extracted
6115 my $fh = IO
::File-
>new($cfgfn, "r") ||
6116 "unable to read qemu-server.conf - $!\n";
6118 my $fwcfgfn = "$tmpdir/qemu-server.fw";
6120 my $pve_firewall_dir = '/etc/pve/firewall';
6121 mkdir $pve_firewall_dir; # make sure the dir exists
6122 PVE
::Tools
::file_copy
($fwcfgfn, "${pve_firewall_dir}/$vmid.fw");
6125 my $virtdev_hash = $parse_backup_hints->($rpcenv, $user, $cfg, $fh, $devinfo, $opts);
6127 foreach my $key (keys %storage_limits) {
6128 my $limit = PVE
::Storage
::get_bandwidth_limit
('restore', [$key], $bwlimit);
6130 print STDERR
"rate limit for storage $key: $limit KiB/s\n";
6131 $storage_limits{$key} = $limit * 1024;
6134 foreach my $devname (keys %$devinfo) {
6135 die "found no device mapping information for device '$devname'\n"
6136 if !$devinfo->{$devname}->{virtdev
};
6139 # create empty/temp config
6141 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
6142 $restore_cleanup_oldconf->($cfg, $vmid, $oldconf, $virtdev_hash);
6146 my $map = $restore_allocate_devices->($cfg, $virtdev_hash, $vmid);
6148 # print restore information to $fifofh
6149 foreach my $virtdev (sort keys %$virtdev_hash) {
6150 my $d = $virtdev_hash->{$virtdev};
6151 next if $d->{is_cloudinit
}; # no need to restore cloudinit
6153 my $storeid = $d->{storeid
};
6154 my $volid = $d->{volid
};
6157 if (my $limit = $storage_limits{$storeid}) {
6158 $map_opts .= "throttling.bps=$limit:throttling.group=$storeid:";
6161 my $write_zeros = 1;
6162 if (PVE
::Storage
::volume_has_feature
($cfg, 'sparseinit', $volid)) {
6166 my $path = PVE
::Storage
::path
($cfg, $volid);
6168 print $fifofh "${map_opts}format=$d->{format}:${write_zeros}:$d->{devname}=$path\n";
6170 print "map '$d->{devname}' to '$path' (write zeros = ${write_zeros})\n";
6173 $fh->seek(0, 0) || die "seek failed - $!\n";
6175 my $outfd = new IO
::File
($tmpfn, "w") ||
6176 die "unable to write config for VM $vmid\n";
6178 my $cookie = { netcount
=> 0 };
6179 while (defined(my $line = <$fh>)) {
6180 $restore_update_config_line->($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
6193 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6194 local $SIG{ALRM
} = sub { die "got timeout\n"; };
6196 $oldtimeout = alarm($timeout);
6203 if ($line =~ m/^DEV:\sdev_id=(\d+)\ssize:\s(\d+)\sdevname:\s(\S+)$/) {
6204 my ($dev_id, $size, $devname) = ($1, $2, $3);
6205 $devinfo->{$devname} = { size
=> $size, dev_id
=> $dev_id };
6206 } elsif ($line =~ m/^CTIME: /) {
6207 # we correctly received the vma config, so we can disable
6208 # the timeout now for disk allocation (set to 10 minutes, so
6209 # that we always timeout if something goes wrong)
6212 print $fifofh "done\n";
6213 my $tmp = $oldtimeout || 0;
6214 $oldtimeout = undef;
6220 print "restore vma archive: $dbg_cmdstring\n";
6221 run_command
($commands, input
=> $input, outfunc
=> $parser, afterfork
=> $openfifo);
6225 alarm($oldtimeout) if $oldtimeout;
6227 $restore_deactivate_volumes->($cfg, $devinfo);
6234 $restore_destroy_volumes->($cfg, $devinfo);
6238 rename($tmpfn, $conffile) ||
6239 die "unable to commit configuration file '$conffile'\n";
6241 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6243 eval { rescan
($vmid, 1); };
6247 sub restore_tar_archive
{
6248 my ($archive, $vmid, $user, $opts) = @_;
6250 if ($archive ne '-') {
6251 my $firstfile = tar_archive_read_firstfile
($archive);
6252 die "ERROR: file '$archive' dos not lock like a QemuServer vzdump backup\n"
6253 if $firstfile ne 'qemu-server.conf';
6256 my $storecfg = PVE
::Storage
::config
();
6258 # avoid zombie disks when restoring over an existing VM -> cleanup first
6259 # pass keep_empty_config=1 to keep the config (thus VMID) reserved for us
6260 # skiplock=1 because qmrestore has set the 'create' lock itself already
6261 my $vmcfgfn = PVE
::QemuConfig-
>config_file($vmid);
6262 destroy_vm
($storecfg, $vmid, 1, { lock => 'restore' }) if -f
$vmcfgfn;
6264 my $tocmd = "/usr/lib/qemu-server/qmextract";
6266 $tocmd .= " --storage " . PVE
::Tools
::shellquote
($opts->{storage
}) if $opts->{storage
};
6267 $tocmd .= " --pool " . PVE
::Tools
::shellquote
($opts->{pool
}) if $opts->{pool
};
6268 $tocmd .= ' --prealloc' if $opts->{prealloc
};
6269 $tocmd .= ' --info' if $opts->{info
};
6271 # tar option "xf" does not autodetect compression when read from STDIN,
6272 # so we pipe to zcat
6273 my $cmd = "zcat -f|tar xf " . PVE
::Tools
::shellquote
($archive) . " " .
6274 PVE
::Tools
::shellquote
("--to-command=$tocmd");
6276 my $tmpdir = "/var/tmp/vzdumptmp$$";
6279 local $ENV{VZDUMP_TMPDIR
} = $tmpdir;
6280 local $ENV{VZDUMP_VMID
} = $vmid;
6281 local $ENV{VZDUMP_USER
} = $user;
6283 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6284 my $tmpfn = "$conffile.$$.tmp";
6286 # disable interrupts (always do cleanups)
6290 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
6298 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6300 if ($archive eq '-') {
6301 print "extracting archive from STDIN\n";
6302 run_command
($cmd, input
=> "<&STDIN");
6304 print "extracting archive '$archive'\n";
6308 return if $opts->{info
};
6312 my $statfile = "$tmpdir/qmrestore.stat";
6313 if (my $fd = IO
::File-
>new($statfile, "r")) {
6314 while (defined (my $line = <$fd>)) {
6315 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
6316 $map->{$1} = $2 if $1;
6318 print STDERR
"unable to parse line in statfile - $line\n";
6324 my $confsrc = "$tmpdir/qemu-server.conf";
6326 my $srcfd = new IO
::File
($confsrc, "r") ||
6327 die "unable to open file '$confsrc'\n";
6329 my $outfd = new IO
::File
($tmpfn, "w") ||
6330 die "unable to write config for VM $vmid\n";
6332 my $cookie = { netcount
=> 0 };
6333 while (defined (my $line = <$srcfd>)) {
6334 $restore_update_config_line->($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
6342 tar_restore_cleanup
($storecfg, "$tmpdir/qmrestore.stat") if !$opts->{info
};
6348 rename $tmpfn, $conffile ||
6349 die "unable to commit configuration file '$conffile'\n";
6351 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6353 eval { rescan
($vmid, 1); };
6357 sub foreach_storage_used_by_vm
{
6358 my ($conf, $func) = @_;
6362 foreach_drive
($conf, sub {
6363 my ($ds, $drive) = @_;
6364 return if drive_is_cdrom
($drive);
6366 my $volid = $drive->{file
};
6368 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
6369 $sidhash->{$sid} = $sid if $sid;
6372 foreach my $sid (sort keys %$sidhash) {
6377 my $qemu_snap_storage = {
6380 sub do_snapshots_with_qemu
{
6381 my ($storecfg, $volid) = @_;
6383 my $storage_name = PVE
::Storage
::parse_volume_id
($volid);
6384 my $scfg = $storecfg->{ids
}->{$storage_name};
6386 if ($qemu_snap_storage->{$scfg->{type
}} && !$scfg->{krbd
}){
6390 if ($volid =~ m/\.(qcow2|qed)$/){
6397 sub qga_check_running
{
6398 my ($vmid, $nowarn) = @_;
6400 eval { mon_cmd
($vmid, "guest-ping", timeout
=> 3); };
6402 warn "Qemu Guest Agent is not running - $@" if !$nowarn;
6408 sub template_create
{
6409 my ($vmid, $conf, $disk) = @_;
6411 my $storecfg = PVE
::Storage
::config
();
6413 foreach_drive
($conf, sub {
6414 my ($ds, $drive) = @_;
6416 return if drive_is_cdrom
($drive);
6417 return if $disk && $ds ne $disk;
6419 my $volid = $drive->{file
};
6420 return if !PVE
::Storage
::volume_has_feature
($storecfg, 'template', $volid);
6422 my $voliddst = PVE
::Storage
::vdisk_create_base
($storecfg, $volid);
6423 $drive->{file
} = $voliddst;
6424 $conf->{$ds} = print_drive
($drive);
6425 PVE
::QemuConfig-
>write_config($vmid, $conf);
6429 sub convert_iscsi_path
{
6432 if ($path =~ m
|^iscsi
://([^/]+)/([^/]+)/(.+)$|) {
6437 my $initiator_name = get_initiator_name
();
6439 return "file.driver=iscsi,file.transport=tcp,file.initiator-name=$initiator_name,".
6440 "file.portal=$portal,file.target=$target,file.lun=$lun,driver=raw";
6443 die "cannot convert iscsi path '$path', unkown format\n";
6446 sub qemu_img_convert
{
6447 my ($src_volid, $dst_volid, $size, $snapname, $is_zero_initialized) = @_;
6449 my $storecfg = PVE
::Storage
::config
();
6450 my ($src_storeid, $src_volname) = PVE
::Storage
::parse_volume_id
($src_volid, 1);
6451 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid, 1);
6453 die "destination '$dst_volid' is not a valid volid form qemu-img convert\n" if !$dst_storeid;
6457 my $src_is_iscsi = 0;
6461 PVE
::Storage
::activate_volumes
($storecfg, [$src_volid], $snapname);
6462 my $src_scfg = PVE
::Storage
::storage_config
($storecfg, $src_storeid);
6463 $src_format = qemu_img_format
($src_scfg, $src_volname);
6464 $src_path = PVE
::Storage
::path
($storecfg, $src_volid, $snapname);
6465 $src_is_iscsi = ($src_path =~ m
|^iscsi
://|);
6466 $cachemode = 'none' if $src_scfg->{type
} eq 'zfspool';
6467 } elsif (-f
$src_volid) {
6468 $src_path = $src_volid;
6469 if ($src_path =~ m/\.($PVE::QemuServer::Drive::QEMU_FORMAT_RE)$/) {
6474 die "source '$src_volid' is not a valid volid nor path for qemu-img convert\n" if !$src_path;
6476 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
6477 my $dst_format = qemu_img_format
($dst_scfg, $dst_volname);
6478 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
6479 my $dst_is_iscsi = ($dst_path =~ m
|^iscsi
://|);
6482 push @$cmd, '/usr/bin/qemu-img', 'convert', '-p', '-n';
6483 push @$cmd, '-l', "snapshot.name=$snapname"
6484 if $snapname && $src_format && $src_format eq "qcow2";
6485 push @$cmd, '-t', 'none' if $dst_scfg->{type
} eq 'zfspool';
6486 push @$cmd, '-T', $cachemode if defined($cachemode);
6488 if ($src_is_iscsi) {
6489 push @$cmd, '--image-opts';
6490 $src_path = convert_iscsi_path
($src_path);
6491 } elsif ($src_format) {
6492 push @$cmd, '-f', $src_format;
6495 if ($dst_is_iscsi) {
6496 push @$cmd, '--target-image-opts';
6497 $dst_path = convert_iscsi_path
($dst_path);
6499 push @$cmd, '-O', $dst_format;
6502 push @$cmd, $src_path;
6504 if (!$dst_is_iscsi && $is_zero_initialized) {
6505 push @$cmd, "zeroinit:$dst_path";
6507 push @$cmd, $dst_path;
6512 if($line =~ m/\((\S+)\/100\
%\)/){
6514 my $transferred = int($size * $percent / 100);
6515 my $remaining = $size - $transferred;
6517 print "transferred: $transferred bytes remaining: $remaining bytes total: $size bytes progression: $percent %\n";
6522 eval { run_command
($cmd, timeout
=> undef, outfunc
=> $parser); };
6524 die "copy failed: $err" if $err;
6527 sub qemu_img_format
{
6528 my ($scfg, $volname) = @_;
6530 if ($scfg->{path
} && $volname =~ m/\.($PVE::QemuServer::Drive::QEMU_FORMAT_RE)$/) {
6537 sub qemu_drive_mirror
{
6538 my ($vmid, $drive, $dst_volid, $vmiddst, $is_zero_initialized, $jobs, $completion, $qga, $bwlimit) = @_;
6540 $jobs = {} if !$jobs;
6544 $jobs->{"drive-$drive"} = {};
6546 if ($dst_volid =~ /^nbd:/) {
6547 $qemu_target = $dst_volid;
6550 my $storecfg = PVE
::Storage
::config
();
6551 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid);
6553 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
6555 $format = qemu_img_format
($dst_scfg, $dst_volname);
6557 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
6559 $qemu_target = $is_zero_initialized ?
"zeroinit:$dst_path" : $dst_path;
6562 my $opts = { timeout
=> 10, device
=> "drive-$drive", mode
=> "existing", sync
=> "full", target
=> $qemu_target };
6563 $opts->{format
} = $format if $format;
6565 if (defined($bwlimit)) {
6566 $opts->{speed
} = $bwlimit * 1024;
6567 print "drive mirror is starting for drive-$drive with bandwidth limit: ${bwlimit} KB/s\n";
6569 print "drive mirror is starting for drive-$drive\n";
6572 # if a job already runs for this device we get an error, catch it for cleanup
6573 eval { mon_cmd
($vmid, "drive-mirror", %$opts); };
6575 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
6577 die "mirroring error: $err\n";
6580 qemu_drive_mirror_monitor
($vmid, $vmiddst, $jobs, $completion, $qga);
6583 # $completion can be either
6584 # 'complete': wait until all jobs are ready, block-job-complete them (default)
6585 # 'cancel': wait until all jobs are ready, block-job-cancel them
6586 # 'skip': wait until all jobs are ready, return with block jobs in ready state
6587 sub qemu_drive_mirror_monitor
{
6588 my ($vmid, $vmiddst, $jobs, $completion, $qga) = @_;
6590 $completion //= 'complete';
6593 my $err_complete = 0;
6596 die "storage migration timed out\n" if $err_complete > 300;
6598 my $stats = mon_cmd
($vmid, "query-block-jobs");
6600 my $running_mirror_jobs = {};
6601 foreach my $stat (@$stats) {
6602 next if $stat->{type
} ne 'mirror';
6603 $running_mirror_jobs->{$stat->{device
}} = $stat;
6606 my $readycounter = 0;
6608 foreach my $job (keys %$jobs) {
6610 if(defined($jobs->{$job}->{complete
}) && !defined($running_mirror_jobs->{$job})) {
6611 print "$job : finished\n";
6612 delete $jobs->{$job};
6616 die "$job: mirroring has been cancelled\n" if !defined($running_mirror_jobs->{$job});
6618 my $busy = $running_mirror_jobs->{$job}->{busy
};
6619 my $ready = $running_mirror_jobs->{$job}->{ready
};
6620 if (my $total = $running_mirror_jobs->{$job}->{len
}) {
6621 my $transferred = $running_mirror_jobs->{$job}->{offset
} || 0;
6622 my $remaining = $total - $transferred;
6623 my $percent = sprintf "%.2f", ($transferred * 100 / $total);
6625 print "$job: transferred: $transferred bytes remaining: $remaining bytes total: $total bytes progression: $percent % busy: $busy ready: $ready \n";
6628 $readycounter++ if $running_mirror_jobs->{$job}->{ready
};
6631 last if scalar(keys %$jobs) == 0;
6633 if ($readycounter == scalar(keys %$jobs)) {
6634 print "all mirroring jobs are ready \n";
6635 last if $completion eq 'skip'; #do the complete later
6637 if ($vmiddst && $vmiddst != $vmid) {
6638 my $agent_running = $qga && qga_check_running
($vmid);
6639 if ($agent_running) {
6640 print "freeze filesystem\n";
6641 eval { mon_cmd
($vmid, "guest-fsfreeze-freeze"); };
6643 print "suspend vm\n";
6644 eval { PVE
::QemuServer
::vm_suspend
($vmid, 1); };
6647 # if we clone a disk for a new target vm, we don't switch the disk
6648 PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs);
6650 if ($agent_running) {
6651 print "unfreeze filesystem\n";
6652 eval { mon_cmd
($vmid, "guest-fsfreeze-thaw"); };
6654 print "resume vm\n";
6655 eval { PVE
::QemuServer
::vm_resume
($vmid, 1, 1); };
6661 foreach my $job (keys %$jobs) {
6662 # try to switch the disk if source and destination are on the same guest
6663 print "$job: Completing block job...\n";
6666 if ($completion eq 'complete') {
6667 $op = 'block-job-complete';
6668 } elsif ($completion eq 'cancel') {
6669 $op = 'block-job-cancel';
6671 die "invalid completion value: $completion\n";
6673 eval { mon_cmd
($vmid, $op, device
=> $job) };
6674 if ($@ =~ m/cannot be completed/) {
6675 print "$job: Block job cannot be completed, try again.\n";
6678 print "$job: Completed successfully.\n";
6679 $jobs->{$job}->{complete
} = 1;
6690 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
6691 die "mirroring error: $err";
6696 sub qemu_blockjobs_cancel
{
6697 my ($vmid, $jobs) = @_;
6699 foreach my $job (keys %$jobs) {
6700 print "$job: Cancelling block job\n";
6701 eval { mon_cmd
($vmid, "block-job-cancel", device
=> $job); };
6702 $jobs->{$job}->{cancel
} = 1;
6706 my $stats = mon_cmd
($vmid, "query-block-jobs");
6708 my $running_jobs = {};
6709 foreach my $stat (@$stats) {
6710 $running_jobs->{$stat->{device
}} = $stat;
6713 foreach my $job (keys %$jobs) {
6715 if (defined($jobs->{$job}->{cancel
}) && !defined($running_jobs->{$job})) {
6716 print "$job: Done.\n";
6717 delete $jobs->{$job};
6721 last if scalar(keys %$jobs) == 0;
6728 my ($storecfg, $vmid, $running, $drivename, $drive, $snapname,
6729 $newvmid, $storage, $format, $full, $newvollist, $jobs, $completion, $qga, $bwlimit) = @_;
6734 print "create linked clone of drive $drivename ($drive->{file})\n";
6735 $newvolid = PVE
::Storage
::vdisk_clone
($storecfg, $drive->{file
}, $newvmid, $snapname);
6736 push @$newvollist, $newvolid;
6739 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
6740 $storeid = $storage if $storage;
6742 my $dst_format = resolve_dst_disk_format
($storecfg, $storeid, $volname, $format);
6743 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $drive->{file
}, 3);
6745 print "create full clone of drive $drivename ($drive->{file})\n";
6747 if (drive_is_cloudinit
($drive)) {
6748 $name = "vm-$newvmid-cloudinit";
6749 $name .= ".$dst_format" if $dst_format ne 'raw';
6751 $size = PVE
::QemuServer
::Cloudinit
::CLOUDINIT_DISK_SIZE
;
6753 $newvolid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $newvmid, $dst_format, $name, ($size/1024));
6754 push @$newvollist, $newvolid;
6756 PVE
::Storage
::activate_volumes
($storecfg, [$newvolid]);
6758 if (drive_is_cloudinit
($drive)) {
6762 my $sparseinit = PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $newvolid);
6763 if (!$running || $snapname) {
6764 # TODO: handle bwlimits
6765 qemu_img_convert
($drive->{file
}, $newvolid, $size, $snapname, $sparseinit);
6768 my $kvmver = get_running_qemu_version
($vmid);
6769 if (!min_version
($kvmver, 2, 7)) {
6770 die "drive-mirror with iothread requires qemu version 2.7 or higher\n"
6771 if $drive->{iothread
};
6774 qemu_drive_mirror
($vmid, $drivename, $newvolid, $newvmid, $sparseinit, $jobs, $completion, $qga, $bwlimit);
6779 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $newvolid, 3);
6782 $disk->{format
} = undef;
6783 $disk->{file
} = $newvolid;
6784 $disk->{size
} = $size;
6789 sub get_running_qemu_version
{
6791 my $res = mon_cmd
($vmid, "query-version");
6792 return "$res->{qemu}->{major}.$res->{qemu}->{minor}";
6795 sub qemu_use_old_bios_files
{
6796 my ($machine_type) = @_;
6798 return if !$machine_type;
6800 my $use_old_bios_files = undef;
6802 if ($machine_type =~ m/^(\S+)\.pxe$/) {
6804 $use_old_bios_files = 1;
6806 my $version = PVE
::QemuServer
::Machine
::extract_version
($machine_type, kvm_user_version
());
6807 # Note: kvm version < 2.4 use non-efi pxe files, and have problems when we
6808 # load new efi bios files on migration. So this hack is required to allow
6809 # live migration from qemu-2.2 to qemu-2.4, which is sometimes used when
6810 # updrading from proxmox-ve-3.X to proxmox-ve 4.0
6811 $use_old_bios_files = !min_version
($version, 2, 4);
6814 return ($use_old_bios_files, $machine_type);
6817 sub create_efidisk
($$$$$) {
6818 my ($storecfg, $storeid, $vmid, $fmt, $arch) = @_;
6820 my (undef, $ovmf_vars) = get_ovmf_files
($arch);
6821 die "EFI vars default image not found\n" if ! -f
$ovmf_vars;
6823 my $vars_size_b = -s
$ovmf_vars;
6824 my $vars_size = PVE
::Tools
::convert_size
($vars_size_b, 'b' => 'kb');
6825 my $volid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $vmid, $fmt, undef, $vars_size);
6826 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
6828 qemu_img_convert
($ovmf_vars, $volid, $vars_size_b, undef, 0);
6829 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $volid, 3);
6831 return ($volid, $size/1024);
6834 sub vm_iothreads_list
{
6837 my $res = mon_cmd
($vmid, 'query-iothreads');
6840 foreach my $iothread (@$res) {
6841 $iothreads->{ $iothread->{id
} } = $iothread->{"thread-id"};
6848 my ($conf, $drive) = @_;
6852 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)) {
6854 } elsif ($conf->{scsihw
} && ($conf->{scsihw
} eq 'virtio-scsi-single')) {
6860 my $controller = int($drive->{index} / $maxdev);
6861 my $controller_prefix = ($conf->{scsihw
} && $conf->{scsihw
} eq 'virtio-scsi-single') ?
"virtioscsi" : "scsihw";
6863 return ($maxdev, $controller, $controller_prefix);
6866 sub windows_version
{
6869 return 0 if !$ostype;
6873 if($ostype eq 'wxp' || $ostype eq 'w2k3' || $ostype eq 'w2k') {
6875 } elsif($ostype eq 'w2k8' || $ostype eq 'wvista') {
6877 } elsif ($ostype =~ m/^win(\d+)$/) {
6884 sub resolve_dst_disk_format
{
6885 my ($storecfg, $storeid, $src_volname, $format) = @_;
6886 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
6889 # if no target format is specified, use the source disk format as hint
6891 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
6892 $format = qemu_img_format
($scfg, $src_volname);
6898 # test if requested format is supported - else use default
6899 my $supported = grep { $_ eq $format } @$validFormats;
6900 $format = $defFormat if !$supported;
6904 # NOTE: if this logic changes, please update docs & possibly gui logic
6905 sub find_vmstate_storage
{
6906 my ($conf, $storecfg) = @_;
6908 # first, return storage from conf if set
6909 return $conf->{vmstatestorage
} if $conf->{vmstatestorage
};
6911 my ($target, $shared, $local);
6913 foreach_storage_used_by_vm
($conf, sub {
6915 my $scfg = PVE
::Storage
::storage_config
($storecfg, $sid);
6916 my $dst = $scfg->{shared
} ? \
$shared : \
$local;
6917 $$dst = $sid if !$$dst || $scfg->{path
}; # prefer file based storage
6920 # second, use shared storage where VM has at least one disk
6921 # third, use local storage where VM has at least one disk
6922 # fall back to local storage
6923 $target = $shared // $local // 'local';
6929 my ($uuid, $uuid_str);
6930 UUID
::generate
($uuid);
6931 UUID
::unparse
($uuid, $uuid_str);
6935 sub generate_smbios1_uuid
{
6936 return "uuid=".generate_uuid
();
6942 mon_cmd
($vmid, 'nbd-server-stop');
6945 sub create_reboot_request
{
6947 open(my $fh, '>', "/run/qemu-server/$vmid.reboot")
6948 or die "failed to create reboot trigger file: $!\n";
6952 sub clear_reboot_request
{
6954 my $path = "/run/qemu-server/$vmid.reboot";
6957 $res = unlink($path);
6958 die "could not remove reboot request for $vmid: $!"
6959 if !$res && $! != POSIX
::ENOENT
;
6964 # bash completion helper
6966 sub complete_backup_archives
{
6967 my ($cmdname, $pname, $cvalue) = @_;
6969 my $cfg = PVE
::Storage
::config
();
6973 if ($cvalue =~ m/^([^:]+):/) {
6977 my $data = PVE
::Storage
::template_list
($cfg, $storeid, 'backup');
6980 foreach my $id (keys %$data) {
6981 foreach my $item (@{$data->{$id}}) {
6982 next if $item->{format
} !~ m/^vma\.(gz|lzo)$/;
6983 push @$res, $item->{volid
} if defined($item->{volid
});
6990 my $complete_vmid_full = sub {
6993 my $idlist = vmstatus
();
6997 foreach my $id (keys %$idlist) {
6998 my $d = $idlist->{$id};
6999 if (defined($running)) {
7000 next if $d->{template
};
7001 next if $running && $d->{status
} ne 'running';
7002 next if !$running && $d->{status
} eq 'running';
7011 return &$complete_vmid_full();
7014 sub complete_vmid_stopped
{
7015 return &$complete_vmid_full(0);
7018 sub complete_vmid_running
{
7019 return &$complete_vmid_full(1);
7022 sub complete_storage
{
7024 my $cfg = PVE
::Storage
::config
();
7025 my $ids = $cfg->{ids
};
7028 foreach my $sid (keys %$ids) {
7029 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, undef, 1);
7030 next if !$ids->{$sid}->{content
}->{images
};
7037 sub complete_migration_storage
{
7038 my ($cmd, $param, $current_value, $all_args) = @_;
7040 my $targetnode = @$all_args[1];
7042 my $cfg = PVE
::Storage
::config
();
7043 my $ids = $cfg->{ids
};
7046 foreach my $sid (keys %$ids) {
7047 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, $targetnode, 1);
7048 next if !$ids->{$sid}->{content
}->{images
};