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);
31 use PVE
::DataCenterConfig
;
32 use PVE
::Exception
qw(raise raise_param_exc);
33 use PVE
::Format
qw(render_duration render_bytes);
34 use PVE
::GuestHelpers
qw(safe_string_ne safe_num_ne safe_boolean_ne);
36 use PVE
::JSONSchema
qw(get_standard_option parse_property_string);
39 use PVE
::RPCEnvironment
;
43 use PVE
::Tools
qw(run_command file_read_firstline file_get_contents dir_glob_foreach get_host_arch $IPV6RE);
47 use PVE
::QemuServer
::Helpers
qw(min_version config_aware_timeout);
48 use PVE
::QemuServer
::Cloudinit
;
49 use PVE
::QemuServer
::CGroup
;
50 use PVE
::QemuServer
::CPUConfig
qw(print_cpu_device get_cpu_options);
51 use PVE
::QemuServer
::Drive
qw(is_valid_drivename drive_is_cloudinit drive_is_cdrom parse_drive print_drive);
52 use PVE
::QemuServer
::Machine
;
53 use PVE
::QemuServer
::Memory
;
54 use PVE
::QemuServer
::Monitor
qw(mon_cmd);
55 use PVE
::QemuServer
::PCI
qw(print_pci_addr print_pcie_addr print_pcie_root_port parse_hostpci);
56 use PVE
::QemuServer
::USB
qw(parse_usb_device);
60 require PVE
::Network
::SDN
::Zones
;
64 my $EDK2_FW_BASE = '/usr/share/pve-edk2-firmware/';
67 "$EDK2_FW_BASE/OVMF_CODE.fd",
68 "$EDK2_FW_BASE/OVMF_VARS.fd"
71 "$EDK2_FW_BASE/AAVMF_CODE.fd",
72 "$EDK2_FW_BASE/AAVMF_VARS.fd"
76 my $cpuinfo = PVE
::ProcFSTools
::read_cpuinfo
();
78 # Note about locking: we use flock on the config file protect
79 # against concurent actions.
80 # Aditionaly, we have a 'lock' setting in the config file. This
81 # can be set to 'migrate', 'backup', 'snapshot' or 'rollback'. Most actions are not
82 # allowed when such lock is set. But you can ignore this kind of
83 # lock with the --skiplock flag.
85 cfs_register_file
('/qemu-server/',
89 PVE
::JSONSchema
::register_standard_option
('pve-qm-stateuri', {
90 description
=> "Some command save/restore state from this location.",
96 PVE
::JSONSchema
::register_standard_option
('pve-qemu-machine', {
97 description
=> "Specifies the Qemu machine type.",
99 pattern
=> '(pc|pc(-i440fx)?-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|q35|pc-q35-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|virt(?:-\d+(\.\d+)+)?(\+pve\d+)?)',
106 my ($map, $source) = @_;
108 return $source if !defined($map);
110 return $map->{entries
}->{$source}
111 if $map->{entries
} && defined($map->{entries
}->{$source});
113 return $map->{default} if $map->{default};
115 # identity (fallback)
119 PVE
::JSONSchema
::register_standard_option
('pve-targetstorage', {
120 description
=> "Mapping from source to target storages. Providing only a single storage ID maps all source storages to that storage. Providing the special value '1' will map each source storage to itself.",
122 format
=> 'storagepair-list',
126 #no warnings 'redefine';
130 $nodename_cache //= PVE
::INotify
::nodename
();
131 return $nodename_cache;
138 enum
=> [qw(i6300esb ib700)],
139 description
=> "Watchdog type to emulate.",
140 default => 'i6300esb',
145 enum
=> [qw(reset shutdown poweroff pause debug none)],
146 description
=> "The action to perform if after activation the guest fails to poll the watchdog in time.",
150 PVE
::JSONSchema
::register_format
('pve-qm-watchdog', $watchdog_fmt);
154 description
=> "Enable/disable Qemu GuestAgent.",
159 fstrim_cloned_disks
=> {
160 description
=> "Run fstrim after moving a disk or migrating the VM.",
166 description
=> "Select the agent type",
170 enum
=> [qw(virtio isa)],
176 description
=> "Select the VGA type.",
181 enum
=> [qw(cirrus qxl qxl2 qxl3 qxl4 none serial0 serial1 serial2 serial3 std virtio vmware)],
184 description
=> "Sets the VGA memory (in MiB). Has no effect with serial display.",
196 description
=> "The size of the file in MB.",
200 pattern
=> '[a-zA-Z0-9\-]+',
202 format_description
=> 'string',
203 description
=> "The name of the file. Will be prefixed with 'pve-shm-'. Default is the VMID. Will be deleted when the VM is stopped.",
210 enum
=> [qw(ich9-intel-hda intel-hda AC97)],
211 description
=> "Configure an audio device."
215 enum
=> ['spice', 'none'],
218 description
=> "Driver backend for the audio device."
222 my $spice_enhancements_fmt = {
227 description
=> "Enable folder sharing via SPICE. Needs Spice-WebDAV daemon installed in the VM."
231 enum
=> ['off', 'all', 'filter'],
234 description
=> "Enable video streaming. Uses compression for detected video streams."
241 enum
=> ['/dev/urandom', '/dev/random', '/dev/hwrng'],
243 description
=> "The file on the host to gather entropy from. In most"
244 . " cases /dev/urandom should be preferred over /dev/random"
245 . " to avoid entropy-starvation issues on the host. Using"
246 . " urandom does *not* decrease security in any meaningful"
247 . " way, as it's still seeded from real entropy, and the"
248 . " bytes provided will most likely be mixed with real"
249 . " entropy on the guest as well. /dev/hwrng can be used"
250 . " to pass through a hardware RNG from the host.",
254 description
=> "Maximum bytes of entropy injected into the guest every"
255 . " 'period' milliseconds. Prefer a lower value when using"
256 . " /dev/random as source. Use 0 to disable limiting"
257 . " (potentially dangerous!).",
260 # default is 1 KiB/s, provides enough entropy to the guest to avoid
261 # boot-starvation issues (e.g. systemd etc...) while allowing no chance
262 # of overwhelming the host, provided we're reading from /dev/urandom
267 description
=> "Every 'period' milliseconds the entropy-injection quota"
268 . " is reset, allowing the guest to retrieve another"
269 . " 'max_bytes' of entropy.",
279 description
=> "Specifies whether a VM will be started during system bootup.",
285 description
=> "Automatic restart after crash (currently ignored).",
290 type
=> 'string', format
=> 'pve-hotplug-features',
291 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'.",
292 default => 'network,disk,usb',
297 description
=> "Allow reboot. If set to '0' the VM exit on reboot.",
303 description
=> "Lock/unlock the VM.",
304 enum
=> [qw(backup clone create migrate rollback snapshot snapshot-delete suspending suspended)],
309 description
=> "Limit of CPU usage.",
310 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.",
318 description
=> "CPU weight for a VM.",
319 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.",
327 description
=> "Amount of RAM for the VM in MB. This is the maximum available memory when you use the balloon device.",
334 description
=> "Amount of target RAM for the VM in MB. Using zero disables the ballon driver.",
340 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.",
348 description
=> "Keybord layout for vnc server. Default is read from the '/etc/pve/datacenter.cfg' configuration file.".
349 "It should not be necessary to set it.",
350 enum
=> PVE
::Tools
::kvmkeymaplist
(),
355 type
=> 'string', format
=> 'dns-name',
356 description
=> "Set a name for the VM. Only used on the configuration web interface.",
361 description
=> "SCSI controller model",
362 enum
=> [qw(lsi lsi53c810 virtio-scsi-pci virtio-scsi-single megasas pvscsi)],
368 description
=> "Description for the VM. Only used on the configuration web interface. This is saved as comment inside the configuration file.",
373 enum
=> [qw(other wxp w2k w2k3 w2k8 wvista win7 win8 win10 l24 l26 solaris)],
374 description
=> "Specify guest operating system.",
375 verbose_description
=> <<EODESC,
376 Specify guest operating system. This is used to enable special
377 optimization/features for specific operating systems:
380 other;; unspecified OS
381 wxp;; Microsoft Windows XP
382 w2k;; Microsoft Windows 2000
383 w2k3;; Microsoft Windows 2003
384 w2k8;; Microsoft Windows 2008
385 wvista;; Microsoft Windows Vista
386 win7;; Microsoft Windows 7
387 win8;; Microsoft Windows 8/2012/2012r2
388 win10;; Microsoft Windows 10/2016/2019
389 l24;; Linux 2.4 Kernel
390 l26;; Linux 2.6 - 5.X Kernel
391 solaris;; Solaris/OpenSolaris/OpenIndiania kernel
396 type
=> 'string', format
=> 'pve-qm-boot',
397 description
=> "Specify guest boot order. Use with 'order=', usage with"
398 . " no key or 'legacy=' is deprecated.",
402 type
=> 'string', format
=> 'pve-qm-bootdisk',
403 description
=> "Enable booting from specified disk. Deprecated: Use 'boot: order=foo;bar' instead.",
404 pattern
=> '(ide|sata|scsi|virtio)\d+',
409 description
=> "The number of CPUs. Please use option -sockets instead.",
416 description
=> "The number of CPU sockets.",
423 description
=> "The number of cores per socket.",
430 description
=> "Enable/disable NUMA.",
436 description
=> "Enable/disable hugepages memory.",
437 enum
=> [qw(any 2 1024)],
443 description
=> "Use together with hugepages. If enabled, hugepages will not not be deleted"
444 ." after VM shutdown and can be used for subsequent starts.",
449 description
=> "Number of hotplugged vcpus.",
456 description
=> "Enable/disable ACPI.",
461 description
=> "Enable/disable Qemu GuestAgent and its properties.",
463 format
=> $agent_fmt,
468 description
=> "Enable/disable KVM hardware virtualization.",
474 description
=> "Enable/disable time drift fix.",
480 description
=> "Set the real time clock to local time. This is enabled by default if ostype"
481 ." indicates a Microsoft OS.",
486 description
=> "Freeze CPU at startup (use 'c' monitor command to start execution).",
490 type
=> 'string', format
=> $vga_fmt,
491 description
=> "Configure the VGA hardware.",
492 verbose_description
=> "Configure the VGA Hardware. If you want to use high resolution"
493 ." modes (>= 1280x1024x16) you may need to increase the vga memory option. Since QEMU"
494 ." 2.9 the default VGA display type is 'std' for all OS types besides some Windows"
495 ." versions (XP and older) which use 'cirrus'. The 'qxl' option enables the SPICE"
496 ." display server. For win* OS you can select how many independent displays you want,"
497 ." Linux guests can add displays them self.\nYou can also run without any graphic card,"
498 ." using a serial device as terminal.",
502 type
=> 'string', format
=> 'pve-qm-watchdog',
503 description
=> "Create a virtual hardware watchdog device.",
504 verbose_description
=> "Create a virtual hardware watchdog device. Once enabled (by a guest"
505 ." action), the watchdog must be periodically polled by an agent inside the guest or"
506 ." else the watchdog will reset the guest (or execute the respective action specified)",
511 typetext
=> "(now | YYYY-MM-DD | YYYY-MM-DDTHH:MM:SS)",
512 description
=> "Set the initial date of the real time clock. Valid format for date are:"
513 ."'now' or '2006-06-17T16:01:21' or '2006-06-17'.",
514 pattern
=> '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
517 startup
=> get_standard_option
('pve-startup-order'),
521 description
=> "Enable/disable Template.",
527 description
=> "Arbitrary arguments passed to kvm.",
528 verbose_description
=> <<EODESCR,
529 Arbitrary arguments passed to kvm, for example:
531 args: -no-reboot -no-hpet
533 NOTE: this option is for experts only.
540 description
=> "Enable/disable the USB tablet device.",
541 verbose_description
=> "Enable/disable the USB tablet device. This device is usually needed"
542 ." to allow absolute mouse positioning with VNC. Else the mouse runs out of sync with"
543 ." normal VNC clients. If you're running lots of console-only guests on one host, you"
544 ." may consider disabling this to save some context switches. This is turned off by"
545 ." default if you use spice (`qm set <vmid> --vga qxl`).",
550 description
=> "Set maximum speed (in MB/s) for migrations. Value 0 is no limit.",
554 migrate_downtime
=> {
557 description
=> "Set maximum tolerated downtime (in seconds) for migrations.",
563 type
=> 'string', format
=> 'pve-qm-ide',
564 typetext
=> '<volume>',
565 description
=> "This is an alias for option -ide2",
569 description
=> "Emulated CPU type.",
571 format
=> 'pve-vm-cpu-conf',
573 parent
=> get_standard_option
('pve-snapshot-name', {
575 description
=> "Parent snapshot name. This is used internally, and should not be modified.",
579 description
=> "Timestamp for snapshots.",
585 type
=> 'string', format
=> 'pve-volume-id',
586 description
=> "Reference to a volume which stores the VM state. This is used internally"
589 vmstatestorage
=> get_standard_option
('pve-storage-id', {
590 description
=> "Default storage for VM state volumes/files.",
593 runningmachine
=> get_standard_option
('pve-qemu-machine', {
594 description
=> "Specifies the QEMU machine type of the running vm. This is used internally"
598 description
=> "Specifies the QEMU '-cpu' parameter of the running vm. This is used"
599 ." internally for snapshots.",
602 pattern
=> $PVE::QemuServer
::CPUConfig
::qemu_cmdline_cpu_re
,
603 format_description
=> 'QEMU -cpu parameter'
605 machine
=> get_standard_option
('pve-qemu-machine'),
607 description
=> "Virtual processor architecture. Defaults to the host.",
610 enum
=> [qw(x86_64 aarch64)],
613 description
=> "Specify SMBIOS type 1 fields.",
614 type
=> 'string', format
=> 'pve-qm-smbios1',
621 description
=> "Sets the protection flag of the VM. This will disable the remove VM and"
622 ." remove disk operations.",
628 enum
=> [ qw(seabios ovmf) ],
629 description
=> "Select BIOS implementation.",
630 default => 'seabios',
634 pattern
=> '(?:[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}|[01])',
635 format_description
=> 'UUID',
636 description
=> "Set VM Generation ID. Use '1' to autogenerate on create or update, pass '0'"
637 ." to disable explicitly.",
638 verbose_description
=> "The VM generation ID (vmgenid) device exposes a 128-bit integer"
639 ." value identifier to the guest OS. This allows to notify the guest operating system"
640 ." when the virtual machine is executed with a different configuration (e.g. snapshot"
641 ." execution or creation from a template). The guest operating system notices the"
642 ." change, and is then able to react as appropriate by marking its copies of"
643 ." distributed databases as dirty, re-initializing its random number generator, etc.\n"
644 ."Note that auto-creation only works when done through API/CLI create or update methods"
645 .", but not when manually editing the config file.",
646 default => "1 (autogenerated)",
651 format
=> 'pve-volume-id',
653 description
=> "Script that will be executed during various steps in the vms lifetime.",
657 format
=> $ivshmem_fmt,
658 description
=> "Inter-VM shared memory. Useful for direct communication between VMs, or to"
664 format
=> $audio_fmt,
665 description
=> "Configure a audio device, useful in combination with QXL/Spice.",
668 spice_enhancements
=> {
670 format
=> $spice_enhancements_fmt,
671 description
=> "Configure additional enhancements for SPICE.",
675 type
=> 'string', format
=> 'pve-tag-list',
676 description
=> 'Tags of the VM. This is only meta information.',
682 description
=> "Configure a VirtIO-based Random Number Generator.",
691 description
=> 'Specify a custom file containing all meta data passed to the VM via"
692 ." cloud-init. This is provider specific meaning configdrive2 and nocloud differ.',
693 format
=> 'pve-volume-id',
694 format_description
=> 'volume',
699 description
=> 'Specify a custom file containing all network data passed to the VM via'
701 format
=> 'pve-volume-id',
702 format_description
=> 'volume',
707 description
=> 'Specify a custom file containing all user data passed to the VM via'
709 format
=> 'pve-volume-id',
710 format_description
=> 'volume',
713 PVE
::JSONSchema
::register_format
('pve-qm-cicustom', $cicustom_fmt);
715 my $confdesc_cloudinit = {
719 description
=> 'Specifies the cloud-init configuration format. The default depends on the'
720 .' configured operating system type (`ostype`. We use the `nocloud` format for Linux,'
721 .' and `configdrive2` for windows.',
722 enum
=> ['configdrive2', 'nocloud', 'opennebula'],
727 description
=> "cloud-init: User name to change ssh keys and password for instead of the"
728 ." image's configured default user.",
733 description
=> 'cloud-init: Password to assign the user. Using this is generally not'
734 .' recommended. Use ssh keys instead. Also note that older cloud-init versions do not'
735 .' support hashed passwords.',
740 description
=> 'cloud-init: Specify custom files to replace the automatically generated'
742 format
=> 'pve-qm-cicustom',
747 description
=> "cloud-init: Sets DNS search domains for a container. Create will'
748 .' automatically use the setting from the host if neither searchdomain nor nameserver'
753 type
=> 'string', format
=> 'address-list',
754 description
=> "cloud-init: Sets DNS server IP address for a container. Create will'
755 .' automatically use the setting from the host if neither searchdomain nor nameserver'
761 format
=> 'urlencoded',
762 description
=> "cloud-init: Setup public SSH keys (one key per line, OpenSSH format).",
766 # what about other qemu settings ?
768 #machine => 'string',
781 ##soundhw => 'string',
783 while (my ($k, $v) = each %$confdesc) {
784 PVE
::JSONSchema
::register_standard_option
("pve-qm-$k", $v);
787 my $MAX_USB_DEVICES = 5;
789 my $MAX_SERIAL_PORTS = 4;
790 my $MAX_PARALLEL_PORTS = 3;
796 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
797 description
=> "CPUs accessing this NUMA node.",
798 format_description
=> "id[-id];...",
802 description
=> "Amount of memory this NUMA node provides.",
807 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
808 description
=> "Host NUMA nodes to use.",
809 format_description
=> "id[-id];...",
814 enum
=> [qw(preferred bind interleave)],
815 description
=> "NUMA allocation policy.",
819 PVE
::JSONSchema
::register_format
('pve-qm-numanode', $numa_fmt);
822 type
=> 'string', format
=> $numa_fmt,
823 description
=> "NUMA topology.",
825 PVE
::JSONSchema
::register_standard_option
("pve-qm-numanode", $numadesc);
827 for (my $i = 0; $i < $MAX_NUMA; $i++) {
828 $confdesc->{"numa$i"} = $numadesc;
831 my $nic_model_list = ['rtl8139', 'ne2k_pci', 'e1000', 'pcnet', 'virtio',
832 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3',
833 'e1000-82540em', 'e1000-82544gc', 'e1000-82545em'];
834 my $nic_model_list_txt = join(' ', sort @$nic_model_list);
836 my $net_fmt_bridge_descr = <<__EOD__;
837 Bridge to attach the network device to. The Proxmox VE standard bridge
840 If you do not specify a bridge, we create a kvm user (NATed) network
841 device, which provides DHCP and DNS services. The following addresses
848 The DHCP server assign addresses to the guest starting from 10.0.2.15.
852 macaddr
=> get_standard_option
('mac-addr', {
853 description
=> "MAC address. That address must be unique withing your network. This is"
854 ." automatically generated if not specified.",
858 description
=> "Network Card Model. The 'virtio' model provides the best performance with"
859 ." very low CPU overhead. If your guest does not support this driver, it is usually"
860 ." best to use 'e1000'.",
861 enum
=> $nic_model_list,
864 (map { $_ => { keyAlias
=> 'model', alias
=> 'macaddr' }} @$nic_model_list),
867 description
=> $net_fmt_bridge_descr,
868 format_description
=> 'bridge',
869 pattern
=> '[-_.\w\d]+',
874 minimum
=> 0, maximum
=> 16,
875 description
=> 'Number of packet queues to be used on the device.',
881 description
=> "Rate limit in mbps (megabytes per second) as floating point number.",
886 minimum
=> 1, maximum
=> 4094,
887 description
=> 'VLAN tag to apply to packets on this interface.',
892 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
893 description
=> 'VLAN trunks to pass through this interface.',
894 format_description
=> 'vlanid[;vlanid...]',
899 description
=> 'Whether this interface should be protected by the firewall.',
904 description
=> 'Whether this interface should be disconnected (like pulling the plug).',
909 minimum
=> 1, maximum
=> 65520,
910 description
=> "Force MTU, for VirtIO only. Set to '1' to use the bridge MTU",
917 type
=> 'string', format
=> $net_fmt,
918 description
=> "Specify network devices.",
921 PVE
::JSONSchema
::register_standard_option
("pve-qm-net", $netdesc);
926 format
=> 'pve-ipv4-config',
927 format_description
=> 'IPv4Format/CIDR',
928 description
=> 'IPv4 address in CIDR format.',
935 format_description
=> 'GatewayIPv4',
936 description
=> 'Default gateway for IPv4 traffic.',
942 format
=> 'pve-ipv6-config',
943 format_description
=> 'IPv6Format/CIDR',
944 description
=> 'IPv6 address in CIDR format.',
951 format_description
=> 'GatewayIPv6',
952 description
=> 'Default gateway for IPv6 traffic.',
957 PVE
::JSONSchema
::register_format
('pve-qm-ipconfig', $ipconfig_fmt);
960 type
=> 'string', format
=> 'pve-qm-ipconfig',
961 description
=> <<'EODESCR',
962 cloud-init: Specify IP addresses and gateways for the corresponding interface.
964 IP addresses use CIDR notation, gateways are optional but need an IP of the same type specified.
966 The special string 'dhcp' can be used for IP addresses to use DHCP, in which case no explicit
967 gateway should be provided.
968 For IPv6 the special string 'auto' can be used to use stateless autoconfiguration. This requires
969 cloud-init 19.4 or newer.
971 If cloud-init is enabled and neither an IPv4 nor an IPv6 address is specified, it defaults to using
975 PVE
::JSONSchema
::register_standard_option
("pve-qm-ipconfig", $netdesc);
977 for (my $i = 0; $i < $MAX_NETS; $i++) {
978 $confdesc->{"net$i"} = $netdesc;
979 $confdesc_cloudinit->{"ipconfig$i"} = $ipconfigdesc;
982 foreach my $key (keys %$confdesc_cloudinit) {
983 $confdesc->{$key} = $confdesc_cloudinit->{$key};
986 PVE
::JSONSchema
::register_format
('pve-volume-id-or-qm-path', \
&verify_volume_id_or_qm_path
);
987 sub verify_volume_id_or_qm_path
{
988 my ($volid, $noerr) = @_;
990 if ($volid eq 'none' || $volid eq 'cdrom' || $volid =~ m
|^/|) {
994 # if its neither 'none' nor 'cdrom' nor a path, check if its a volume-id
995 $volid = eval { PVE
::JSONSchema
::check_format
('pve-volume-id', $volid, '') };
1006 type
=> 'string', format
=> 'pve-qm-usb-device',
1007 format_description
=> 'HOSTUSBDEVICE|spice',
1008 description
=> <<EODESCR,
1009 The Host USB device or port or the value 'spice'. HOSTUSBDEVICE syntax is:
1011 'bus-port(.port)*' (decimal numbers) or
1012 'vendor_id:product_id' (hexadeciaml numbers) or
1015 You can use the 'lsusb -t' command to list existing usb devices.
1017 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such
1018 machines - use with special care.
1020 The value 'spice' can be used to add a usb redirection devices for spice.
1026 description
=> "Specifies whether if given host option is a USB3 device or port.",
1033 type
=> 'string', format
=> $usb_fmt,
1034 description
=> "Configure an USB device (n is 0 to 4).",
1036 PVE
::JSONSchema
::register_standard_option
("pve-qm-usb", $usbdesc);
1041 pattern
=> '(/dev/.+|socket)',
1042 description
=> "Create a serial device inside the VM (n is 0 to 3)",
1043 verbose_description
=> <<EODESCR,
1044 Create a serial device inside the VM (n is 0 to 3), and pass through a
1045 host serial device (i.e. /dev/ttyS0), or create a unix socket on the
1046 host side (use 'qm terminal' to open a terminal connection).
1048 NOTE: If you pass through a host serial device, it is no longer possible to migrate such machines -
1049 use with special care.
1051 CAUTION: Experimental! User reported problems with this option.
1058 pattern
=> '/dev/parport\d+|/dev/usb/lp\d+',
1059 description
=> "Map host parallel devices (n is 0 to 2).",
1060 verbose_description
=> <<EODESCR,
1061 Map host parallel devices (n is 0 to 2).
1063 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such
1064 machines - use with special care.
1066 CAUTION: Experimental! User reported problems with this option.
1070 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
1071 $confdesc->{"parallel$i"} = $paralleldesc;
1074 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
1075 $confdesc->{"serial$i"} = $serialdesc;
1078 for (my $i = 0; $i < $PVE::QemuServer
::PCI
::MAX_HOSTPCI_DEVICES
; $i++) {
1079 $confdesc->{"hostpci$i"} = $PVE::QemuServer
::PCI
::hostpcidesc
;
1082 for my $key (keys %{$PVE::QemuServer
::Drive
::drivedesc_hash
}) {
1083 $confdesc->{$key} = $PVE::QemuServer
::Drive
::drivedesc_hash-
>{$key};
1086 for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
1087 $confdesc->{"usb$i"} = $usbdesc;
1095 description
=> "Boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)."
1096 . " Deprecated, use 'order=' instead.",
1097 pattern
=> '[acdn]{1,4}',
1098 format_description
=> "[acdn]{1,4}",
1100 # note: this is also the fallback if boot: is not given at all
1106 format
=> 'pve-qm-bootdev-list',
1107 format_description
=> "device[;device...]",
1108 description
=> <<EODESC,
1109 The guest will attempt to boot from devices in the order they appear here.
1111 Disks, optical drives and passed-through storage USB devices will be directly
1112 booted from, NICs will load PXE, and PCIe devices will either behave like disks
1113 (e.g. NVMe) or load an option ROM (e.g. RAID controller, hardware NIC).
1115 Note that only devices in this list will be marked as bootable and thus loaded
1116 by the guest firmware (BIOS/UEFI). If you require multiple disks for booting
1117 (e.g. software-raid), you need to specify all of them here.
1119 Overrides the deprecated 'legacy=[acdn]*' value when given.
1123 PVE
::JSONSchema
::register_format
('pve-qm-boot', $boot_fmt);
1125 PVE
::JSONSchema
::register_format
('pve-qm-bootdev', \
&verify_bootdev
);
1126 sub verify_bootdev
{
1127 my ($dev, $noerr) = @_;
1129 return $dev if PVE
::QemuServer
::Drive
::is_valid_drivename
($dev) && $dev !~ m/^efidisk/;
1133 return 0 if $dev !~ m/^$base\d+$/;
1134 return 0 if !$confdesc->{$dev};
1138 return $dev if $check->("net");
1139 return $dev if $check->("usb");
1140 return $dev if $check->("hostpci");
1143 die "invalid boot device '$dev'\n";
1146 sub print_bootorder
{
1148 return "" if !@$devs;
1149 my $data = { order
=> join(';', @$devs) };
1150 return PVE
::JSONSchema
::print_property_string
($data, $boot_fmt);
1153 my $kvm_api_version = 0;
1156 return $kvm_api_version if $kvm_api_version;
1158 open my $fh, '<', '/dev/kvm' or return;
1160 # 0xae00 => KVM_GET_API_VERSION
1161 $kvm_api_version = ioctl($fh, 0xae00, 0);
1164 return $kvm_api_version;
1167 my $kvm_user_version = {};
1170 sub kvm_user_version
{
1173 $binary //= get_command_for_arch
(get_host_arch
()); # get the native arch by default
1174 my $st = stat($binary);
1176 my $cachedmtime = $kvm_mtime->{$binary} // -1;
1177 return $kvm_user_version->{$binary} if $kvm_user_version->{$binary} &&
1178 $cachedmtime == $st->mtime;
1180 $kvm_user_version->{$binary} = 'unknown';
1181 $kvm_mtime->{$binary} = $st->mtime;
1185 if ($line =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)(\.\d+)?[,\s]/) {
1186 $kvm_user_version->{$binary} = $2;
1190 eval { run_command
([$binary, '--version'], outfunc
=> $code); };
1193 return $kvm_user_version->{$binary};
1196 my sub extract_version
{
1197 my ($machine_type, $version) = @_;
1198 $version = kvm_user_version
() if !defined($version);
1199 PVE
::QemuServer
::Machine
::extract_version
($machine_type, $version)
1202 sub kernel_has_vhost_net
{
1203 return -c
'/dev/vhost-net';
1208 return defined($confdesc->{$key});
1212 sub get_cdrom_path
{
1214 return $cdrom_path if $cdrom_path;
1216 return $cdrom_path = "/dev/cdrom" if -l
"/dev/cdrom";
1217 return $cdrom_path = "/dev/cdrom1" if -l
"/dev/cdrom1";
1218 return $cdrom_path = "/dev/cdrom2" if -l
"/dev/cdrom2";
1222 my ($storecfg, $vmid, $cdrom) = @_;
1224 if ($cdrom eq 'cdrom') {
1225 return get_cdrom_path
();
1226 } elsif ($cdrom eq 'none') {
1228 } elsif ($cdrom =~ m
|^/|) {
1231 return PVE
::Storage
::path
($storecfg, $cdrom);
1235 # try to convert old style file names to volume IDs
1236 sub filename_to_volume_id
{
1237 my ($vmid, $file, $media) = @_;
1239 if (!($file eq 'none' || $file eq 'cdrom' ||
1240 $file =~ m
|^/dev/.+| || $file =~ m/^([^:]+):(.+)$/)) {
1242 return if $file =~ m
|/|;
1244 if ($media && $media eq 'cdrom') {
1245 $file = "local:iso/$file";
1247 $file = "local:$vmid/$file";
1254 sub verify_media_type
{
1255 my ($opt, $vtype, $media) = @_;
1260 if ($media eq 'disk') {
1262 } elsif ($media eq 'cdrom') {
1265 die "internal error";
1268 return if ($vtype eq $etype);
1270 raise_param_exc
({ $opt => "unexpected media type ($vtype != $etype)" });
1273 sub cleanup_drive_path
{
1274 my ($opt, $storecfg, $drive) = @_;
1276 # try to convert filesystem paths to volume IDs
1278 if (($drive->{file
} !~ m/^(cdrom|none)$/) &&
1279 ($drive->{file
} !~ m
|^/dev/.+|) &&
1280 ($drive->{file
} !~ m/^([^:]+):(.+)$/) &&
1281 ($drive->{file
} !~ m/^\d+$/)) {
1282 my ($vtype, $volid) = PVE
::Storage
::path_to_volume_id
($storecfg, $drive->{file
});
1283 raise_param_exc
({ $opt => "unable to associate path '$drive->{file}' to any storage"})
1285 $drive->{media
} = 'cdrom' if !$drive->{media
} && $vtype eq 'iso';
1286 verify_media_type
($opt, $vtype, $drive->{media
});
1287 $drive->{file
} = $volid;
1290 $drive->{media
} = 'cdrom' if !$drive->{media
} && $drive->{file
} =~ m/^(cdrom|none)$/;
1293 sub parse_hotplug_features
{
1298 return $res if $data eq '0';
1300 $data = $confdesc->{hotplug
}->{default} if $data eq '1';
1302 foreach my $feature (PVE
::Tools
::split_list
($data)) {
1303 if ($feature =~ m/^(network|disk|cpu|memory|usb)$/) {
1306 die "invalid hotplug feature '$feature'\n";
1312 PVE
::JSONSchema
::register_format
('pve-hotplug-features', \
&pve_verify_hotplug_features
);
1313 sub pve_verify_hotplug_features
{
1314 my ($value, $noerr) = @_;
1316 return $value if parse_hotplug_features
($value);
1320 die "unable to parse hotplug option\n";
1324 my($fh, $noerr) = @_;
1327 my $SG_GET_VERSION_NUM = 0x2282;
1329 my $versionbuf = "\x00" x
8;
1330 my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
1332 die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
1335 my $version = unpack("I", $versionbuf);
1336 if ($version < 30000) {
1337 die "scsi generic interface too old\n" if !$noerr;
1341 my $buf = "\x00" x
36;
1342 my $sensebuf = "\x00" x
8;
1343 my $cmd = pack("C x3 C x1", 0x12, 36);
1345 # see /usr/include/scsi/sg.h
1346 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";
1348 my $packet = pack($sg_io_hdr_t, ord('S'), -3, length($cmd),
1349 length($sensebuf), 0, length($buf), $buf,
1350 $cmd, $sensebuf, 6000);
1352 $ret = ioctl($fh, $SG_IO, $packet);
1354 die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
1358 my @res = unpack($sg_io_hdr_t, $packet);
1359 if ($res[17] || $res[18]) {
1360 die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
1365 (my $byte0, my $byte1, $res->{vendor
},
1366 $res->{product
}, $res->{revision
}) = unpack("C C x6 A8 A16 A4", $buf);
1368 $res->{removable
} = $byte1 & 128 ?
1 : 0;
1369 $res->{type
} = $byte0 & 31;
1377 my $fh = IO
::File-
>new("+<$path") || return;
1378 my $res = scsi_inquiry
($fh, 1);
1384 sub print_tabletdevice_full
{
1385 my ($conf, $arch) = @_;
1387 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
1389 # we use uhci for old VMs because tablet driver was buggy in older qemu
1391 if (PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf) || $arch eq 'aarch64') {
1397 return "usb-tablet,id=tablet,bus=$usbbus.0,port=1";
1400 sub print_keyboarddevice_full
{
1401 my ($conf, $arch, $machine) = @_;
1403 return if $arch ne 'aarch64';
1405 return "usb-kbd,id=keyboard,bus=ehci.0,port=2";
1408 my sub get_drive_id
{
1410 return "$drive->{interface}$drive->{index}";
1413 sub print_drivedevice_full
{
1414 my ($storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type) = @_;
1419 my $drive_id = get_drive_id
($drive);
1420 if ($drive->{interface
} eq 'virtio') {
1421 my $pciaddr = print_pci_addr
("$drive_id", $bridges, $arch, $machine_type);
1422 $device = "virtio-blk-pci,drive=drive-$drive_id,id=${drive_id}${pciaddr}";
1423 $device .= ",iothread=iothread-$drive_id" if $drive->{iothread
};
1424 } elsif ($drive->{interface
} eq 'scsi') {
1426 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
1427 my $unit = $drive->{index} % $maxdev;
1428 my $devicetype = 'hd';
1430 if (drive_is_cdrom
($drive)) {
1433 if ($drive->{file
} =~ m
|^/|) {
1434 $path = $drive->{file
};
1435 if (my $info = path_is_scsi
($path)) {
1436 if ($info->{type
} == 0 && $drive->{scsiblock
}) {
1437 $devicetype = 'block';
1438 } elsif ($info->{type
} == 1) { # tape
1439 $devicetype = 'generic';
1443 $path = PVE
::Storage
::path
($storecfg, $drive->{file
});
1446 # for compatibility only, we prefer scsi-hd (#2408, #2355, #2380)
1447 my $version = extract_version
($machine_type, kvm_user_version
());
1448 if ($path =~ m/^iscsi\:\/\
// &&
1449 !min_version
($version, 4, 1)) {
1450 $devicetype = 'generic';
1454 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)){
1455 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,scsi-id=$unit";
1457 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,channel=0,scsi-id=0"
1458 .",lun=$drive->{index}";
1460 $device .= ",drive=drive-$drive_id,id=$drive_id";
1462 if ($drive->{ssd
} && ($devicetype eq 'block' || $devicetype eq 'hd')) {
1463 $device .= ",rotation_rate=1";
1465 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1467 } elsif ($drive->{interface
} eq 'ide' || $drive->{interface
} eq 'sata') {
1468 my $maxdev = ($drive->{interface
} eq 'sata') ?
$PVE::QemuServer
::Drive
::MAX_SATA_DISKS
: 2;
1469 my $controller = int($drive->{index} / $maxdev);
1470 my $unit = $drive->{index} % $maxdev;
1471 my $devicetype = ($drive->{media
} && $drive->{media
} eq 'cdrom') ?
"cd" : "hd";
1473 $device = "ide-$devicetype";
1474 if ($drive->{interface
} eq 'ide') {
1475 $device .= ",bus=ide.$controller,unit=$unit";
1477 $device .= ",bus=ahci$controller.$unit";
1479 $device .= ",drive=drive-$drive_id,id=$drive_id";
1481 if ($devicetype eq 'hd') {
1482 if (my $model = $drive->{model
}) {
1483 $model = URI
::Escape
::uri_unescape
($model);
1484 $device .= ",model=$model";
1486 if ($drive->{ssd
}) {
1487 $device .= ",rotation_rate=1";
1490 $device .= ",wwn=$drive->{wwn}" if $drive->{wwn
};
1491 } elsif ($drive->{interface
} eq 'usb') {
1493 # -device ide-drive,bus=ide.1,unit=0,drive=drive-ide0-1-0,id=ide0-1-0
1495 die "unsupported interface type";
1498 $device .= ",bootindex=$drive->{bootindex}" if $drive->{bootindex
};
1500 if (my $serial = $drive->{serial
}) {
1501 $serial = URI
::Escape
::uri_unescape
($serial);
1502 $device .= ",serial=$serial";
1509 sub get_initiator_name
{
1512 my $fh = IO
::File-
>new('/etc/iscsi/initiatorname.iscsi') || return;
1513 while (defined(my $line = <$fh>)) {
1514 next if $line !~ m/^\s*InitiatorName\s*=\s*([\.\-:\w]+)/;
1523 sub print_drive_commandline_full
{
1524 my ($storecfg, $vmid, $drive, $pbs_name) = @_;
1527 my $volid = $drive->{file
};
1528 my $format = $drive->{format
};
1529 my $drive_id = get_drive_id
($drive);
1531 if (drive_is_cdrom
($drive)) {
1532 $path = get_iso_path
($storecfg, $vmid, $volid);
1533 die "$drive_id: cannot back cdrom drive with PBS snapshot\n" if $pbs_name;
1535 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
1537 $path = PVE
::Storage
::path
($storecfg, $volid);
1538 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
1539 $format //= qemu_img_format
($scfg, $volname);
1546 my $is_rbd = $path =~ m/^rbd:/;
1549 my @qemu_drive_options = qw(heads secs cyls trans media cache rerror werror aio discard);
1550 foreach my $o (@qemu_drive_options) {
1551 $opts .= ",$o=$drive->{$o}" if defined($drive->{$o});
1554 # snapshot only accepts on|off
1555 if (defined($drive->{snapshot
})) {
1556 my $v = $drive->{snapshot
} ?
'on' : 'off';
1557 $opts .= ",snapshot=$v";
1560 foreach my $type (['', '-total'], [_rd
=> '-read'], [_wr
=> '-write']) {
1561 my ($dir, $qmpname) = @$type;
1562 if (my $v = $drive->{"mbps$dir"}) {
1563 $opts .= ",throttling.bps$qmpname=".int($v*1024*1024);
1565 if (my $v = $drive->{"mbps${dir}_max"}) {
1566 $opts .= ",throttling.bps$qmpname-max=".int($v*1024*1024);
1568 if (my $v = $drive->{"bps${dir}_max_length"}) {
1569 $opts .= ",throttling.bps$qmpname-max-length=$v";
1571 if (my $v = $drive->{"iops${dir}"}) {
1572 $opts .= ",throttling.iops$qmpname=$v";
1574 if (my $v = $drive->{"iops${dir}_max"}) {
1575 $opts .= ",throttling.iops$qmpname-max=$v";
1577 if (my $v = $drive->{"iops${dir}_max_length"}) {
1578 $opts .= ",throttling.iops$qmpname-max-length=$v";
1583 $format = "rbd" if $is_rbd;
1584 die "$drive_id: Proxmox Backup Server backed drive cannot auto-detect the format\n"
1586 $opts .= ",format=alloc-track,file.driver=$format";
1588 $opts .= ",format=$format";
1591 my $cache_direct = 0;
1593 if (my $cache = $drive->{cache
}) {
1594 $cache_direct = $cache =~ /^(?:off|none|directsync)$/;
1595 } elsif (!drive_is_cdrom
($drive)) {
1596 $opts .= ",cache=none";
1600 # aio native works only with O_DIRECT
1601 if (!$drive->{aio
}) {
1603 $opts .= ",aio=native";
1605 $opts .= ",aio=threads";
1609 if (!drive_is_cdrom
($drive)) {
1611 if (defined($drive->{detect_zeroes
}) && !$drive->{detect_zeroes
}) {
1612 $detectzeroes = 'off';
1613 } elsif ($drive->{discard
}) {
1614 $detectzeroes = $drive->{discard
} eq 'on' ?
'unmap' : 'on';
1616 # This used to be our default with discard not being specified:
1617 $detectzeroes = 'on';
1620 # note: 'detect-zeroes' works per blockdev and we want it to persist
1621 # after the alloc-track is removed, so put it on 'file' directly
1622 my $dz_param = $pbs_name ?
"file.detect-zeroes" : "detect-zeroes";
1623 $opts .= ",$dz_param=$detectzeroes" if $detectzeroes;
1627 $opts .= ",backing=$pbs_name";
1628 $opts .= ",auto-remove=on";
1631 # my $file_param = $pbs_name ? "file.file.filename" : "file";
1632 my $file_param = "file";
1634 # non-rbd drivers require the underlying file to be a seperate block
1635 # node, so add a second .file indirection
1636 $file_param .= ".file" if !$is_rbd;
1637 $file_param .= ".filename";
1639 my $pathinfo = $path ?
"$file_param=$path," : '';
1641 return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
1644 sub print_pbs_blockdev
{
1645 my ($pbs_conf, $pbs_name) = @_;
1646 my $blockdev = "driver=pbs,node-name=$pbs_name,read-only=on";
1647 $blockdev .= ",repository=$pbs_conf->{repository}";
1648 $blockdev .= ",snapshot=$pbs_conf->{snapshot}";
1649 $blockdev .= ",archive=$pbs_conf->{archive}";
1650 $blockdev .= ",keyfile=$pbs_conf->{keyfile}" if $pbs_conf->{keyfile
};
1654 sub print_netdevice_full
{
1655 my ($vmid, $conf, $net, $netid, $bridges, $use_old_bios_files, $arch, $machine_type) = @_;
1657 my $device = $net->{model
};
1658 if ($net->{model
} eq 'virtio') {
1659 $device = 'virtio-net-pci';
1662 my $pciaddr = print_pci_addr
("$netid", $bridges, $arch, $machine_type);
1663 my $tmpstr = "$device,mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
1664 if ($net->{queues
} && $net->{queues
} > 1 && $net->{model
} eq 'virtio'){
1665 # Consider we have N queues, the number of vectors needed is 2 * N + 2, i.e., one per in
1666 # and out of each queue plus one config interrupt and control vector queue
1667 my $vectors = $net->{queues
} * 2 + 2;
1668 $tmpstr .= ",vectors=$vectors,mq=on";
1670 $tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex
} ;
1672 if (my $mtu = $net->{mtu
}) {
1673 if ($net->{model
} eq 'virtio' && $net->{bridge
}) {
1674 my $bridge_mtu = PVE
::Network
::read_bridge_mtu
($net->{bridge
});
1677 } elsif ($mtu < 576) {
1678 die "netdev $netid: MTU '$mtu' is smaller than the IP minimum MTU '576'\n";
1679 } elsif ($mtu > $bridge_mtu) {
1680 die "netdev $netid: MTU '$mtu' is bigger than the bridge MTU '$bridge_mtu'\n";
1682 $tmpstr .= ",host_mtu=$mtu";
1684 warn "WARN: netdev $netid: ignoring MTU '$mtu', not using VirtIO or no bridge configured.\n";
1688 if ($use_old_bios_files) {
1690 if ($device eq 'virtio-net-pci') {
1691 $romfile = 'pxe-virtio.rom';
1692 } elsif ($device eq 'e1000') {
1693 $romfile = 'pxe-e1000.rom';
1694 } elsif ($device eq 'ne2k') {
1695 $romfile = 'pxe-ne2k_pci.rom';
1696 } elsif ($device eq 'pcnet') {
1697 $romfile = 'pxe-pcnet.rom';
1698 } elsif ($device eq 'rtl8139') {
1699 $romfile = 'pxe-rtl8139.rom';
1701 $tmpstr .= ",romfile=$romfile" if $romfile;
1707 sub print_netdev_full
{
1708 my ($vmid, $conf, $arch, $net, $netid, $hotplug) = @_;
1711 if ($netid =~ m/^net(\d+)$/) {
1715 die "got strange net id '$i'\n" if $i >= ${MAX_NETS
};
1717 my $ifname = "tap${vmid}i$i";
1719 # kvm uses TUNSETIFF ioctl, and that limits ifname length
1720 die "interface name '$ifname' is too long (max 15 character)\n"
1721 if length($ifname) >= 16;
1723 my $vhostparam = '';
1724 if (is_native
($arch)) {
1725 $vhostparam = ',vhost=on' if kernel_has_vhost_net
() && $net->{model
} eq 'virtio';
1728 my $vmname = $conf->{name
} || "vm$vmid";
1731 my $script = $hotplug ?
"pve-bridge-hotplug" : "pve-bridge";
1733 if ($net->{bridge
}) {
1734 $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/$script"
1735 .",downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
1737 $netdev = "type=user,id=$netid,hostname=$vmname";
1740 $netdev .= ",queues=$net->{queues}" if ($net->{queues
} && $net->{model
} eq 'virtio');
1746 'cirrus' => 'cirrus-vga',
1748 'vmware' => 'vmware-svga',
1749 'virtio' => 'virtio-vga',
1752 sub print_vga_device
{
1753 my ($conf, $vga, $arch, $machine_version, $machine, $id, $qxlnum, $bridges) = @_;
1755 my $type = $vga_map->{$vga->{type
}};
1756 if ($arch eq 'aarch64' && defined($type) && $type eq 'virtio-vga') {
1757 $type = 'virtio-gpu';
1759 my $vgamem_mb = $vga->{memory
};
1761 my $max_outputs = '';
1763 $type = $id ?
'qxl' : 'qxl-vga';
1765 if (!$conf->{ostype
} || $conf->{ostype
} =~ m/^(?:l\d\d)|(?:other)$/) {
1766 # set max outputs so linux can have up to 4 qxl displays with one device
1767 if (min_version
($machine_version, 4, 1)) {
1768 $max_outputs = ",max_outputs=4";
1773 die "no devicetype for $vga->{type}\n" if !$type;
1777 if ($vga->{type
} eq 'virtio') {
1778 my $bytes = PVE
::Tools
::convert_size
($vgamem_mb, "mb" => "b");
1779 $memory = ",max_hostmem=$bytes";
1781 # from https://www.spice-space.org/multiple-monitors.html
1782 $memory = ",vgamem_mb=$vga->{memory}";
1783 my $ram = $vgamem_mb * 4;
1784 my $vram = $vgamem_mb * 2;
1785 $memory .= ",ram_size_mb=$ram,vram_size_mb=$vram";
1787 $memory = ",vgamem_mb=$vga->{memory}";
1789 } elsif ($qxlnum && $id) {
1790 $memory = ",ram_size=67108864,vram_size=33554432";
1794 if ($type eq 'VGA' && windows_version
($conf->{ostype
})) {
1795 $edidoff=",edid=off" if (!defined($conf->{bios
}) || $conf->{bios
} ne 'ovmf');
1798 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
1799 my $vgaid = "vga" . ($id // '');
1802 if ($q35 && $vgaid eq 'vga') {
1803 # the first display uses pcie.0 bus on q35 machines
1804 $pciaddr = print_pcie_addr
($vgaid, $bridges, $arch, $machine);
1806 $pciaddr = print_pci_addr
($vgaid, $bridges, $arch, $machine);
1809 return "$type,id=${vgaid}${memory}${max_outputs}${pciaddr}${edidoff}";
1812 sub parse_number_sets
{
1815 foreach my $part (split(/;/, $set)) {
1816 if ($part =~ /^\s*(\d+)(?:-(\d+))?\s*$/) {
1817 die "invalid range: $part ($2 < $1)\n" if defined($2) && $2 < $1;
1818 push @$res, [ $1, $2 ];
1820 die "invalid range: $part\n";
1829 my $res = parse_property_string
($numa_fmt, $data);
1830 $res->{cpus
} = parse_number_sets
($res->{cpus
}) if defined($res->{cpus
});
1831 $res->{hostnodes
} = parse_number_sets
($res->{hostnodes
}) if defined($res->{hostnodes
});
1835 # netX: e1000=XX:XX:XX:XX:XX:XX,bridge=vmbr0,rate=<mbps>
1839 my $res = eval { parse_property_string
($net_fmt, $data) };
1844 if (!defined($res->{macaddr
})) {
1845 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
1846 $res->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
});
1851 # ipconfigX ip=cidr,gw=ip,ip6=cidr,gw6=ip
1852 sub parse_ipconfig
{
1855 my $res = eval { parse_property_string
($ipconfig_fmt, $data) };
1861 if ($res->{gw
} && !$res->{ip
}) {
1862 warn 'gateway specified without specifying an IP address';
1865 if ($res->{gw6
} && !$res->{ip6
}) {
1866 warn 'IPv6 gateway specified without specifying an IPv6 address';
1869 if ($res->{gw
} && $res->{ip
} eq 'dhcp') {
1870 warn 'gateway specified together with DHCP';
1873 if ($res->{gw6
} && $res->{ip6
} !~ /^$IPV6RE/) {
1875 warn "IPv6 gateway specified together with $res->{ip6} address";
1879 if (!$res->{ip
} && !$res->{ip6
}) {
1880 return { ip
=> 'dhcp', ip6
=> 'dhcp' };
1889 return PVE
::JSONSchema
::print_property_string
($net, $net_fmt);
1892 sub add_random_macs
{
1893 my ($settings) = @_;
1895 foreach my $opt (keys %$settings) {
1896 next if $opt !~ m/^net(\d+)$/;
1897 my $net = parse_net
($settings->{$opt});
1899 $settings->{$opt} = print_net
($net);
1903 sub vm_is_volid_owner
{
1904 my ($storecfg, $vmid, $volid) = @_;
1906 if ($volid !~ m
|^/|) {
1908 eval { ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid); };
1909 if ($owner && ($owner == $vmid)) {
1917 sub vmconfig_register_unused_drive
{
1918 my ($storecfg, $vmid, $conf, $drive) = @_;
1920 if (drive_is_cloudinit
($drive)) {
1921 eval { PVE
::Storage
::vdisk_free
($storecfg, $drive->{file
}) };
1923 } elsif (!drive_is_cdrom
($drive)) {
1924 my $volid = $drive->{file
};
1925 if (vm_is_volid_owner
($storecfg, $vmid, $volid)) {
1926 PVE
::QemuConfig-
>add_unused_volume($conf, $volid, $vmid);
1931 # smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str][,base64=bool]
1935 pattern
=> '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
1936 format_description
=> 'UUID',
1937 description
=> "Set SMBIOS1 UUID.",
1942 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1943 format_description
=> 'Base64 encoded string',
1944 description
=> "Set SMBIOS1 version.",
1949 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1950 format_description
=> 'Base64 encoded string',
1951 description
=> "Set SMBIOS1 serial number.",
1956 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1957 format_description
=> 'Base64 encoded string',
1958 description
=> "Set SMBIOS1 manufacturer.",
1963 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1964 format_description
=> 'Base64 encoded string',
1965 description
=> "Set SMBIOS1 product ID.",
1970 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1971 format_description
=> 'Base64 encoded string',
1972 description
=> "Set SMBIOS1 SKU string.",
1977 pattern
=> '[A-Za-z0-9+\/]+={0,2}',
1978 format_description
=> 'Base64 encoded string',
1979 description
=> "Set SMBIOS1 family string.",
1984 description
=> 'Flag to indicate that the SMBIOS values are base64 encoded',
1992 my $res = eval { parse_property_string
($smbios1_fmt, $data) };
1999 return PVE
::JSONSchema
::print_property_string
($smbios1, $smbios1_fmt);
2002 PVE
::JSONSchema
::register_format
('pve-qm-smbios1', $smbios1_fmt);
2004 sub parse_watchdog
{
2009 my $res = eval { parse_property_string
($watchdog_fmt, $value) };
2014 sub parse_guest_agent
{
2017 return {} if !defined($conf->{agent
});
2019 my $res = eval { parse_property_string
($agent_fmt, $conf->{agent
}) };
2022 # if the agent is disabled ignore the other potentially set properties
2023 return {} if !$res->{enabled
};
2028 my ($conf, $key) = @_;
2029 return undef if !defined($conf->{agent
});
2031 my $agent = parse_guest_agent
($conf);
2032 return $agent->{$key};
2038 return {} if !$value;
2039 my $res = eval { parse_property_string
($vga_fmt, $value) };
2049 my $res = eval { parse_property_string
($rng_fmt, $value) };
2054 PVE
::JSONSchema
::register_format
('pve-qm-usb-device', \
&verify_usb_device
);
2055 sub verify_usb_device
{
2056 my ($value, $noerr) = @_;
2058 return $value if parse_usb_device
($value);
2062 die "unable to parse usb device\n";
2065 # add JSON properties for create and set function
2066 sub json_config_properties
{
2069 foreach my $opt (keys %$confdesc) {
2070 next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate' ||
2071 $opt eq 'runningmachine' || $opt eq 'runningcpu';
2072 $prop->{$opt} = $confdesc->{$opt};
2078 # return copy of $confdesc_cloudinit to generate documentation
2079 sub cloudinit_config_properties
{
2081 return dclone
($confdesc_cloudinit);
2085 my ($key, $value) = @_;
2087 die "unknown setting '$key'\n" if !$confdesc->{$key};
2089 my $type = $confdesc->{$key}->{type
};
2091 if (!defined($value)) {
2092 die "got undefined value\n";
2095 if ($value =~ m/[\n\r]/) {
2096 die "property contains a line feed\n";
2099 if ($type eq 'boolean') {
2100 return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
2101 return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
2102 die "type check ('boolean') failed - got '$value'\n";
2103 } elsif ($type eq 'integer') {
2104 return int($1) if $value =~ m/^(\d+)$/;
2105 die "type check ('integer') failed - got '$value'\n";
2106 } elsif ($type eq 'number') {
2107 return $value if $value =~ m/^(\d+)(\.\d+)?$/;
2108 die "type check ('number') failed - got '$value'\n";
2109 } elsif ($type eq 'string') {
2110 if (my $fmt = $confdesc->{$key}->{format
}) {
2111 PVE
::JSONSchema
::check_format
($fmt, $value);
2114 $value =~ s/^\"(.*)\"$/$1/;
2117 die "internal error"
2122 my ($storecfg, $vmid, $skiplock, $replacement_conf, $purge_unreferenced) = @_;
2124 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2126 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
2128 if ($conf->{template
}) {
2129 # check if any base image is still used by a linked clone
2130 PVE
::QemuConfig-
>foreach_volume($conf, sub {
2131 my ($ds, $drive) = @_;
2132 return if drive_is_cdrom
($drive);
2134 my $volid = $drive->{file
};
2135 return if !$volid || $volid =~ m
|^/|;
2137 die "base volume '$volid' is still in use by linked cloned\n"
2138 if PVE
::Storage
::volume_is_base_and_used
($storecfg, $volid);
2143 # only remove disks owned by this VM (referenced in the config)
2144 PVE
::QemuConfig-
>foreach_volume_full($conf, { include_unused
=> 1 }, sub {
2145 my ($ds, $drive) = @_;
2146 return if drive_is_cdrom
($drive, 1);
2148 my $volid = $drive->{file
};
2149 return if !$volid || $volid =~ m
|^/|;
2151 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
2152 return if !$path || !$owner || ($owner != $vmid);
2154 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid) };
2155 warn "Could not remove disk '$volid', check manually: $@" if $@;
2158 if ($purge_unreferenced) { # also remove unreferenced disk
2159 my $vmdisks = PVE
::Storage
::vdisk_list
($storecfg, undef, $vmid, undef, 'images');
2160 PVE
::Storage
::foreach_volid
($vmdisks, sub {
2161 my ($volid, $sid, $volname, $d) = @_;
2162 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid) };
2167 if (defined $replacement_conf) {
2168 PVE
::QemuConfig-
>write_config($vmid, $replacement_conf);
2170 PVE
::QemuConfig-
>destroy_config($vmid);
2174 sub parse_vm_config
{
2175 my ($filename, $raw) = @_;
2177 return if !defined($raw);
2180 digest
=> Digest
::SHA
::sha1_hex
($raw),
2185 $filename =~ m
|/qemu-server/(\d
+)\
.conf
$|
2186 || die "got strange filename '$filename'";
2194 my @lines = split(/\n/, $raw);
2195 foreach my $line (@lines) {
2196 next if $line =~ m/^\s*$/;
2198 if ($line =~ m/^\[PENDING\]\s*$/i) {
2199 $section = 'pending';
2200 if (defined($descr)) {
2202 $conf->{description
} = $descr;
2205 $conf = $res->{$section} = {};
2208 } elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
2210 if (defined($descr)) {
2212 $conf->{description
} = $descr;
2215 $conf = $res->{snapshots
}->{$section} = {};
2219 if ($line =~ m/^\#(.*)\s*$/) {
2220 $descr = '' if !defined($descr);
2221 $descr .= PVE
::Tools
::decode_text
($1) . "\n";
2225 if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
2226 $descr = '' if !defined($descr);
2227 $descr .= PVE
::Tools
::decode_text
($2);
2228 } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
2229 $conf->{snapstate
} = $1;
2230 } elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
2233 $conf->{$key} = $value;
2234 } elsif ($line =~ m/^delete:\s*(.*\S)\s*$/) {
2236 if ($section eq 'pending') {
2237 $conf->{delete} = $value; # we parse this later
2239 warn "vm $vmid - propertry 'delete' is only allowed in [PENDING]\n";
2241 } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(.+?)\s*$/) {
2244 eval { $value = check_type
($key, $value); };
2246 warn "vm $vmid - unable to parse value of '$key' - $@";
2248 $key = 'ide2' if $key eq 'cdrom';
2249 my $fmt = $confdesc->{$key}->{format
};
2250 if ($fmt && $fmt =~ /^pve-qm-(?:ide|scsi|virtio|sata)$/) {
2251 my $v = parse_drive
($key, $value);
2252 if (my $volid = filename_to_volume_id
($vmid, $v->{file
}, $v->{media
})) {
2253 $v->{file
} = $volid;
2254 $value = print_drive
($v);
2256 warn "vm $vmid - unable to parse value of '$key'\n";
2261 $conf->{$key} = $value;
2264 warn "vm $vmid - unable to parse config: $line\n";
2268 if (defined($descr)) {
2270 $conf->{description
} = $descr;
2272 delete $res->{snapstate
}; # just to be sure
2277 sub write_vm_config
{
2278 my ($filename, $conf) = @_;
2280 delete $conf->{snapstate
}; # just to be sure
2282 if ($conf->{cdrom
}) {
2283 die "option ide2 conflicts with cdrom\n" if $conf->{ide2
};
2284 $conf->{ide2
} = $conf->{cdrom
};
2285 delete $conf->{cdrom
};
2288 # we do not use 'smp' any longer
2289 if ($conf->{sockets
}) {
2290 delete $conf->{smp
};
2291 } elsif ($conf->{smp
}) {
2292 $conf->{sockets
} = $conf->{smp
};
2293 delete $conf->{cores
};
2294 delete $conf->{smp
};
2297 my $used_volids = {};
2299 my $cleanup_config = sub {
2300 my ($cref, $pending, $snapname) = @_;
2302 foreach my $key (keys %$cref) {
2303 next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots' ||
2304 $key eq 'snapstate' || $key eq 'pending';
2305 my $value = $cref->{$key};
2306 if ($key eq 'delete') {
2307 die "propertry 'delete' is only allowed in [PENDING]\n"
2309 # fixme: check syntax?
2312 eval { $value = check_type
($key, $value); };
2313 die "unable to parse value of '$key' - $@" if $@;
2315 $cref->{$key} = $value;
2317 if (!$snapname && is_valid_drivename
($key)) {
2318 my $drive = parse_drive
($key, $value);
2319 $used_volids->{$drive->{file
}} = 1 if $drive && $drive->{file
};
2324 &$cleanup_config($conf);
2326 &$cleanup_config($conf->{pending
}, 1);
2328 foreach my $snapname (keys %{$conf->{snapshots
}}) {
2329 die "internal error: snapshot name '$snapname' is forbidden" if lc($snapname) eq 'pending';
2330 &$cleanup_config($conf->{snapshots
}->{$snapname}, undef, $snapname);
2333 # remove 'unusedX' settings if we re-add a volume
2334 foreach my $key (keys %$conf) {
2335 my $value = $conf->{$key};
2336 if ($key =~ m/^unused/ && $used_volids->{$value}) {
2337 delete $conf->{$key};
2341 my $generate_raw_config = sub {
2342 my ($conf, $pending) = @_;
2346 # add description as comment to top of file
2347 if (defined(my $descr = $conf->{description
})) {
2349 foreach my $cl (split(/\n/, $descr)) {
2350 $raw .= '#' . PVE
::Tools
::encode_text
($cl) . "\n";
2353 $raw .= "#\n" if $pending;
2357 foreach my $key (sort keys %$conf) {
2358 next if $key =~ /^(digest|description|pending|snapshots)$/;
2359 $raw .= "$key: $conf->{$key}\n";
2364 my $raw = &$generate_raw_config($conf);
2366 if (scalar(keys %{$conf->{pending
}})){
2367 $raw .= "\n[PENDING]\n";
2368 $raw .= &$generate_raw_config($conf->{pending
}, 1);
2371 foreach my $snapname (sort keys %{$conf->{snapshots
}}) {
2372 $raw .= "\n[$snapname]\n";
2373 $raw .= &$generate_raw_config($conf->{snapshots
}->{$snapname});
2383 # we use static defaults from our JSON schema configuration
2384 foreach my $key (keys %$confdesc) {
2385 if (defined(my $default = $confdesc->{$key}->{default})) {
2386 $res->{$key} = $default;
2394 my $vmlist = PVE
::Cluster
::get_vmlist
();
2396 return $res if !$vmlist || !$vmlist->{ids
};
2397 my $ids = $vmlist->{ids
};
2398 my $nodename = nodename
();
2400 foreach my $vmid (keys %$ids) {
2401 my $d = $ids->{$vmid};
2402 next if !$d->{node
} || $d->{node
} ne $nodename;
2403 next if !$d->{type
} || $d->{type
} ne 'qemu';
2404 $res->{$vmid}->{exists} = 1;
2409 # test if VM uses local resources (to prevent migration)
2410 sub check_local_resources
{
2411 my ($conf, $noerr) = @_;
2415 push @loc_res, "hostusb" if $conf->{hostusb
}; # old syntax
2416 push @loc_res, "hostpci" if $conf->{hostpci
}; # old syntax
2418 push @loc_res, "ivshmem" if $conf->{ivshmem
};
2420 foreach my $k (keys %$conf) {
2421 next if $k =~ m/^usb/ && ($conf->{$k} =~ m/^spice(?![^,])/);
2422 # sockets are safe: they will recreated be on the target side post-migrate
2423 next if $k =~ m/^serial/ && ($conf->{$k} eq 'socket');
2424 push @loc_res, $k if $k =~ m/^(usb|hostpci|serial|parallel)\d+$/;
2427 die "VM uses local resources\n" if scalar @loc_res && !$noerr;
2432 # check if used storages are available on all nodes (use by migrate)
2433 sub check_storage_availability
{
2434 my ($storecfg, $conf, $node) = @_;
2436 PVE
::QemuConfig-
>foreach_volume($conf, sub {
2437 my ($ds, $drive) = @_;
2439 my $volid = $drive->{file
};
2442 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2445 # check if storage is available on both nodes
2446 my $scfg = PVE
::Storage
::storage_check_node
($storecfg, $sid);
2447 PVE
::Storage
::storage_check_node
($storecfg, $sid, $node);
2451 # list nodes where all VM images are available (used by has_feature API)
2453 my ($conf, $storecfg) = @_;
2455 my $nodelist = PVE
::Cluster
::get_nodelist
();
2456 my $nodehash = { map { $_ => 1 } @$nodelist };
2457 my $nodename = nodename
();
2459 PVE
::QemuConfig-
>foreach_volume($conf, sub {
2460 my ($ds, $drive) = @_;
2462 my $volid = $drive->{file
};
2465 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2467 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2468 if ($scfg->{disable
}) {
2470 } elsif (my $avail = $scfg->{nodes
}) {
2471 foreach my $node (keys %$nodehash) {
2472 delete $nodehash->{$node} if !$avail->{$node};
2474 } elsif (!$scfg->{shared
}) {
2475 foreach my $node (keys %$nodehash) {
2476 delete $nodehash->{$node} if $node ne $nodename
2485 sub check_local_storage_availability
{
2486 my ($conf, $storecfg) = @_;
2488 my $nodelist = PVE
::Cluster
::get_nodelist
();
2489 my $nodehash = { map { $_ => {} } @$nodelist };
2491 PVE
::QemuConfig-
>foreach_volume($conf, sub {
2492 my ($ds, $drive) = @_;
2494 my $volid = $drive->{file
};
2497 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2499 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2501 if ($scfg->{disable
}) {
2502 foreach my $node (keys %$nodehash) {
2503 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
2505 } elsif (my $avail = $scfg->{nodes
}) {
2506 foreach my $node (keys %$nodehash) {
2507 if (!$avail->{$node}) {
2508 $nodehash->{$node}->{unavailable_storages
}->{$storeid} = 1;
2515 foreach my $node (values %$nodehash) {
2516 if (my $unavail = $node->{unavailable_storages
}) {
2517 $node->{unavailable_storages
} = [ sort keys %$unavail ];
2524 # Compat only, use assert_config_exists_on_node and vm_running_locally where possible
2526 my ($vmid, $nocheck, $node) = @_;
2528 PVE
::QemuConfig
::assert_config_exists_on_node
($vmid, $node) if !$nocheck;
2529 return PVE
::QemuServer
::Helpers
::vm_running_locally
($vmid);
2534 my $vzlist = config_list
();
2536 my $fd = IO
::Dir-
>new($PVE::QemuServer
::Helpers
::var_run_tmpdir
) || return $vzlist;
2538 while (defined(my $de = $fd->read)) {
2539 next if $de !~ m/^(\d+)\.pid$/;
2541 next if !defined($vzlist->{$vmid});
2542 if (my $pid = check_running
($vmid)) {
2543 $vzlist->{$vmid}->{pid
} = $pid;
2550 our $vmstatus_return_properties = {
2551 vmid
=> get_standard_option
('pve-vmid'),
2553 description
=> "Qemu process status.",
2555 enum
=> ['stopped', 'running'],
2558 description
=> "Maximum memory in bytes.",
2561 renderer
=> 'bytes',
2564 description
=> "Root disk size in bytes.",
2567 renderer
=> 'bytes',
2570 description
=> "VM name.",
2575 description
=> "Qemu QMP agent status.",
2580 description
=> "PID of running qemu process.",
2585 description
=> "Uptime.",
2588 renderer
=> 'duration',
2591 description
=> "Maximum usable CPUs.",
2596 description
=> "The current config lock, if any.",
2601 description
=> "The current configured tags, if any",
2605 'running-machine' => {
2606 description
=> "The currently running machine type (if running).",
2611 description
=> "The currently running QEMU version (if running).",
2617 my $last_proc_pid_stat;
2619 # get VM status information
2620 # This must be fast and should not block ($full == false)
2621 # We only query KVM using QMP if $full == true (this can be slow)
2623 my ($opt_vmid, $full) = @_;
2627 my $storecfg = PVE
::Storage
::config
();
2629 my $list = vzlist
();
2630 my $defaults = load_defaults
();
2632 my ($uptime) = PVE
::ProcFSTools
::read_proc_uptime
(1);
2634 my $cpucount = $cpuinfo->{cpus
} || 1;
2636 foreach my $vmid (keys %$list) {
2637 next if $opt_vmid && ($vmid ne $opt_vmid);
2639 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2641 my $d = { vmid
=> $vmid };
2642 $d->{pid
} = $list->{$vmid}->{pid
};
2644 # fixme: better status?
2645 $d->{status
} = $list->{$vmid}->{pid
} ?
'running' : 'stopped';
2647 my $size = PVE
::QemuServer
::Drive
::bootdisk_size
($storecfg, $conf);
2648 if (defined($size)) {
2649 $d->{disk
} = 0; # no info available
2650 $d->{maxdisk
} = $size;
2656 $d->{cpus
} = ($conf->{sockets
} || $defaults->{sockets
})
2657 * ($conf->{cores
} || $defaults->{cores
});
2658 $d->{cpus
} = $cpucount if $d->{cpus
} > $cpucount;
2659 $d->{cpus
} = $conf->{vcpus
} if $conf->{vcpus
};
2661 $d->{name
} = $conf->{name
} || "VM $vmid";
2662 $d->{maxmem
} = $conf->{memory
} ?
$conf->{memory
}*(1024*1024)
2663 : $defaults->{memory
}*(1024*1024);
2665 if ($conf->{balloon
}) {
2666 $d->{balloon_min
} = $conf->{balloon
}*(1024*1024);
2667 $d->{shares
} = defined($conf->{shares
}) ?
$conf->{shares
}
2668 : $defaults->{shares
};
2679 $d->{diskwrite
} = 0;
2681 $d->{template
} = PVE
::QemuConfig-
>is_template($conf);
2683 $d->{serial
} = 1 if conf_has_serial
($conf);
2684 $d->{lock} = $conf->{lock} if $conf->{lock};
2685 $d->{tags
} = $conf->{tags
} if defined($conf->{tags
});
2690 my $netdev = PVE
::ProcFSTools
::read_proc_net_dev
();
2691 foreach my $dev (keys %$netdev) {
2692 next if $dev !~ m/^tap([1-9]\d*)i/;
2694 my $d = $res->{$vmid};
2697 $d->{netout
} += $netdev->{$dev}->{receive
};
2698 $d->{netin
} += $netdev->{$dev}->{transmit
};
2701 $d->{nics
}->{$dev}->{netout
} = $netdev->{$dev}->{receive
};
2702 $d->{nics
}->{$dev}->{netin
} = $netdev->{$dev}->{transmit
};
2707 my $ctime = gettimeofday
;
2709 foreach my $vmid (keys %$list) {
2711 my $d = $res->{$vmid};
2712 my $pid = $d->{pid
};
2715 my $pstat = PVE
::ProcFSTools
::read_proc_pid_stat
($pid);
2716 next if !$pstat; # not running
2718 my $used = $pstat->{utime} + $pstat->{stime
};
2720 $d->{uptime
} = int(($uptime - $pstat->{starttime
})/$cpuinfo->{user_hz
});
2722 if ($pstat->{vsize
}) {
2723 $d->{mem
} = int(($pstat->{rss
}/$pstat->{vsize
})*$d->{maxmem
});
2726 my $old = $last_proc_pid_stat->{$pid};
2728 $last_proc_pid_stat->{$pid} = {
2736 my $dtime = ($ctime - $old->{time}) * $cpucount * $cpuinfo->{user_hz
};
2738 if ($dtime > 1000) {
2739 my $dutime = $used - $old->{used
};
2741 $d->{cpu
} = (($dutime/$dtime)* $cpucount) / $d->{cpus
};
2742 $last_proc_pid_stat->{$pid} = {
2748 $d->{cpu
} = $old->{cpu
};
2752 return $res if !$full;
2754 my $qmpclient = PVE
::QMPClient-
>new();
2756 my $ballooncb = sub {
2757 my ($vmid, $resp) = @_;
2759 my $info = $resp->{'return'};
2760 return if !$info->{max_mem
};
2762 my $d = $res->{$vmid};
2764 # use memory assigned to VM
2765 $d->{maxmem
} = $info->{max_mem
};
2766 $d->{balloon
} = $info->{actual
};
2768 if (defined($info->{total_mem
}) && defined($info->{free_mem
})) {
2769 $d->{mem
} = $info->{total_mem
} - $info->{free_mem
};
2770 $d->{freemem
} = $info->{free_mem
};
2773 $d->{ballooninfo
} = $info;
2776 my $blockstatscb = sub {
2777 my ($vmid, $resp) = @_;
2778 my $data = $resp->{'return'} || [];
2779 my $totalrdbytes = 0;
2780 my $totalwrbytes = 0;
2782 for my $blockstat (@$data) {
2783 $totalrdbytes = $totalrdbytes + $blockstat->{stats
}->{rd_bytes
};
2784 $totalwrbytes = $totalwrbytes + $blockstat->{stats
}->{wr_bytes
};
2786 $blockstat->{device
} =~ s/drive-//;
2787 $res->{$vmid}->{blockstat
}->{$blockstat->{device
}} = $blockstat->{stats
};
2789 $res->{$vmid}->{diskread
} = $totalrdbytes;
2790 $res->{$vmid}->{diskwrite
} = $totalwrbytes;
2793 my $machinecb = sub {
2794 my ($vmid, $resp) = @_;
2795 my $data = $resp->{'return'} || [];
2797 $res->{$vmid}->{'running-machine'} =
2798 PVE
::QemuServer
::Machine
::current_from_query_machines
($data);
2801 my $versioncb = sub {
2802 my ($vmid, $resp) = @_;
2803 my $data = $resp->{'return'} // {};
2804 my $version = 'unknown';
2806 if (my $v = $data->{qemu
}) {
2807 $version = $v->{major
} . "." . $v->{minor
} . "." . $v->{micro
};
2810 $res->{$vmid}->{'running-qemu'} = $version;
2813 my $statuscb = sub {
2814 my ($vmid, $resp) = @_;
2816 $qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
2817 $qmpclient->queue_cmd($vmid, $machinecb, 'query-machines');
2818 $qmpclient->queue_cmd($vmid, $versioncb, 'query-version');
2819 # this fails if ballon driver is not loaded, so this must be
2820 # the last commnand (following command are aborted if this fails).
2821 $qmpclient->queue_cmd($vmid, $ballooncb, 'query-balloon');
2823 my $status = 'unknown';
2824 if (!defined($status = $resp->{'return'}->{status
})) {
2825 warn "unable to get VM status\n";
2829 $res->{$vmid}->{qmpstatus
} = $resp->{'return'}->{status
};
2832 foreach my $vmid (keys %$list) {
2833 next if $opt_vmid && ($vmid ne $opt_vmid);
2834 next if !$res->{$vmid}->{pid
}; # not running
2835 $qmpclient->queue_cmd($vmid, $statuscb, 'query-status');
2838 $qmpclient->queue_execute(undef, 2);
2840 foreach my $vmid (keys %$list) {
2841 next if $opt_vmid && ($vmid ne $opt_vmid);
2842 next if !$res->{$vmid}->{pid
}; #not running
2844 # we can't use the $qmpclient since it might have already aborted on
2845 # 'query-balloon', but this might also fail for older versions...
2846 my $qemu_support = eval { mon_cmd
($vmid, "query-proxmox-support") };
2847 $res->{$vmid}->{'proxmox-support'} = $qemu_support // {};
2850 foreach my $vmid (keys %$list) {
2851 next if $opt_vmid && ($vmid ne $opt_vmid);
2852 $res->{$vmid}->{qmpstatus
} = $res->{$vmid}->{status
} if !$res->{$vmid}->{qmpstatus
};
2858 sub conf_has_serial
{
2861 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
2862 if ($conf->{"serial$i"}) {
2870 sub conf_has_audio
{
2871 my ($conf, $id) = @_;
2874 my $audio = $conf->{"audio$id"};
2875 return if !defined($audio);
2877 my $audioproperties = parse_property_string
($audio_fmt, $audio);
2878 my $audiodriver = $audioproperties->{driver
} // 'spice';
2881 dev
=> $audioproperties->{device
},
2882 dev_id
=> "audiodev$id",
2883 backend
=> $audiodriver,
2884 backend_id
=> "$audiodriver-backend${id}",
2889 my ($audio, $audiopciaddr, $machine_version) = @_;
2893 my $id = $audio->{dev_id
};
2895 if (min_version
($machine_version, 4, 2)) {
2896 $audiodev = ",audiodev=$audio->{backend_id}";
2899 if ($audio->{dev
} eq 'AC97') {
2900 push @$devs, '-device', "AC97,id=${id}${audiopciaddr}$audiodev";
2901 } elsif ($audio->{dev
} =~ /intel\-hda$/) {
2902 push @$devs, '-device', "$audio->{dev},id=${id}${audiopciaddr}";
2903 push @$devs, '-device', "hda-micro,id=${id}-codec0,bus=${id}.0,cad=0$audiodev";
2904 push @$devs, '-device', "hda-duplex,id=${id}-codec1,bus=${id}.0,cad=1$audiodev";
2906 die "unkown audio device '$audio->{dev}', implement me!";
2909 push @$devs, '-audiodev', "$audio->{backend},id=$audio->{backend_id}";
2914 sub vga_conf_has_spice
{
2917 my $vgaconf = parse_vga
($vga);
2918 my $vgatype = $vgaconf->{type
};
2919 return 0 if !$vgatype || $vgatype !~ m/^qxl([234])?$/;
2926 return get_host_arch
() eq $arch;
2931 return $conf->{arch
} // get_host_arch
();
2934 my $default_machines = {
2939 sub get_installed_machine_version
{
2940 my ($kvmversion) = @_;
2941 $kvmversion = kvm_user_version
() if !defined($kvmversion);
2942 $kvmversion =~ m/^(\d+\.\d+)/;
2946 sub windows_get_pinned_machine_version
{
2947 my ($machine, $base_version, $kvmversion) = @_;
2949 my $pin_version = $base_version;
2950 if (!defined($base_version) ||
2951 !PVE
::QemuServer
::Machine
::can_run_pve_machine_version
($base_version, $kvmversion)
2953 $pin_version = get_installed_machine_version
($kvmversion);
2955 if (!$machine || $machine eq 'pc') {
2956 $machine = "pc-i440fx-$pin_version";
2957 } elsif ($machine eq 'q35') {
2958 $machine = "pc-q35-$pin_version";
2959 } elsif ($machine eq 'virt') {
2960 $machine = "virt-$pin_version";
2962 warn "unknown machine type '$machine', not touching that!\n";
2968 sub get_vm_machine
{
2969 my ($conf, $forcemachine, $arch, $add_pve_version, $kvmversion) = @_;
2971 my $machine = $forcemachine || $conf->{machine
};
2973 if (!$machine || $machine =~ m/^(?:pc|q35|virt)$/) {
2974 $kvmversion //= kvm_user_version
();
2975 # we must pin Windows VMs without a specific version to 5.1, as 5.2 fixed a bug in ACPI
2976 # layout which confuses windows quite a bit and may result in various regressions..
2977 # see: https://lists.gnu.org/archive/html/qemu-devel/2021-02/msg08484.html
2978 if (windows_version
($conf->{ostype
})) {
2979 $machine = windows_get_pinned_machine_version
($machine, '5.1', $kvmversion);
2982 $machine ||= $default_machines->{$arch};
2983 if ($add_pve_version) {
2984 my $pvever = PVE
::QemuServer
::Machine
::get_pve_version
($kvmversion);
2985 $machine .= "+pve$pvever";
2989 if ($add_pve_version && $machine !~ m/\+pve\d+?(?:\.pxe)?$/) {
2990 my $is_pxe = $machine =~ m/^(.*?)\.pxe$/;
2991 $machine = $1 if $is_pxe;
2993 # for version-pinned machines that do not include a pve-version (e.g.
2994 # pc-q35-4.1), we assume 0 to keep them stable in case we bump
2995 $machine .= '+pve0';
2997 $machine .= '.pxe' if $is_pxe;
3003 sub get_ovmf_files
($) {
3006 my $ovmf = $OVMF->{$arch}
3007 or die "no OVMF images known for architecture '$arch'\n";
3013 aarch64
=> '/usr/bin/qemu-system-aarch64',
3014 x86_64
=> '/usr/bin/qemu-system-x86_64',
3016 sub get_command_for_arch
($) {
3018 return '/usr/bin/kvm' if is_native
($arch);
3020 my $cmd = $Arch2Qemu->{$arch}
3021 or die "don't know how to emulate architecture '$arch'\n";
3025 # To use query_supported_cpu_flags and query_understood_cpu_flags to get flags
3026 # to use in a QEMU command line (-cpu element), first array_intersect the result
3027 # of query_supported_ with query_understood_. This is necessary because:
3029 # a) query_understood_ returns flags the host cannot use and
3030 # b) query_supported_ (rather the QMP call) doesn't actually return CPU
3031 # flags, but CPU settings - with most of them being flags. Those settings
3032 # (and some flags, curiously) cannot be specified as a "-cpu" argument.
3034 # query_supported_ needs to start up to 2 temporary VMs and is therefore rather
3035 # expensive. If you need the value returned from this, you can get it much
3036 # cheaper from pmxcfs using PVE::Cluster::get_node_kv('cpuflags-$accel') with
3037 # $accel being 'kvm' or 'tcg'.
3039 # pvestatd calls this function on startup and whenever the QEMU/KVM version
3040 # changes, automatically populating pmxcfs.
3042 # Returns: { kvm => [ flagX, flagY, ... ], tcg => [ flag1, flag2, ... ] }
3043 # since kvm and tcg machines support different flags
3045 sub query_supported_cpu_flags
{
3048 $arch //= get_host_arch
();
3049 my $default_machine = $default_machines->{$arch};
3053 # FIXME: Once this is merged, the code below should work for ARM as well:
3054 # https://lists.nongnu.org/archive/html/qemu-devel/2019-06/msg04947.html
3055 die "QEMU/KVM cannot detect CPU flags on ARM (aarch64)\n" if
3058 my $kvm_supported = defined(kvm_version
());
3059 my $qemu_cmd = get_command_for_arch
($arch);
3061 my $pidfile = PVE
::QemuServer
::Helpers
::pidfile_name
($fakevmid);
3063 # Start a temporary (frozen) VM with vmid -1 to allow sending a QMP command
3064 my $query_supported_run_qemu = sub {
3070 '-machine', $default_machine,
3072 '-chardev', "socket,id=qmp,path=/var/run/qemu-server/$fakevmid.qmp,server,nowait",
3073 '-mon', 'chardev=qmp,mode=control',
3074 '-pidfile', $pidfile,
3079 push @$cmd, '-accel', 'tcg';
3082 my $rc = run_command
($cmd, noerr
=> 1, quiet
=> 0);
3083 die "QEMU flag querying VM exited with code " . $rc if $rc;
3086 my $cmd_result = mon_cmd
(
3088 'query-cpu-model-expansion',
3090 model
=> { name
=> 'host' }
3093 my $props = $cmd_result->{model
}->{props
};
3094 foreach my $prop (keys %$props) {
3095 next if $props->{$prop} ne '1';
3096 # QEMU returns some flags multiple times, with '_', '.' or '-'
3097 # (e.g. lahf_lm and lahf-lm; sse4.2, sse4-2 and sse4_2; ...).
3098 # We only keep those with underscores, to match /proc/cpuinfo
3099 $prop =~ s/\.|-/_/g;
3100 $flags->{$prop} = 1;
3105 # force stop with 10 sec timeout and 'nocheck'
3106 # always stop, even if QMP failed
3107 vm_stop
(undef, $fakevmid, 1, 1, 10, 0, 1);
3111 return [ sort keys %$flags ];
3114 # We need to query QEMU twice, since KVM and TCG have different supported flags
3115 PVE
::QemuConfig-
>lock_config($fakevmid, sub {
3116 $flags->{tcg
} = eval { $query_supported_run_qemu->(0) };
3117 warn "warning: failed querying supported tcg flags: $@\n" if $@;
3119 if ($kvm_supported) {
3120 $flags->{kvm
} = eval { $query_supported_run_qemu->(1) };
3121 warn "warning: failed querying supported kvm flags: $@\n" if $@;
3128 # Understood CPU flags are written to a file at 'pve-qemu' compile time
3129 my $understood_cpu_flag_dir = "/usr/share/kvm";
3130 sub query_understood_cpu_flags
{
3131 my $arch = get_host_arch
();
3132 my $filepath = "$understood_cpu_flag_dir/recognized-CPUID-flags-$arch";
3134 die "Cannot query understood QEMU CPU flags for architecture: $arch (file not found)\n"
3137 my $raw = file_get_contents
($filepath);
3138 $raw =~ s/^\s+|\s+$//g;
3139 my @flags = split(/\s+/, $raw);
3144 sub config_to_command
{
3145 my ($storecfg, $vmid, $conf, $defaults, $forcemachine, $forcecpu,
3149 my $globalFlags = [];
3150 my $machineFlags = [];
3155 my $ostype = $conf->{ostype
};
3156 my $winversion = windows_version
($ostype);
3157 my $kvm = $conf->{kvm
};
3158 my $nodename = nodename
();
3160 my $arch = get_vm_arch
($conf);
3161 my $kvm_binary = get_command_for_arch
($arch);
3162 my $kvmver = kvm_user_version
($kvm_binary);
3164 if (!$kvmver || $kvmver !~ m/^(\d+)\.(\d+)/ || $1 < 3) {
3165 $kvmver //= "undefined";
3166 die "Detected old QEMU binary ('$kvmver', at least 3.0 is required)\n";
3169 my $add_pve_version = min_version
($kvmver, 4, 1);
3171 my $machine_type = get_vm_machine
($conf, $forcemachine, $arch, $add_pve_version);
3172 my $machine_version = extract_version
($machine_type, $kvmver);
3173 $kvm //= 1 if is_native
($arch);
3175 $machine_version =~ m/(\d+)\.(\d+)/;
3176 my ($machine_major, $machine_minor) = ($1, $2);
3178 if ($kvmver =~ m/^\d+\.\d+\.(\d+)/ && $1 >= 90) {
3179 warn "warning: Installed QEMU version ($kvmver) is a release candidate, ignoring version checks\n";
3180 } elsif (!min_version
($kvmver, $machine_major, $machine_minor)) {
3181 die "Installed QEMU version '$kvmver' is too old to run machine type '$machine_type',"
3182 ." please upgrade node '$nodename'\n"
3183 } elsif (!PVE
::QemuServer
::Machine
::can_run_pve_machine_version
($machine_version, $kvmver)) {
3184 my $max_pve_version = PVE
::QemuServer
::Machine
::get_pve_version
($machine_version);
3185 die "Installed qemu-server (max feature level for $machine_major.$machine_minor is"
3186 ." pve$max_pve_version) is too old to run machine type '$machine_type', please upgrade"
3187 ." node '$nodename'\n";
3190 # if a specific +pve version is required for a feature, use $version_guard
3191 # instead of min_version to allow machines to be run with the minimum
3193 my $required_pve_version = 0;
3194 my $version_guard = sub {
3195 my ($major, $minor, $pve) = @_;
3196 return 0 if !min_version
($machine_version, $major, $minor, $pve);
3197 my $max_pve = PVE
::QemuServer
::Machine
::get_pve_version
("$major.$minor");
3198 return 1 if min_version
($machine_version, $major, $minor, $max_pve+1);
3199 $required_pve_version = $pve if $pve && $pve > $required_pve_version;
3203 if ($kvm && !defined kvm_version
()) {
3204 die "KVM virtualisation configured, but not available. Either disable in VM configuration"
3205 ." or enable in BIOS.\n";
3208 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
3209 my $hotplug_features = parse_hotplug_features
(defined($conf->{hotplug
}) ?
$conf->{hotplug
} : '1');
3210 my $use_old_bios_files = undef;
3211 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
3213 my $cpuunits = defined($conf->{cpuunits
}) ?
3214 $conf->{cpuunits
} : $defaults->{cpuunits
};
3216 push @$cmd, $kvm_binary;
3218 push @$cmd, '-id', $vmid;
3220 my $vmname = $conf->{name
} || "vm$vmid";
3222 push @$cmd, '-name', $vmname;
3224 push @$cmd, '-no-shutdown';
3228 my $qmpsocket = PVE
::QemuServer
::Helpers
::qmp_socket
($vmid);
3229 push @$cmd, '-chardev', "socket,id=qmp,path=$qmpsocket,server,nowait";
3230 push @$cmd, '-mon', "chardev=qmp,mode=control";
3232 if (min_version
($machine_version, 2, 12)) {
3233 push @$cmd, '-chardev', "socket,id=qmp-event,path=/var/run/qmeventd.sock,reconnect=5";
3234 push @$cmd, '-mon', "chardev=qmp-event,mode=control";
3237 push @$cmd, '-pidfile' , PVE
::QemuServer
::Helpers
::pidfile_name
($vmid);
3239 push @$cmd, '-daemonize';
3241 if ($conf->{smbios1
}) {
3242 my $smbios_conf = parse_smbios1
($conf->{smbios1
});
3243 if ($smbios_conf->{base64
}) {
3244 # Do not pass base64 flag to qemu
3245 delete $smbios_conf->{base64
};
3246 my $smbios_string = "";
3247 foreach my $key (keys %$smbios_conf) {
3249 if ($key eq "uuid") {
3250 $value = $smbios_conf->{uuid
}
3252 $value = decode_base64
($smbios_conf->{$key});
3254 # qemu accepts any binary data, only commas need escaping by double comma
3256 $smbios_string .= "," . $key . "=" . $value if $value;
3258 push @$cmd, '-smbios', "type=1" . $smbios_string;
3260 push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
3264 if ($conf->{bios
} && $conf->{bios
} eq 'ovmf') {
3265 my ($ovmf_code, $ovmf_vars) = get_ovmf_files
($arch);
3266 die "uefi base image '$ovmf_code' not found\n" if ! -f
$ovmf_code;
3268 my ($path, $format);
3269 if (my $efidisk = $conf->{efidisk0
}) {
3270 my $d = parse_drive
('efidisk0', $efidisk);
3271 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($d->{file
}, 1);
3272 $format = $d->{format
};
3274 $path = PVE
::Storage
::path
($storecfg, $d->{file
});
3275 if (!defined($format)) {
3276 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
3277 $format = qemu_img_format
($scfg, $volname);
3281 die "efidisk format must be specified\n"
3282 if !defined($format);
3285 warn "no efidisk configured! Using temporary efivars disk.\n";
3286 $path = "/tmp/$vmid-ovmf.fd";
3287 PVE
::Tools
::file_copy
($ovmf_vars, $path, -s
$ovmf_vars);
3293 if ($format eq 'raw' && $version_guard->(4, 1, 2)) {
3294 $size_str = ",size=" . (-s
$ovmf_vars);
3297 push @$cmd, '-drive', "if=pflash,unit=0,format=raw,readonly,file=$ovmf_code";
3298 push @$cmd, '-drive', "if=pflash,unit=1,format=$format,id=drive-efidisk0$size_str,file=$path";
3303 # we use different pcie-port hardware for qemu >= 4.0 for passthrough
3304 if (min_version
($machine_version, 4, 0)) {
3305 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35-4.0.cfg';
3307 push @$devices, '-readconfig', '/usr/share/qemu-server/pve-q35.cfg';
3311 if ($conf->{vmgenid
}) {
3312 push @$devices, '-device', 'vmgenid,guid='.$conf->{vmgenid
};
3315 # add usb controllers
3316 my @usbcontrollers = PVE
::QemuServer
::USB
::get_usb_controllers
(
3317 $conf, $bridges, $arch, $machine_type, $usbdesc->{format
}, $MAX_USB_DEVICES);
3318 push @$devices, @usbcontrollers if @usbcontrollers;
3319 my $vga = parse_vga
($conf->{vga
});
3321 my $qxlnum = vga_conf_has_spice
($conf->{vga
});
3322 $vga->{type
} = 'qxl' if $qxlnum;
3324 if (!$vga->{type
}) {
3325 if ($arch eq 'aarch64') {
3326 $vga->{type
} = 'virtio';
3327 } elsif (min_version
($machine_version, 2, 9)) {
3328 $vga->{type
} = (!$winversion || $winversion >= 6) ?
'std' : 'cirrus';
3330 $vga->{type
} = ($winversion >= 6) ?
'std' : 'cirrus';
3334 # enable absolute mouse coordinates (needed by vnc)
3336 if (defined($conf->{tablet
})) {
3337 $tablet = $conf->{tablet
};
3339 $tablet = $defaults->{tablet
};
3340 $tablet = 0 if $qxlnum; # disable for spice because it is not needed
3341 $tablet = 0 if $vga->{type
} =~ m/^serial\d+$/; # disable if we use serial terminal (no vga card)
3345 push @$devices, '-device', print_tabletdevice_full
($conf, $arch) if $tablet;
3346 my $kbd = print_keyboarddevice_full
($conf, $arch);
3347 push @$devices, '-device', $kbd if defined($kbd);
3350 my $bootorder = device_bootorder
($conf);
3352 # host pci device passthrough
3353 my ($kvm_off, $gpu_passthrough, $legacy_igd) = PVE
::QemuServer
::PCI
::print_hostpci_devices
(
3354 $vmid, $conf, $devices, $vga, $winversion, $q35, $bridges, $arch, $machine_type, $bootorder);
3357 my $usb_dev_features = {};
3358 $usb_dev_features->{spice_usb3
} = 1 if min_version
($machine_version, 4, 0);
3360 my @usbdevices = PVE
::QemuServer
::USB
::get_usb_devices
(
3361 $conf, $usbdesc->{format
}, $MAX_USB_DEVICES, $usb_dev_features, $bootorder);
3362 push @$devices, @usbdevices if @usbdevices;
3365 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
3366 if (my $path = $conf->{"serial$i"}) {
3367 if ($path eq 'socket') {
3368 my $socket = "/var/run/qemu-server/${vmid}.serial$i";
3369 push @$devices, '-chardev', "socket,id=serial$i,path=$socket,server,nowait";
3370 # On aarch64, serial0 is the UART device. Qemu only allows
3371 # connecting UART devices via the '-serial' command line, as
3372 # the device has a fixed slot on the hardware...
3373 if ($arch eq 'aarch64' && $i == 0) {
3374 push @$devices, '-serial', "chardev:serial$i";
3376 push @$devices, '-device', "isa-serial,chardev=serial$i";
3379 die "no such serial device\n" if ! -c
$path;
3380 push @$devices, '-chardev', "tty,id=serial$i,path=$path";
3381 push @$devices, '-device', "isa-serial,chardev=serial$i";
3387 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
3388 if (my $path = $conf->{"parallel$i"}) {
3389 die "no such parallel device\n" if ! -c
$path;
3390 my $devtype = $path =~ m!^/dev/usb/lp! ?
'tty' : 'parport';
3391 push @$devices, '-chardev', "$devtype,id=parallel$i,path=$path";
3392 push @$devices, '-device', "isa-parallel,chardev=parallel$i";
3396 if (min_version
($machine_version, 4, 0) && (my $audio = conf_has_audio
($conf))) {
3397 my $audiopciaddr = print_pci_addr
("audio0", $bridges, $arch, $machine_type);
3398 my $audio_devs = audio_devs
($audio, $audiopciaddr, $machine_version);
3399 push @$devices, @$audio_devs;
3403 $sockets = $conf->{smp
} if $conf->{smp
}; # old style - no longer iused
3404 $sockets = $conf->{sockets
} if $conf->{sockets
};
3406 my $cores = $conf->{cores
} || 1;
3408 my $maxcpus = $sockets * $cores;
3410 my $vcpus = $conf->{vcpus
} ?
$conf->{vcpus
} : $maxcpus;
3412 my $allowed_vcpus = $cpuinfo->{cpus
};
3414 die "MAX $allowed_vcpus vcpus allowed per VM on this node\n"
3415 if ($allowed_vcpus < $maxcpus);
3417 if($hotplug_features->{cpu
} && min_version
($machine_version, 2, 7)) {
3419 push @$cmd, '-smp', "1,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3420 for (my $i = 2; $i <= $vcpus; $i++) {
3421 my $cpustr = print_cpu_device
($conf,$i);
3422 push @$cmd, '-device', $cpustr;
3427 push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3429 push @$cmd, '-nodefaults';
3431 push @$cmd, '-boot', "menu=on,strict=on,reboot-timeout=1000,splash=/usr/share/qemu-server/bootsplash.jpg";
3433 push @$cmd, '-no-acpi' if defined($conf->{acpi
}) && $conf->{acpi
} == 0;
3435 push @$cmd, '-no-reboot' if defined($conf->{reboot
}) && $conf->{reboot
} == 0;
3437 if ($vga->{type
} && $vga->{type
} !~ m/^serial\d+$/ && $vga->{type
} ne 'none'){
3438 push @$devices, '-device', print_vga_device
(
3439 $conf, $vga, $arch, $machine_version, $machine_type, undef, $qxlnum, $bridges);
3440 my $socket = PVE
::QemuServer
::Helpers
::vnc_socket
($vmid);
3441 push @$cmd, '-vnc', "unix:$socket,password";
3443 push @$cmd, '-vga', 'none' if $vga->{type
} eq 'none';
3444 push @$cmd, '-nographic';
3448 my $tdf = defined($conf->{tdf
}) ?
$conf->{tdf
} : $defaults->{tdf
};
3449 my $useLocaltime = $conf->{localtime};
3451 if ($winversion >= 5) { # windows
3452 $useLocaltime = 1 if !defined($conf->{localtime});
3454 # use time drift fix when acpi is enabled
3455 if (!(defined($conf->{acpi
}) && $conf->{acpi
} == 0)) {
3456 $tdf = 1 if !defined($conf->{tdf
});
3460 if ($winversion >= 6) {
3461 push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
3462 push @$cmd, '-no-hpet';
3465 push @$rtcFlags, 'driftfix=slew' if $tdf;
3467 if ($conf->{startdate
} && $conf->{startdate
} ne 'now') {
3468 push @$rtcFlags, "base=$conf->{startdate}";
3469 } elsif ($useLocaltime) {
3470 push @$rtcFlags, 'base=localtime';
3474 push @$cmd, '-cpu', $forcecpu;
3476 push @$cmd, get_cpu_options
($conf, $arch, $kvm, $kvm_off, $machine_version, $winversion, $gpu_passthrough);
3479 PVE
::QemuServer
::Memory
::config
($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd);
3481 push @$cmd, '-S' if $conf->{freeze
};
3483 push @$cmd, '-k', $conf->{keyboard
} if defined($conf->{keyboard
});
3485 my $guest_agent = parse_guest_agent
($conf);
3487 if ($guest_agent->{enabled
}) {
3488 my $qgasocket = PVE
::QemuServer
::Helpers
::qmp_socket
($vmid, 1);
3489 push @$devices, '-chardev', "socket,path=$qgasocket,server,nowait,id=qga0";
3491 if (!$guest_agent->{type
} || $guest_agent->{type
} eq 'virtio') {
3492 my $pciaddr = print_pci_addr
("qga0", $bridges, $arch, $machine_type);
3493 push @$devices, '-device', "virtio-serial,id=qga0$pciaddr";
3494 push @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
3495 } elsif ($guest_agent->{type
} eq 'isa') {
3496 push @$devices, '-device', "isa-serial,chardev=qga0";
3500 my $rng = $conf->{rng0
} ? parse_rng
($conf->{rng0
}) : undef;
3501 if ($rng && $version_guard->(4, 1, 2)) {
3502 check_rng_source
($rng->{source
});
3504 my $max_bytes = $rng->{max_bytes
} // $rng_fmt->{max_bytes
}->{default};
3505 my $period = $rng->{period
} // $rng_fmt->{period
}->{default};
3506 my $limiter_str = "";
3508 $limiter_str = ",max-bytes=$max_bytes,period=$period";
3511 my $rng_addr = print_pci_addr
("rng0", $bridges, $arch, $machine_type);
3512 push @$devices, '-object', "rng-random,filename=$rng->{source},id=rng0";
3513 push @$devices, '-device', "virtio-rng-pci,rng=rng0$limiter_str$rng_addr";
3521 for (my $i = 1; $i < $qxlnum; $i++){
3522 push @$devices, '-device', print_vga_device
(
3523 $conf, $vga, $arch, $machine_version, $machine_type, $i, $qxlnum, $bridges);
3526 # assume other OS works like Linux
3527 my ($ram, $vram) = ("134217728", "67108864");
3528 if ($vga->{memory
}) {
3529 $ram = PVE
::Tools
::convert_size
($qxlnum*4*$vga->{memory
}, 'mb' => 'b');
3530 $vram = PVE
::Tools
::convert_size
($qxlnum*2*$vga->{memory
}, 'mb' => 'b');
3532 push @$cmd, '-global', "qxl-vga.ram_size=$ram";
3533 push @$cmd, '-global', "qxl-vga.vram_size=$vram";
3537 my $pciaddr = print_pci_addr
("spice", $bridges, $arch, $machine_type);
3539 my $pfamily = PVE
::Tools
::get_host_address_family
($nodename);
3540 my @nodeaddrs = PVE
::Tools
::getaddrinfo_all
('localhost', family
=> $pfamily);
3541 die "failed to get an ip address of type $pfamily for 'localhost'\n" if !@nodeaddrs;
3543 push @$devices, '-device', "virtio-serial,id=spice$pciaddr";
3544 push @$devices, '-chardev', "spicevmc,id=vdagent,name=vdagent";
3545 push @$devices, '-device', "virtserialport,chardev=vdagent,name=com.redhat.spice.0";
3547 my $localhost = PVE
::Network
::addr_to_ip
($nodeaddrs[0]->{addr
});
3548 $spice_port = PVE
::Tools
::next_spice_port
($pfamily, $localhost);
3550 my $spice_enhancement_str = $conf->{spice_enhancements
} // '';
3551 my $spice_enhancement = parse_property_string
($spice_enhancements_fmt, $spice_enhancement_str);
3552 if ($spice_enhancement->{foldersharing
}) {
3553 push @$devices, '-chardev', "spiceport,id=foldershare,name=org.spice-space.webdav.0";
3554 push @$devices, '-device', "virtserialport,chardev=foldershare,name=org.spice-space.webdav.0";
3557 my $spice_opts = "tls-port=${spice_port},addr=$localhost,tls-ciphers=HIGH,seamless-migration=on";
3558 $spice_opts .= ",streaming-video=$spice_enhancement->{videostreaming}"
3559 if $spice_enhancement->{videostreaming
};
3561 push @$devices, '-spice', "$spice_opts";
3564 # enable balloon by default, unless explicitly disabled
3565 if (!defined($conf->{balloon
}) || $conf->{balloon
}) {
3566 $pciaddr = print_pci_addr
("balloon0", $bridges, $arch, $machine_type);
3567 push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr";
3570 if ($conf->{watchdog
}) {
3571 my $wdopts = parse_watchdog
($conf->{watchdog
});
3572 $pciaddr = print_pci_addr
("watchdog", $bridges, $arch, $machine_type);
3573 my $watchdog = $wdopts->{model
} || 'i6300esb';
3574 push @$devices, '-device', "$watchdog$pciaddr";
3575 push @$devices, '-watchdog-action', $wdopts->{action
} if $wdopts->{action
};
3579 my $scsicontroller = {};
3580 my $ahcicontroller = {};
3581 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : $defaults->{scsihw
};
3583 # Add iscsi initiator name if available
3584 if (my $initiator = get_initiator_name
()) {
3585 push @$devices, '-iscsi', "initiator-name=$initiator";
3588 PVE
::QemuConfig-
>foreach_volume($conf, sub {
3589 my ($ds, $drive) = @_;
3591 if (PVE
::Storage
::parse_volume_id
($drive->{file
}, 1)) {
3592 push @$vollist, $drive->{file
};
3595 # ignore efidisk here, already added in bios/fw handling code above
3596 return if $drive->{interface
} eq 'efidisk';
3598 $use_virtio = 1 if $ds =~ m/^virtio/;
3600 $drive->{bootindex
} = $bootorder->{$ds} if $bootorder->{$ds};
3602 if ($drive->{interface
} eq 'virtio'){
3603 push @$cmd, '-object', "iothread,id=iothread-$ds" if $drive->{iothread
};
3606 if ($drive->{interface
} eq 'scsi') {
3608 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
3610 die "scsi$drive->{index}: machine version 4.1~pve2 or higher is required to use more than 14 SCSI disks\n"
3611 if $drive->{index} > 13 && !&$version_guard(4, 1, 2);
3613 $pciaddr = print_pci_addr
("$controller_prefix$controller", $bridges, $arch, $machine_type);
3614 my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ?
"virtio-scsi-pci" : $scsihw;
3617 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{iothread
}){
3618 $iothread .= ",iothread=iothread-$controller_prefix$controller";
3619 push @$cmd, '-object', "iothread,id=iothread-$controller_prefix$controller";
3620 } elsif ($drive->{iothread
}) {
3621 warn "iothread is only valid with virtio disk or virtio-scsi-single controller, ignoring\n";
3625 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{queues
}){
3626 $queues = ",num_queues=$drive->{queues}";
3629 push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr$iothread$queues"
3630 if !$scsicontroller->{$controller};
3631 $scsicontroller->{$controller}=1;
3634 if ($drive->{interface
} eq 'sata') {
3635 my $controller = int($drive->{index} / $PVE::QemuServer
::Drive
::MAX_SATA_DISKS
);
3636 $pciaddr = print_pci_addr
("ahci$controller", $bridges, $arch, $machine_type);
3637 push @$devices, '-device', "ahci,id=ahci$controller,multifunction=on$pciaddr"
3638 if !$ahcicontroller->{$controller};
3639 $ahcicontroller->{$controller}=1;
3642 my $pbs_conf = $pbs_backing->{$ds};
3643 my $pbs_name = undef;
3645 $pbs_name = "drive-$ds-pbs";
3646 push @$devices, '-blockdev', print_pbs_blockdev
($pbs_conf, $pbs_name);
3649 my $drive_cmd = print_drive_commandline_full
($storecfg, $vmid, $drive, $pbs_name);
3650 $drive_cmd .= ',readonly' if PVE
::QemuConfig-
>is_template($conf);
3652 push @$devices, '-drive',$drive_cmd;
3653 push @$devices, '-device', print_drivedevice_full
(
3654 $storecfg, $conf, $vmid, $drive, $bridges, $arch, $machine_type);
3657 for (my $i = 0; $i < $MAX_NETS; $i++) {
3658 my $netname = "net$i";
3660 next if !$conf->{$netname};
3661 my $d = parse_net
($conf->{$netname});
3664 $use_virtio = 1 if $d->{model
} eq 'virtio';
3666 $d->{bootindex
} = $bootorder->{$netname} if $bootorder->{$netname};
3668 my $netdevfull = print_netdev_full
($vmid, $conf, $arch, $d, $netname);
3669 push @$devices, '-netdev', $netdevfull;
3671 my $netdevicefull = print_netdevice_full
(
3672 $vmid, $conf, $d, $netname, $bridges, $use_old_bios_files, $arch, $machine_type);
3674 push @$devices, '-device', $netdevicefull;
3677 if ($conf->{ivshmem
}) {
3678 my $ivshmem = parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
3682 $bus = print_pcie_addr
("ivshmem");
3684 $bus = print_pci_addr
("ivshmem", $bridges, $arch, $machine_type);
3687 my $ivshmem_name = $ivshmem->{name
} // $vmid;
3688 my $path = '/dev/shm/pve-shm-' . $ivshmem_name;
3690 push @$devices, '-device', "ivshmem-plain,memdev=ivshmem$bus,";
3691 push @$devices, '-object', "memory-backend-file,id=ivshmem,share=on,mem-path=$path"
3692 .",size=$ivshmem->{size}M";
3695 # pci.4 is nested in pci.1
3696 $bridges->{1} = 1 if $bridges->{4};
3700 if (min_version
($machine_version, 2, 3)) {
3705 $bridges->{3} = 1 if $scsihw =~ m/^virtio-scsi-single/;
3709 for my $k (sort {$b cmp $a} keys %$bridges) {
3710 next if $q35 && $k < 4; # q35.cfg already includes bridges up to 3
3713 if ($k == 2 && $legacy_igd) {
3716 $pciaddr = print_pci_addr
("pci.$k_name", undef, $arch, $machine_type);
3718 my $devstr = "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr";
3720 # add after -readconfig pve-q35.cfg
3721 splice @$devices, 2, 0, '-device', $devstr;
3723 unshift @$devices, '-device', $devstr if $k > 0;
3728 push @$machineFlags, 'accel=tcg';
3731 my $machine_type_min = $machine_type;
3732 if ($add_pve_version) {
3733 $machine_type_min =~ s/\+pve\d+$//;
3734 $machine_type_min .= "+pve$required_pve_version";
3736 push @$machineFlags, "type=${machine_type_min}";
3738 push @$cmd, @$devices;
3739 push @$cmd, '-rtc', join(',', @$rtcFlags) if scalar(@$rtcFlags);
3740 push @$cmd, '-machine', join(',', @$machineFlags) if scalar(@$machineFlags);
3741 push @$cmd, '-global', join(',', @$globalFlags) if scalar(@$globalFlags);
3743 if (my $vmstate = $conf->{vmstate
}) {
3744 my $statepath = PVE
::Storage
::path
($storecfg, $vmstate);
3745 push @$vollist, $vmstate;
3746 push @$cmd, '-loadstate', $statepath;
3747 print "activating and using '$vmstate' as vmstate\n";
3751 if ($conf->{args
}) {
3752 my $aa = PVE
::Tools
::split_args
($conf->{args
});
3756 return wantarray ?
($cmd, $vollist, $spice_port) : $cmd;
3759 sub check_rng_source
{
3762 # mostly relevant for /dev/hwrng, but doesn't hurt to check others too
3763 die "cannot create VirtIO RNG device: source file '$source' doesn't exist\n"
3766 my $rng_current = '/sys/devices/virtual/misc/hw_random/rng_current';
3767 if ($source eq '/dev/hwrng' && file_read_firstline
($rng_current) eq 'none') {
3768 # Needs to abort, otherwise QEMU crashes on first rng access. Note that rng_current cannot
3769 # be changed to 'none' manually, so once the VM is past this point, it's no longer an issue.
3770 die "Cannot start VM with passed-through RNG device: '/dev/hwrng' exists, but"
3771 ." '$rng_current' is set to 'none'. Ensure that a compatible hardware-RNG is attached"
3779 my $res = mon_cmd
($vmid, 'query-spice');
3781 return $res->{'tls-port'} || $res->{'port'} || die "no spice port\n";
3784 sub vm_devices_list
{
3787 my $res = mon_cmd
($vmid, 'query-pci');
3788 my $devices_to_check = [];
3790 foreach my $pcibus (@$res) {
3791 push @$devices_to_check, @{$pcibus->{devices
}},
3794 while (@$devices_to_check) {
3796 for my $d (@$devices_to_check) {
3797 $devices->{$d->{'qdev_id'}} = 1 if $d->{'qdev_id'};
3798 next if !$d->{'pci_bridge'};
3800 $devices->{$d->{'qdev_id'}} += scalar(@{$d->{'pci_bridge'}->{devices
}});
3801 push @$to_check, @{$d->{'pci_bridge'}->{devices
}};
3803 $devices_to_check = $to_check;
3806 my $resblock = mon_cmd
($vmid, 'query-block');
3807 foreach my $block (@$resblock) {
3808 if($block->{device
} =~ m/^drive-(\S+)/){
3813 my $resmice = mon_cmd
($vmid, 'query-mice');
3814 foreach my $mice (@$resmice) {
3815 if ($mice->{name
} eq 'QEMU HID Tablet') {
3816 $devices->{tablet
} = 1;
3821 # for usb devices there is no query-usb
3822 # but we can iterate over the entries in
3823 # qom-list path=/machine/peripheral
3824 my $resperipheral = mon_cmd
($vmid, 'qom-list', path
=> '/machine/peripheral');
3825 foreach my $per (@$resperipheral) {
3826 if ($per->{name
} =~ m/^usb\d+$/) {
3827 $devices->{$per->{name
}} = 1;
3835 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
3837 my $q35 = PVE
::QemuServer
::Machine
::machine_type_is_q35
($conf);
3839 my $devices_list = vm_devices_list
($vmid);
3840 return 1 if defined($devices_list->{$deviceid});
3842 # add PCI bridge if we need it for the device
3843 qemu_add_pci_bridge
($storecfg, $conf, $vmid, $deviceid, $arch, $machine_type);
3845 if ($deviceid eq 'tablet') {
3847 qemu_deviceadd
($vmid, print_tabletdevice_full
($conf, $arch));
3849 } elsif ($deviceid eq 'keyboard') {
3851 qemu_deviceadd
($vmid, print_keyboarddevice_full
($conf, $arch));
3853 } elsif ($deviceid =~ m/^usb(\d+)$/) {
3855 die "usb hotplug currently not reliable\n";
3856 # since we can't reliably hot unplug all added usb devices and usb
3857 # passthrough breaks live migration we disable usb hotplugging for now
3858 #qemu_deviceadd($vmid, PVE::QemuServer::USB::print_usbdevice_full($conf, $deviceid, $device));
3860 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3862 qemu_iothread_add
($vmid, $deviceid, $device);
3864 qemu_driveadd
($storecfg, $vmid, $device);
3865 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, undef, $arch, $machine_type);
3867 qemu_deviceadd
($vmid, $devicefull);
3868 eval { qemu_deviceaddverify
($vmid, $deviceid); };
3870 eval { qemu_drivedel
($vmid, $deviceid); };
3875 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3878 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : "lsi";
3879 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
3880 my $scsihw_type = $scsihw eq 'virtio-scsi-single' ?
"virtio-scsi-pci" : $scsihw;
3882 my $devicefull = "$scsihw_type,id=$deviceid$pciaddr";
3884 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{iothread
}) {
3885 qemu_iothread_add
($vmid, $deviceid, $device);
3886 $devicefull .= ",iothread=iothread-$deviceid";
3889 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{queues
}) {
3890 $devicefull .= ",num_queues=$device->{queues}";
3893 qemu_deviceadd
($vmid, $devicefull);
3894 qemu_deviceaddverify
($vmid, $deviceid);
3896 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3898 qemu_findorcreatescsihw
($storecfg,$conf, $vmid, $device, $arch, $machine_type);
3899 qemu_driveadd
($storecfg, $vmid, $device);
3901 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device, undef, $arch, $machine_type);
3902 eval { qemu_deviceadd
($vmid, $devicefull); };
3904 eval { qemu_drivedel
($vmid, $deviceid); };
3909 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3911 return if !qemu_netdevadd
($vmid, $conf, $arch, $device, $deviceid);
3913 my $machine_type = PVE
::QemuServer
::Machine
::qemu_machine_pxe
($vmid, $conf);
3914 my $use_old_bios_files = undef;
3915 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
3917 my $netdevicefull = print_netdevice_full
(
3918 $vmid, $conf, $device, $deviceid, undef, $use_old_bios_files, $arch, $machine_type);
3919 qemu_deviceadd
($vmid, $netdevicefull);
3921 qemu_deviceaddverify
($vmid, $deviceid);
3922 qemu_set_link_status
($vmid, $deviceid, !$device->{link_down
});
3925 eval { qemu_netdevdel
($vmid, $deviceid); };
3930 } elsif (!$q35 && $deviceid =~ m/^(pci\.)(\d+)$/) {
3933 my $pciaddr = print_pci_addr
($deviceid, undef, $arch, $machine_type);
3934 my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
3936 qemu_deviceadd
($vmid, $devicefull);
3937 qemu_deviceaddverify
($vmid, $deviceid);
3940 die "can't hotplug device '$deviceid'\n";
3946 # fixme: this should raise exceptions on error!
3947 sub vm_deviceunplug
{
3948 my ($vmid, $conf, $deviceid) = @_;
3950 my $devices_list = vm_devices_list
($vmid);
3951 return 1 if !defined($devices_list->{$deviceid});
3953 my $bootdisks = PVE
::QemuServer
::Drive
::get_bootdisks
($conf);
3954 die "can't unplug bootdisk '$deviceid'\n" if grep {$_ eq $deviceid} @$bootdisks;
3956 if ($deviceid eq 'tablet' || $deviceid eq 'keyboard') {
3958 qemu_devicedel
($vmid, $deviceid);
3960 } elsif ($deviceid =~ m/^usb\d+$/) {
3962 die "usb hotplug currently not reliable\n";
3963 # when unplugging usb devices this way, there may be remaining usb
3964 # controllers/hubs so we disable it for now
3965 #qemu_devicedel($vmid, $deviceid);
3966 #qemu_devicedelverify($vmid, $deviceid);
3968 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3970 qemu_devicedel
($vmid, $deviceid);
3971 qemu_devicedelverify
($vmid, $deviceid);
3972 qemu_drivedel
($vmid, $deviceid);
3973 qemu_iothread_del
($conf, $vmid, $deviceid);
3975 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3977 qemu_devicedel
($vmid, $deviceid);
3978 qemu_devicedelverify
($vmid, $deviceid);
3979 qemu_iothread_del
($conf, $vmid, $deviceid);
3981 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3983 qemu_devicedel
($vmid, $deviceid);
3984 qemu_drivedel
($vmid, $deviceid);
3985 qemu_deletescsihw
($conf, $vmid, $deviceid);
3987 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3989 qemu_devicedel
($vmid, $deviceid);
3990 qemu_devicedelverify
($vmid, $deviceid);
3991 qemu_netdevdel
($vmid, $deviceid);
3994 die "can't unplug device '$deviceid'\n";
4000 sub qemu_deviceadd
{
4001 my ($vmid, $devicefull) = @_;
4003 $devicefull = "driver=".$devicefull;
4004 my %options = split(/[=,]/, $devicefull);
4006 mon_cmd
($vmid, "device_add" , %options);
4009 sub qemu_devicedel
{
4010 my ($vmid, $deviceid) = @_;
4012 my $ret = mon_cmd
($vmid, "device_del", id
=> $deviceid);
4015 sub qemu_iothread_add
{
4016 my($vmid, $deviceid, $device) = @_;
4018 if ($device->{iothread
}) {
4019 my $iothreads = vm_iothreads_list
($vmid);
4020 qemu_objectadd
($vmid, "iothread-$deviceid", "iothread") if !$iothreads->{"iothread-$deviceid"};
4024 sub qemu_iothread_del
{
4025 my($conf, $vmid, $deviceid) = @_;
4027 my $confid = $deviceid;
4028 if ($deviceid =~ m/^(?:virtioscsi|scsihw)(\d+)$/) {
4029 $confid = 'scsi' . $1;
4031 my $device = parse_drive
($confid, $conf->{$confid});
4032 if ($device->{iothread
}) {
4033 my $iothreads = vm_iothreads_list
($vmid);
4034 qemu_objectdel
($vmid, "iothread-$deviceid") if $iothreads->{"iothread-$deviceid"};
4038 sub qemu_objectadd
{
4039 my($vmid, $objectid, $qomtype) = @_;
4041 mon_cmd
($vmid, "object-add", id
=> $objectid, "qom-type" => $qomtype);
4046 sub qemu_objectdel
{
4047 my($vmid, $objectid) = @_;
4049 mon_cmd
($vmid, "object-del", id
=> $objectid);
4055 my ($storecfg, $vmid, $device) = @_;
4057 my $drive = print_drive_commandline_full
($storecfg, $vmid, $device);
4058 $drive =~ s/\\/\\\\/g;
4059 my $ret = PVE
::QemuServer
::Monitor
::hmp_cmd
($vmid, "drive_add auto \"$drive\"");
4061 # If the command succeeds qemu prints: "OK
"
4062 return 1 if $ret =~ m/OK/s;
4064 die "adding drive failed
: $ret\n";
4068 my($vmid, $deviceid) = @_;
4070 my $ret = PVE::QemuServer::Monitor::hmp_cmd($vmid, "drive_del drive-
$deviceid");
4073 return 1 if $ret eq "";
4075 # NB: device not found errors mean the drive was auto-deleted and we ignore the error
4076 return 1 if $ret =~ m/Device \'.*?\' not found/s;
4078 die "deleting drive
$deviceid failed
: $ret\n";
4081 sub qemu_deviceaddverify {
4082 my ($vmid, $deviceid) = @_;
4084 for (my $i = 0; $i <= 5; $i++) {
4085 my $devices_list = vm_devices_list($vmid);
4086 return 1 if defined($devices_list->{$deviceid});
4090 die "error on hotplug device
'$deviceid'\n";
4094 sub qemu_devicedelverify {
4095 my ($vmid, $deviceid) = @_;
4097 # need to verify that the device is correctly removed as device_del
4098 # is async and empty return is not reliable
4100 for (my $i = 0; $i <= 5; $i++) {
4101 my $devices_list = vm_devices_list($vmid);
4102 return 1 if !defined($devices_list->{$deviceid});
4106 die "error on hot-unplugging device
'$deviceid'\n";
4109 sub qemu_findorcreatescsihw {
4110 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
4112 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
4114 my $scsihwid="$controller_prefix$controller";
4115 my $devices_list = vm_devices_list($vmid);
4117 if(!defined($devices_list->{$scsihwid})) {
4118 vm_deviceplug($storecfg, $conf, $vmid, $scsihwid, $device, $arch, $machine_type);
4124 sub qemu_deletescsihw {
4125 my ($conf, $vmid, $opt) = @_;
4127 my $device = parse_drive($opt, $conf->{$opt});
4129 if ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
4130 vm_deviceunplug($vmid, $conf, "virtioscsi
$device->{index}");
4134 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
4136 my $devices_list = vm_devices_list($vmid);
4137 foreach my $opt (keys %{$devices_list}) {
4138 if (is_valid_drivename($opt)) {
4139 my $drive = parse_drive($opt, $conf->{$opt});
4140 if($drive->{interface} eq 'scsi' && $drive->{index} < (($maxdev-1)*($controller+1))) {
4146 my $scsihwid="scsihw
$controller";
4148 vm_deviceunplug($vmid, $conf, $scsihwid);
4153 sub qemu_add_pci_bridge {
4154 my ($storecfg, $conf, $vmid, $device, $arch, $machine_type) = @_;
4160 print_pci_addr($device, $bridges, $arch, $machine_type);
4162 while (my ($k, $v) = each %$bridges) {
4165 return 1 if !defined($bridgeid) || $bridgeid < 1;
4167 my $bridge = "pci
.$bridgeid";
4168 my $devices_list = vm_devices_list($vmid);
4170 if (!defined($devices_list->{$bridge})) {
4171 vm_deviceplug($storecfg, $conf, $vmid, $bridge, $arch, $machine_type);
4177 sub qemu_set_link_status {
4178 my ($vmid, $device, $up) = @_;
4180 mon_cmd($vmid, "set_link
", name => $device,
4181 up => $up ? JSON::true : JSON::false);
4184 sub qemu_netdevadd {
4185 my ($vmid, $conf, $arch, $device, $deviceid) = @_;
4187 my $netdev = print_netdev_full($vmid, $conf, $arch, $device, $deviceid, 1);
4188 my %options = split(/[=,]/, $netdev);
4190 if (defined(my $vhost = $options{vhost})) {
4191 $options{vhost} = JSON::boolean(PVE::JSONSchema::parse_boolean($vhost));
4194 if (defined(my $queues = $options{queues})) {
4195 $options{queues} = $queues + 0;
4198 mon_cmd($vmid, "netdev_add
", %options);
4202 sub qemu_netdevdel {
4203 my ($vmid, $deviceid) = @_;
4205 mon_cmd($vmid, "netdev_del
", id => $deviceid);
4208 sub qemu_usb_hotplug {
4209 my ($storecfg, $conf, $vmid, $deviceid, $device, $arch, $machine_type) = @_;
4213 # remove the old one first
4214 vm_deviceunplug($vmid, $conf, $deviceid);
4216 # check if xhci controller is necessary and available
4217 if ($device->{usb3}) {
4219 my $devicelist = vm_devices_list($vmid);
4221 if (!$devicelist->{xhci}) {
4222 my $pciaddr = print_pci_addr("xhci
", undef, $arch, $machine_type);
4223 qemu_deviceadd($vmid, "nec-usb-xhci
,id
=xhci
$pciaddr");
4226 my $d = parse_usb_device($device->{host});
4227 $d->{usb3} = $device->{usb3};
4230 vm_deviceplug($storecfg, $conf, $vmid, $deviceid, $d, $arch, $machine_type);
4233 sub qemu_cpu_hotplug {
4234 my ($vmid, $conf, $vcpus) = @_;
4236 my $machine_type = PVE::QemuServer::Machine::get_current_qemu_machine($vmid);
4239 $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
4240 $sockets = $conf->{sockets} if $conf->{sockets};
4241 my $cores = $conf->{cores} || 1;
4242 my $maxcpus = $sockets * $cores;
4244 $vcpus = $maxcpus if !$vcpus;
4246 die "you can
't add more vcpus than maxcpus\n"
4247 if $vcpus > $maxcpus;
4249 my $currentvcpus = $conf->{vcpus} || $maxcpus;
4251 if ($vcpus < $currentvcpus) {
4253 if (PVE::QemuServer::Machine::machine_version($machine_type, 2, 7)) {
4255 for (my $i = $currentvcpus; $i > $vcpus; $i--) {
4256 qemu_devicedel($vmid, "cpu$i");
4258 my $currentrunningvcpus = undef;
4260 $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4261 last if scalar(@{$currentrunningvcpus}) == $i-1;
4262 raise_param_exc({ vcpus => "error unplugging cpu$i" }) if $retry > 5;
4266 #update conf after each succesfull cpu unplug
4267 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4268 PVE::QemuConfig->write_config($vmid, $conf);
4271 die "cpu hot-unplugging requires qemu version 2.7 or higher\n";
4277 my $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4278 die "vcpus in running vm does not match its configuration\n"
4279 if scalar(@{$currentrunningvcpus}) != $currentvcpus;
4281 if (PVE::QemuServer::Machine::machine_version($machine_type, 2, 7)) {
4283 for (my $i = $currentvcpus+1; $i <= $vcpus; $i++) {
4284 my $cpustr = print_cpu_device($conf, $i);
4285 qemu_deviceadd($vmid, $cpustr);
4288 my $currentrunningvcpus = undef;
4290 $currentrunningvcpus = mon_cmd($vmid, "query-cpus-fast");
4291 last if scalar(@{$currentrunningvcpus}) == $i;
4292 raise_param_exc({ vcpus => "error hotplugging cpu$i" }) if $retry > 10;
4296 #update conf after each succesfull cpu hotplug
4297 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
4298 PVE::QemuConfig->write_config($vmid, $conf);
4302 for (my $i = $currentvcpus; $i < $vcpus; $i++) {
4303 mon_cmd($vmid, "cpu-add", id => int($i));
4308 sub qemu_block_set_io_throttle {
4309 my ($vmid, $deviceid,
4310 $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr,
4311 $bps_max, $bps_rd_max, $bps_wr_max, $iops_max, $iops_rd_max, $iops_wr_max,
4312 $bps_max_length, $bps_rd_max_length, $bps_wr_max_length,
4313 $iops_max_length, $iops_rd_max_length, $iops_wr_max_length) = @_;
4315 return if !check_running($vmid) ;
4317 mon_cmd($vmid, "block_set_io_throttle", device => $deviceid,
4319 bps_rd => int($bps_rd),
4320 bps_wr => int($bps_wr),
4322 iops_rd => int($iops_rd),
4323 iops_wr => int($iops_wr),
4324 bps_max => int($bps_max),
4325 bps_rd_max => int($bps_rd_max),
4326 bps_wr_max => int($bps_wr_max),
4327 iops_max => int($iops_max),
4328 iops_rd_max => int($iops_rd_max),
4329 iops_wr_max => int($iops_wr_max),
4330 bps_max_length => int($bps_max_length),
4331 bps_rd_max_length => int($bps_rd_max_length),
4332 bps_wr_max_length => int($bps_wr_max_length),
4333 iops_max_length => int($iops_max_length),
4334 iops_rd_max_length => int($iops_rd_max_length),
4335 iops_wr_max_length => int($iops_wr_max_length),
4340 sub qemu_block_resize {
4341 my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
4343 my $running = check_running($vmid);
4345 $size = 0 if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
4347 return if !$running;
4349 my $padding = (1024 - $size % 1024) % 1024;
4350 $size = $size + $padding;
4355 device => $deviceid,
4361 sub qemu_volume_snapshot {
4362 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4364 my $running = check_running($vmid);
4366 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4367 mon_cmd($vmid, 'blockdev-snapshot-internal-sync
', device => $deviceid, name => $snap);
4369 PVE::Storage::volume_snapshot($storecfg, $volid, $snap);
4373 sub qemu_volume_snapshot_delete {
4374 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4376 my $running = check_running($vmid);
4381 my $conf = PVE::QemuConfig->load_config($vmid);
4382 PVE::QemuConfig->foreach_volume($conf, sub {
4383 my ($ds, $drive) = @_;
4384 $running = 1 if $drive->{file} eq $volid;
4388 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4389 mon_cmd($vmid, 'blockdev-snapshot-delete-internal-sync
', device => $deviceid, name => $snap);
4391 PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
4395 sub set_migration_caps {
4396 my ($vmid, $savevm) = @_;
4398 my $qemu_support = eval { mon_cmd($vmid, "query-proxmox-support") };
4400 my $bitmap_prop = $savevm ? 'pbs-dirty-bitmap-savevm
' : 'pbs-dirty-bitmap-migration
';
4401 my $dirty_bitmaps = $qemu_support->{$bitmap_prop} ? 1 : 0;
4406 "auto-converge" => 1,
4408 "x-rdma-pin-all" => 0,
4411 "dirty-bitmaps" => $dirty_bitmaps,
4414 my $supported_capabilities = mon_cmd($vmid, "query-migrate-capabilities");
4416 for my $supported_capability (@$supported_capabilities) {
4418 capability => $supported_capability->{capability},
4419 state => $enabled_cap->{$supported_capability->{capability}} ? JSON::true : JSON::false,
4423 mon_cmd($vmid, "migrate-set-capabilities", capabilities => $cap_ref);
4427 my ($conf, $func, @param) = @_;
4431 my $test_volid = sub {
4432 my ($key, $drive, $snapname) = @_;
4434 my $volid = $drive->{file};
4437 $volhash->{$volid}->{cdrom} //= 1;
4438 $volhash->{$volid}->{cdrom} = 0 if !drive_is_cdrom($drive);
4440 my $replicate = $drive->{replicate} // 1;
4441 $volhash->{$volid}->{replicate} //= 0;
4442 $volhash->{$volid}->{replicate} = 1 if $replicate;
4444 $volhash->{$volid}->{shared} //= 0;
4445 $volhash->{$volid}->{shared} = 1 if $drive->{shared};
4447 $volhash->{$volid}->{referenced_in_config} //= 0;
4448 $volhash->{$volid}->{referenced_in_config} = 1 if !defined($snapname);
4450 $volhash->{$volid}->{referenced_in_snapshot}->{$snapname} = 1
4451 if defined($snapname);
4453 my $size = $drive->{size};
4454 $volhash->{$volid}->{size} //= $size if $size;
4456 $volhash->{$volid}->{is_vmstate} //= 0;
4457 $volhash->{$volid}->{is_vmstate} = 1 if $key eq 'vmstate
';
4459 $volhash->{$volid}->{is_unused} //= 0;
4460 $volhash->{$volid}->{is_unused} = 1 if $key =~ /^unused\d+$/;
4463 my $include_opts = {
4464 extra_keys => ['vmstate
'],
4465 include_unused => 1,
4468 PVE::QemuConfig->foreach_volume_full($conf, $include_opts, $test_volid);
4469 foreach my $snapname (keys %{$conf->{snapshots}}) {
4470 my $snap = $conf->{snapshots}->{$snapname};
4471 PVE::QemuConfig->foreach_volume_full($snap, $include_opts, $test_volid, $snapname);
4474 foreach my $volid (keys %$volhash) {
4475 &$func($volid, $volhash->{$volid}, @param);
4479 my $fast_plug_option = {
4487 'vmstatestorage
' => 1,
4492 # hotplug changes in [PENDING]
4493 # $selection hash can be used to only apply specified options, for
4494 # example: { cores => 1 } (only apply changed 'cores
')
4495 # $errors ref is used to return error messages
4496 sub vmconfig_hotplug_pending {
4497 my ($vmid, $conf, $storecfg, $selection, $errors) = @_;
4499 my $defaults = load_defaults();
4500 my $arch = get_vm_arch($conf);
4501 my $machine_type = get_vm_machine($conf, undef, $arch);
4503 # commit values which do not have any impact on running VM first
4504 # Note: those option cannot raise errors, we we do not care about
4505 # $selection and always apply them.
4507 my $add_error = sub {
4508 my ($opt, $msg) = @_;
4509 $errors->{$opt} = "hotplug problem - $msg";
4513 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4514 if ($fast_plug_option->{$opt}) {
4515 $conf->{$opt} = $conf->{pending}->{$opt};
4516 delete $conf->{pending}->{$opt};
4522 PVE::QemuConfig->write_config($vmid, $conf);
4525 my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
4527 my $cgroup = PVE::QemuServer::CGroup->new($vmid);
4528 my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete});
4529 foreach my $opt (sort keys %$pending_delete_hash) {
4530 next if $selection && !$selection->{$opt};
4531 my $force = $pending_delete_hash->{$opt}->{force};
4533 if ($opt eq 'hotplug
') {
4534 die "skip\n" if ($conf->{hotplug} =~ /memory/);
4535 } elsif ($opt eq 'tablet
') {
4536 die "skip\n" if !$hotplug_features->{usb};
4537 if ($defaults->{tablet}) {
4538 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
4539 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
4540 if $arch eq 'aarch64
';
4542 vm_deviceunplug($vmid, $conf, 'tablet
');
4543 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
4545 } elsif ($opt =~ m/^usb\d+/) {
4547 # since we cannot reliably hot unplug usb devices we are disabling it
4548 #die "skip\n" if !$hotplug_features->{usb} || $conf->{$opt} =~ m/spice/i;
4549 #vm_deviceunplug($vmid, $conf, $opt);
4550 } elsif ($opt eq 'vcpus
') {
4551 die "skip\n" if !$hotplug_features->{cpu};
4552 qemu_cpu_hotplug($vmid, $conf, undef);
4553 } elsif ($opt eq 'balloon
') {
4554 # enable balloon device is not hotpluggable
4555 die "skip\n" if defined($conf->{balloon}) && $conf->{balloon} == 0;
4556 # here we reset the ballooning value to memory
4557 my $balloon = $conf->{memory} || $defaults->{memory};
4558 mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4559 } elsif ($fast_plug_option->{$opt}) {
4561 } elsif ($opt =~ m/^net(\d+)$/) {
4562 die "skip\n" if !$hotplug_features->{network};
4563 vm_deviceunplug($vmid, $conf, $opt);
4564 } elsif (is_valid_drivename($opt)) {
4565 die "skip\n" if !$hotplug_features->{disk} || $opt =~ m/(ide|sata)(\d+)/;
4566 vm_deviceunplug($vmid, $conf, $opt);
4567 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4568 } elsif ($opt =~ m/^memory$/) {
4569 die "skip\n" if !$hotplug_features->{memory};
4570 PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
4571 } elsif ($opt eq 'cpuunits
') {
4572 $cgroup->change_cpu_shares(undef, $defaults->{cpuunits});
4573 } elsif ($opt eq 'cpulimit
') {
4574 $cgroup->change_cpu_quota(-1, 100000);
4580 &$add_error($opt, $err) if $err ne "skip\n";
4582 delete $conf->{$opt};
4583 PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
4587 my ($apply_pending_cloudinit, $apply_pending_cloudinit_done);
4588 $apply_pending_cloudinit = sub {
4589 return if $apply_pending_cloudinit_done; # once is enough
4590 $apply_pending_cloudinit_done = 1; # once is enough
4592 my ($key, $value) = @_;
4594 my @cloudinit_opts = keys %$confdesc_cloudinit;
4595 foreach my $opt (keys %{$conf->{pending}}) {
4596 next if !grep { $_ eq $opt } @cloudinit_opts;
4597 $conf->{$opt} = delete $conf->{pending}->{$opt};
4600 my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete});
4601 foreach my $opt (sort keys %$pending_delete_hash) {
4602 next if !grep { $_ eq $opt } @cloudinit_opts;
4603 PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
4604 delete $conf->{$opt};
4607 my $new_conf = { %$conf };
4608 $new_conf->{$key} = $value;
4609 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($new_conf, $vmid);
4612 foreach my $opt (keys %{$conf->{pending}}) {
4613 next if $selection && !$selection->{$opt};
4614 my $value = $conf->{pending}->{$opt};
4616 if ($opt eq 'hotplug
') {
4617 die "skip\n" if ($value =~ /memory/) || ($value !~ /memory/ && $conf->{hotplug} =~ /memory/);
4618 } elsif ($opt eq 'tablet
') {
4619 die "skip\n" if !$hotplug_features->{usb};
4621 vm_deviceplug($storecfg, $conf, $vmid, 'tablet
', $arch, $machine_type);
4622 vm_deviceplug($storecfg, $conf, $vmid, 'keyboard
', $arch, $machine_type)
4623 if $arch eq 'aarch64
';
4624 } elsif ($value == 0) {
4625 vm_deviceunplug($vmid, $conf, 'tablet
');
4626 vm_deviceunplug($vmid, $conf, 'keyboard
') if $arch eq 'aarch64
';
4628 } elsif ($opt =~ m/^usb\d+$/) {
4630 # since we cannot reliably hot unplug usb devices we disable it for now
4631 #die "skip\n" if !$hotplug_features->{usb} || $value =~ m/spice/i;
4632 #my $d = eval { parse_property_string($usbdesc->{format}, $value) };
4633 #die "skip\n" if !$d;
4634 #qemu_usb_hotplug($storecfg, $conf, $vmid, $opt, $d, $arch, $machine_type);
4635 } elsif ($opt eq 'vcpus
') {
4636 die "skip\n" if !$hotplug_features->{cpu};
4637 qemu_cpu_hotplug($vmid, $conf, $value);
4638 } elsif ($opt eq 'balloon
') {
4639 # enable/disable balloning device is not hotpluggable
4640 my $old_balloon_enabled = !!(!defined($conf->{balloon}) || $conf->{balloon});
4641 my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
4642 die "skip\n" if $old_balloon_enabled != $new_balloon_enabled;
4644 # allow manual ballooning if shares is set to zero
4645 if ((defined($conf->{shares}) && ($conf->{shares} == 0))) {
4646 my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
4647 mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4649 } elsif ($opt =~ m/^net(\d+)$/) {
4650 # some changes can be done without hotplug
4651 vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
4652 $vmid, $opt, $value, $arch, $machine_type);
4653 } elsif (is_valid_drivename($opt)) {
4654 die "skip\n" if $opt eq 'efidisk0
';
4655 # some changes can be done without hotplug
4656 my $drive = parse_drive($opt, $value);
4657 if (drive_is_cloudinit($drive)) {
4658 &$apply_pending_cloudinit($opt, $value);
4660 vmconfig_update_disk($storecfg, $conf, $hotplug_features->{disk},
4661 $vmid, $opt, $value, $arch, $machine_type);
4662 } elsif ($opt =~ m/^memory$/) { #dimms
4663 die "skip\n" if !$hotplug_features->{memory};
4664 $value = PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
4665 } elsif ($opt eq 'cpuunits
') {
4666 $cgroup->change_cpu_shares($conf->{pending}->{$opt}, $defaults->{cpuunits});
4667 } elsif ($opt eq 'cpulimit
') {
4668 my $cpulimit = $conf->{pending}->{$opt} == 0 ? -1 : int($conf->{pending}->{$opt} * 100000);
4669 $cgroup->change_cpu_quota($cpulimit, 100000);
4671 die "skip\n"; # skip non-hot-pluggable options
4675 &$add_error($opt, $err) if $err ne "skip\n";
4677 $conf->{$opt} = $value;
4678 delete $conf->{pending}->{$opt};
4682 PVE::QemuConfig->write_config($vmid, $conf);
4685 sub try_deallocate_drive {
4686 my ($storecfg, $vmid, $conf, $key, $drive, $rpcenv, $authuser, $force) = @_;
4688 if (($force || $key =~ /^unused/) && !drive_is_cdrom($drive, 1)) {
4689 my $volid = $drive->{file};
4690 if (vm_is_volid_owner($storecfg, $vmid, $volid)) {
4691 my $sid = PVE::Storage::parse_volume_id($volid);
4692 $rpcenv->check($authuser, "/storage/$sid", ['Datastore
.AllocateSpace
']);
4694 # check if the disk is really unused
4695 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
4696 if PVE::QemuServer::Drive::is_volume_in_use($storecfg, $conf, $key, $volid);
4697 PVE::Storage::vdisk_free($storecfg, $volid);
4700 # If vm is not owner of this disk remove from config
4708 sub vmconfig_delete_or_detach_drive {
4709 my ($vmid, $storecfg, $conf, $opt, $force) = @_;
4711 my $drive = parse_drive($opt, $conf->{$opt});
4713 my $rpcenv = PVE::RPCEnvironment::get();
4714 my $authuser = $rpcenv->get_user();
4717 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM
.Config
.Disk
']);
4718 try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser, $force);
4720 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $drive);
4726 sub vmconfig_apply_pending {
4727 my ($vmid, $conf, $storecfg, $errors) = @_;
4729 my $add_apply_error = sub {
4730 my ($opt, $msg) = @_;
4731 my $err_msg = "unable to apply pending change $opt : $msg";
4732 $errors->{$opt} = $err_msg;
4738 my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete});
4739 foreach my $opt (sort keys %$pending_delete_hash) {
4740 my $force = $pending_delete_hash->{$opt}->{force};
4742 if ($opt =~ m/^unused/) {
4743 die "internal error";
4744 } elsif (defined($conf->{$opt}) && is_valid_drivename($opt)) {
4745 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4749 $add_apply_error->($opt, $err);
4751 PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
4752 delete $conf->{$opt};
4756 PVE::QemuConfig->cleanup_pending($conf);
4758 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4759 next if $opt eq 'delete'; # just to be sure
4761 if (defined($conf->{$opt}) && is_valid_drivename($opt)) {
4762 vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}))
4766 $add_apply_error->($opt, $err);
4768 $conf->{$opt} = delete $conf->{pending}->{$opt};
4772 # write all changes at once to avoid unnecessary i/o
4773 PVE::QemuConfig->write_config($vmid, $conf);
4776 sub vmconfig_update_net {
4777 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $arch, $machine_type) = @_;
4779 my $newnet = parse_net($value);
4781 if ($conf->{$opt}) {
4782 my $oldnet = parse_net($conf->{$opt});
4784 if (safe_string_ne($oldnet->{model}, $newnet->{model}) ||
4785 safe_string_ne($oldnet->{macaddr}, $newnet->{macaddr}) ||
4786 safe_num_ne($oldnet->{queues}, $newnet->{queues}) ||
4787 !($newnet->{bridge} && $oldnet->{bridge})) { # bridge/nat mode change
4789 # for non online change, we try to hot-unplug
4790 die "skip\n" if !$hotplug;
4791 vm_deviceunplug($vmid, $conf, $opt);
4794 die "internal error" if $opt !~ m/net(\d+)/;
4795 my $iface = "tap${vmid}i$1";
4797 if (safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
4798 safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
4799 safe_string_ne($oldnet->{trunks}, $newnet->{trunks}) ||
4800 safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
4801 PVE::Network::tap_unplug($iface);
4804 PVE::Network::SDN::Zones::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
4806 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
4808 } elsif (safe_num_ne($oldnet->{rate}, $newnet->{rate})) {
4809 # Rate can be applied on its own but any change above needs to
4810 # include the rate in tap_plug since OVS resets everything.
4811 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
4814 if (safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
4815 qemu_set_link_status($vmid, $opt, !$newnet->{link_down});
4823 vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet, $arch, $machine_type);
4829 sub vmconfig_update_disk {
4830 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $arch, $machine_type) = @_;
4832 my $drive = parse_drive($opt, $value);
4834 if ($conf->{$opt} && (my $old_drive = parse_drive($opt, $conf->{$opt}))) {
4835 my $media = $drive->{media} || 'disk
';
4836 my $oldmedia = $old_drive->{media} || 'disk
';
4837 die "unable to change media type\n" if $media ne $oldmedia;
4839 if (!drive_is_cdrom($old_drive)) {
4841 if ($drive->{file} ne $old_drive->{file}) {
4843 die "skip\n" if !$hotplug;
4845 # unplug and register as unused
4846 vm_deviceunplug($vmid, $conf, $opt);
4847 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive)
4850 # update existing disk
4852 # skip non hotpluggable value
4853 if (safe_string_ne($drive->{discard}, $old_drive->{discard}) ||
4854 safe_string_ne($drive->{iothread}, $old_drive->{iothread}) ||
4855 safe_string_ne($drive->{queues}, $old_drive->{queues}) ||
4856 safe_string_ne($drive->{cache}, $old_drive->{cache}) ||
4857 safe_string_ne($drive->{ssd}, $old_drive->{ssd})) {
4862 if (safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
4863 safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
4864 safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
4865 safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
4866 safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
4867 safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr}) ||
4868 safe_num_ne($drive->{mbps_max}, $old_drive->{mbps_max}) ||
4869 safe_num_ne($drive->{mbps_rd_max}, $old_drive->{mbps_rd_max}) ||
4870 safe_num_ne($drive->{mbps_wr_max}, $old_drive->{mbps_wr_max}) ||
4871 safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
4872 safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
4873 safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max}) ||
4874 safe_num_ne($drive->{bps_max_length}, $old_drive->{bps_max_length}) ||
4875 safe_num_ne($drive->{bps_rd_max_length}, $old_drive->{bps_rd_max_length}) ||
4876 safe_num_ne($drive->{bps_wr_max_length}, $old_drive->{bps_wr_max_length}) ||
4877 safe_num_ne($drive->{iops_max_length}, $old_drive->{iops_max_length}) ||
4878 safe_num_ne($drive->{iops_rd_max_length}, $old_drive->{iops_rd_max_length}) ||
4879 safe_num_ne($drive->{iops_wr_max_length}, $old_drive->{iops_wr_max_length})) {
4881 qemu_block_set_io_throttle(
4883 ($drive->{mbps} || 0)*1024*1024,
4884 ($drive->{mbps_rd} || 0)*1024*1024,
4885 ($drive->{mbps_wr} || 0)*1024*1024,
4886 $drive->{iops} || 0,
4887 $drive->{iops_rd} || 0,
4888 $drive->{iops_wr} || 0,
4889 ($drive->{mbps_max} || 0)*1024*1024,
4890 ($drive->{mbps_rd_max} || 0)*1024*1024,
4891 ($drive->{mbps_wr_max} || 0)*1024*1024,
4892 $drive->{iops_max} || 0,
4893 $drive->{iops_rd_max} || 0,
4894 $drive->{iops_wr_max} || 0,
4895 $drive->{bps_max_length} || 1,
4896 $drive->{bps_rd_max_length} || 1,
4897 $drive->{bps_wr_max_length} || 1,
4898 $drive->{iops_max_length} || 1,
4899 $drive->{iops_rd_max_length} || 1,
4900 $drive->{iops_wr_max_length} || 1,
4910 if ($drive->{file} eq 'none
') {
4911 mon_cmd($vmid, "eject", force => JSON::true, id => "$opt");
4912 if (drive_is_cloudinit($old_drive)) {
4913 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive);
4916 my $path = get_iso_path($storecfg, $vmid, $drive->{file});
4918 # force eject if locked
4919 mon_cmd($vmid, "eject", force => JSON::true, id => "$opt");
4922 mon_cmd($vmid, "blockdev-change-medium",
4923 id => "$opt", filename => "$path");
4931 die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
4933 PVE::Storage::activate_volumes($storecfg, [$drive->{file}]) if $drive->{file} !~ m|^/dev/.+|;
4934 vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive, $arch, $machine_type);
4937 # called in locked context by incoming migration
4938 sub vm_migrate_get_nbd_disks {
4939 my ($storecfg, $conf, $replicated_volumes) = @_;
4941 my $local_volumes = {};
4942 PVE::QemuConfig->foreach_volume($conf, sub {
4943 my ($ds, $drive) = @_;
4945 return if drive_is_cdrom($drive);
4947 my $volid = $drive->{file};
4951 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
4953 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4954 return if $scfg->{shared};
4956 # replicated disks re-use existing state via bitmap
4957 my $use_existing = $replicated_volumes->{$volid} ? 1 : 0;
4958 $local_volumes->{$ds} = [$volid, $storeid, $volname, $drive, $use_existing];
4960 return $local_volumes;
4963 # called in locked context by incoming migration
4964 sub vm_migrate_alloc_nbd_disks {
4965 my ($storecfg, $vmid, $source_volumes, $storagemap) = @_;
4970 foreach my $opt (sort keys %$source_volumes) {
4971 my ($volid, $storeid, $volname, $drive, $use_existing) = @{$source_volumes->{$opt}};
4973 if ($use_existing) {
4974 $nbd->{$opt}->{drivestr} = print_drive($drive);
4975 $nbd->{$opt}->{volid} = $volid;
4976 $nbd->{$opt}->{replicated} = 1;
4980 # If a remote storage is specified and the format of the original
4981 # volume is not available there, fall back to the default format.
4982 # Otherwise use the same format as the original.
4983 if (!$storagemap->{identity}) {
4984 $storeid = map_storage($storagemap, $storeid);
4985 my ($defFormat, $validFormats) = PVE::Storage::storage_default_format($storecfg, $storeid);
4986 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4987 my $fileFormat = qemu_img_format($scfg, $volname);
4988 $format = (grep {$fileFormat eq $_} @{$validFormats}) ? $fileFormat : $defFormat;
4990 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4991 $format = qemu_img_format($scfg, $volname);
4994 my $size = $drive->{size} / 1024;
4995 my $newvolid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $format, undef, $size);
4996 my $newdrive = $drive;
4997 $newdrive->{format} = $format;
4998 $newdrive->{file} = $newvolid;
4999 my $drivestr = print_drive($newdrive);
5000 $nbd->{$opt}->{drivestr} = $drivestr;
5001 $nbd->{$opt}->{volid} = $newvolid;
5007 # see vm_start_nolock for parameters, additionally:
5009 # storagemap = parsed storage map for allocating NBD disks
5011 my ($storecfg, $vmid, $params, $migrate_opts) = @_;
5013 return PVE::QemuConfig->lock_config($vmid, sub {
5014 my $conf = PVE::QemuConfig->load_config($vmid, $migrate_opts->{migratedfrom});
5016 die "you can't start a vm
if it
's a template\n"
5017 if !$params->{skiptemplate} && PVE::QemuConfig->is_template($conf);
5019 my $has_suspended_lock = PVE::QemuConfig->has_lock($conf, 'suspended
');
5020 my $has_backup_lock = PVE::QemuConfig->has_lock($conf, 'backup
');
5022 my $running = check_running($vmid, undef, $migrate_opts->{migratedfrom});
5024 if ($has_backup_lock && $running) {
5025 # a backup is currently running, attempt to start the guest in the
5026 # existing QEMU instance
5027 return vm_resume($vmid);
5030 PVE::QemuConfig->check_lock($conf)
5031 if !($params->{skiplock} || $has_suspended_lock);
5033 $params->{resume} = $has_suspended_lock || defined($conf->{vmstate});
5035 die "VM $vmid already running\n" if $running;
5037 if (my $storagemap = $migrate_opts->{storagemap}) {
5038 my $replicated = $migrate_opts->{replicated_volumes};
5039 my $disks = vm_migrate_get_nbd_disks($storecfg, $conf, $replicated);
5040 $migrate_opts->{nbd} = vm_migrate_alloc_nbd_disks($storecfg, $vmid, $disks, $storagemap);
5042 foreach my $opt (keys %{$migrate_opts->{nbd}}) {
5043 $conf->{$opt} = $migrate_opts->{nbd}->{$opt}->{drivestr};
5047 return vm_start_nolock($storecfg, $vmid, $conf, $params, $migrate_opts);
5053 # statefile => 'tcp
', 'unix
' for migration or path/volid for RAM state
5054 # skiplock => 0/1, skip checking for config lock
5055 # skiptemplate => 0/1, skip checking whether VM is template
5056 # forcemachine => to force Qemu machine (rollback/migration)
5057 # forcecpu => a QEMU '-cpu
' argument string to override get_cpu_options
5058 # timeout => in seconds
5059 # paused => start VM in paused state (backup)
5060 # resume => resume from hibernation
5071 # nbd => volumes for NBD exports (vm_migrate_alloc_nbd_disks)
5072 # migratedfrom => source node
5073 # spice_ticket => used for spice migration, passed via tunnel/stdin
5074 # network => CIDR of migration network
5075 # type => secure/insecure - tunnel over encrypted connection or plain-text
5076 # nbd_proto_version => int, 0 for TCP, 1 for UNIX
5077 # replicated_volumes = which volids should be re-used with bitmaps for nbd migration
5078 sub vm_start_nolock {
5079 my ($storecfg, $vmid, $conf, $params, $migrate_opts) = @_;
5081 my $statefile = $params->{statefile};
5082 my $resume = $params->{resume};
5084 my $migratedfrom = $migrate_opts->{migratedfrom};
5085 my $migration_type = $migrate_opts->{type};
5089 # clean up leftover reboot request files
5090 eval { clear_reboot_request($vmid); };
5093 if (!$statefile && scalar(keys %{$conf->{pending}})) {
5094 vmconfig_apply_pending($vmid, $conf, $storecfg);
5095 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
5098 PVE::QemuServer::Cloudinit::generate_cloudinitconfig($conf, $vmid);
5100 my $defaults = load_defaults();
5102 # set environment variable useful inside network script
5103 $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
5105 PVE::GuestHelpers::exec_hookscript($conf, $vmid, 'pre-start
', 1);
5107 my $forcemachine = $params->{forcemachine};
5108 my $forcecpu = $params->{forcecpu};
5110 # enforce machine and CPU type on suspended vm to ensure HW compatibility
5111 $forcemachine = $conf->{runningmachine};
5112 $forcecpu = $conf->{runningcpu};
5113 print "Resuming suspended VM\n";
5116 my ($cmd, $vollist, $spice_port) = config_to_command($storecfg, $vmid,
5117 $conf, $defaults, $forcemachine, $forcecpu, $params->{'pbs-backing
'});
5120 my $get_migration_ip = sub {
5121 my ($nodename) = @_;
5123 return $migration_ip if defined($migration_ip);
5125 my $cidr = $migrate_opts->{network};
5127 if (!defined($cidr)) {
5128 my $dc_conf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
5129 $cidr = $dc_conf->{migration}->{network};
5132 if (defined($cidr)) {
5133 my $ips = PVE::Network::get_local_ip_from_cidr($cidr);
5135 die "could not get IP: no address configured on local " .
5136 "node for network '$cidr'\n" if scalar(@$ips) == 0;
5138 die "could not get IP: multiple addresses configured on local " .
5139 "node for network '$cidr'\n" if scalar(@$ips) > 1;
5141 $migration_ip = @$ips[0];
5144 $migration_ip = PVE::Cluster::remote_node_ip($nodename, 1)
5145 if !defined($migration_ip);
5147 return $migration_ip;
5152 if ($statefile eq 'tcp
') {
5153 my $localip = "localhost";
5154 my $datacenterconf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
5155 my $nodename = nodename();
5157 if (!defined($migration_type)) {
5158 if (defined($datacenterconf->{migration}->{type})) {
5159 $migration_type = $datacenterconf->{migration}->{type};
5161 $migration_type = 'secure
';
5165 if ($migration_type eq 'insecure
') {
5166 $localip = $get_migration_ip->($nodename);
5167 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
5170 my $pfamily = PVE::Tools::get_host_address_family($nodename);
5171 my $migrate_port = PVE::Tools::next_migrate_port($pfamily);
5172 $migrate_uri = "tcp:${localip}:${migrate_port}";
5173 push @$cmd, '-incoming
', $migrate_uri;
5176 } elsif ($statefile eq 'unix
') {
5177 # should be default for secure migrations as a ssh TCP forward
5178 # tunnel is not deterministic reliable ready and fails regurarly
5179 # to set up in time, so use UNIX socket forwards
5180 my $socket_addr = "/run/qemu-server/$vmid.migrate";
5181 unlink $socket_addr;
5183 $migrate_uri = "unix:$socket_addr";
5185 push @$cmd, '-incoming
', $migrate_uri;
5188 } elsif (-e $statefile) {
5189 push @$cmd, '-loadstate
', $statefile;
5191 my $statepath = PVE::Storage::path($storecfg, $statefile);
5192 push @$vollist, $statefile;
5193 push @$cmd, '-loadstate
', $statepath;
5195 } elsif ($params->{paused}) {
5200 for (my $i = 0; $i < $PVE::QemuServer::PCI::MAX_HOSTPCI_DEVICES; $i++) {
5201 my $d = parse_hostpci($conf->{"hostpci$i"});
5203 my $pcidevices = $d->{pciid};
5204 foreach my $pcidevice (@$pcidevices) {
5205 my $pciid = $pcidevice->{id};
5207 my $info = PVE::SysFSTools::pci_device_info("$pciid");
5208 die "IOMMU not present\n" if !PVE::SysFSTools::check_iommu_support();
5209 die "no pci device info for device '$pciid'\n" if !$info;
5212 my $uuid = PVE::SysFSTools::generate_mdev_uuid($vmid, $i);
5213 PVE::SysFSTools::pci_create_mdev_device($pciid, $uuid, $d->{mdev});
5215 die "can't unbind
/bind PCI group to VFIO
'$pciid'\n"
5216 if !PVE::SysFSTools::pci_dev_group_bind_to_vfio($pciid);
5217 die "can
't reset PCI device '$pciid'\n"
5218 if $info->{has_fl_reset} && !PVE::SysFSTools::pci_dev_reset($info);
5223 PVE::Storage::activate_volumes($storecfg, $vollist);
5226 run_command(['/bin/systemctl
', 'stop
', "$vmid.scope"],
5227 outfunc => sub {}, errfunc => sub {});
5229 # Issues with the above 'stop
' not being fully completed are extremely rare, a very low
5230 # timeout should be more than enough here...
5231 PVE::Systemd::wait_for_unit_removed("$vmid.scope", 5);
5233 my $cpuunits = defined($conf->{cpuunits}) ? $conf->{cpuunits}
5234 : $defaults->{cpuunits};
5236 my $start_timeout = $params->{timeout} // config_aware_timeout($conf, $resume);
5238 timeout => $statefile ? undef : $start_timeout,
5243 # when migrating, prefix QEMU output so other side can pick up any
5244 # errors that might occur and show the user
5245 if ($migratedfrom) {
5246 $run_params{quiet} = 1;
5247 $run_params{logfunc} = sub { print "QEMU: $_[0]\n" };
5251 Slice => 'qemu
.slice
',
5255 if (PVE::CGroup::cgroup_mode() == 2) {
5256 $properties{CPUWeight} = $cpuunits;
5258 $properties{CPUShares} = $cpuunits;
5261 if (my $cpulimit = $conf->{cpulimit}) {
5262 $properties{CPUQuota} = int($cpulimit * 100);
5264 $properties{timeout} = 10 if $statefile; # setting up the scope shoul be quick
5266 my $run_qemu = sub {
5267 PVE::Tools::run_fork sub {
5268 PVE::Systemd::enter_systemd_scope($vmid, "Proxmox VE VM $vmid", %properties);
5270 my $exitcode = run_command($cmd, %run_params);
5271 die "QEMU exited with code $exitcode\n" if $exitcode;
5275 if ($conf->{hugepages}) {
5278 my $hugepages_topology = PVE::QemuServer::Memory::hugepages_topology($conf);
5279 my $hugepages_host_topology = PVE::QemuServer::Memory::hugepages_host_topology();
5281 PVE::QemuServer::Memory::hugepages_mount();
5282 PVE::QemuServer::Memory::hugepages_allocate($hugepages_topology, $hugepages_host_topology);
5284 eval { $run_qemu->() };
5286 PVE::QemuServer::Memory::hugepages_reset($hugepages_host_topology)
5287 if !$conf->{keephugepages};
5291 PVE::QemuServer::Memory::hugepages_pre_deallocate($hugepages_topology)
5292 if !$conf->{keephugepages};
5294 eval { PVE::QemuServer::Memory::hugepages_update_locked($code); };
5297 eval { $run_qemu->() };
5301 # deactivate volumes if start fails
5302 eval { PVE::Storage::deactivate_volumes($storecfg, $vollist); };
5303 die "start failed: $err";
5306 print "migration listens on $migrate_uri\n" if $migrate_uri;
5307 $res->{migrate_uri} = $migrate_uri;
5309 if ($statefile && $statefile ne 'tcp
' && $statefile ne 'unix
') {
5310 eval { mon_cmd($vmid, "cont"); };
5314 #start nbd server for storage migration
5315 if (my $nbd = $migrate_opts->{nbd}) {
5316 my $nbd_protocol_version = $migrate_opts->{nbd_proto_version} // 0;
5318 my $migrate_storage_uri;
5319 # nbd_protocol_version > 0 for unix socket support
5320 if ($nbd_protocol_version > 0 && $migration_type eq 'secure
') {
5321 my $socket_path = "/run/qemu-server/$vmid\_nbd.migrate";
5322 mon_cmd($vmid, "nbd-server-start", addr => { type => 'unix
', data => { path => $socket_path } } );
5323 $migrate_storage_uri = "nbd:unix:$socket_path";
5325 my $nodename = nodename();
5326 my $localip = $get_migration_ip->($nodename);
5327 my $pfamily = PVE::Tools::get_host_address_family($nodename);
5328 my $storage_migrate_port = PVE::Tools::next_migrate_port($pfamily);
5330 mon_cmd($vmid, "nbd-server-start", addr => {
5333 host => "${localip}",
5334 port => "${storage_migrate_port}",
5337 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
5338 $migrate_storage_uri = "nbd:${localip}:${storage_migrate_port}";
5341 $res->{migrate_storage_uri} = $migrate_storage_uri;
5343 foreach my $opt (sort keys %$nbd) {
5344 my $drivestr = $nbd->{$opt}->{drivestr};
5345 my $volid = $nbd->{$opt}->{volid};
5346 mon_cmd($vmid, "nbd-server-add", device => "drive-$opt", writable => JSON::true );
5347 my $nbd_uri = "$migrate_storage_uri:exportname=drive-$opt";
5348 print "storage migration listens on $nbd_uri volume:$drivestr\n";
5349 print "re-using replicated volume: $opt - $volid\n"
5350 if $nbd->{$opt}->{replicated};
5352 $res->{drives}->{$opt} = $nbd->{$opt};
5353 $res->{drives}->{$opt}->{nbd_uri} = $nbd_uri;
5357 if ($migratedfrom) {
5359 set_migration_caps($vmid);
5364 print "spice listens on port $spice_port\n";
5365 $res->{spice_port} = $spice_port;
5366 if ($migrate_opts->{spice_ticket}) {
5367 mon_cmd($vmid, "set_password", protocol => 'spice
', password =>
5368 $migrate_opts->{spice_ticket});
5369 mon_cmd($vmid, "expire_password", protocol => 'spice
', time => "+30");
5374 mon_cmd($vmid, "balloon", value => $conf->{balloon}*1024*1024)
5375 if !$statefile && $conf->{balloon};
5377 foreach my $opt (keys %$conf) {
5378 next if $opt !~ m/^net\d+$/;
5379 my $nicconf = parse_net($conf->{$opt});
5380 qemu_set_link_status($vmid, $opt, 0) if $nicconf->{link_down};
5384 mon_cmd($vmid, 'qom-set
',
5385 path => "machine/peripheral/balloon0",
5386 property => "guest-stats-polling-interval",
5387 value => 2) if (!defined($conf->{balloon}) || $conf->{balloon});
5390 print "Resumed VM, removing state\n";
5391 if (my $vmstate = $conf->{vmstate}) {
5392 PVE::Storage::deactivate_volumes($storecfg, [$vmstate]);
5393 PVE::Storage::vdisk_free($storecfg, $vmstate);
5395 delete $conf->@{qw(lock vmstate runningmachine runningcpu)};
5396 PVE
::QemuConfig-
>write_config($vmid, $conf);
5399 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'post-start');
5404 sub vm_commandline
{
5405 my ($storecfg, $vmid, $snapname) = @_;
5407 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5412 my $snapshot = $conf->{snapshots
}->{$snapname};
5413 die "snapshot '$snapname' does not exist\n" if !defined($snapshot);
5415 # check for machine or CPU overrides in snapshot
5416 $forcemachine = $snapshot->{runningmachine
};
5417 $forcecpu = $snapshot->{runningcpu
};
5419 $snapshot->{digest
} = $conf->{digest
}; # keep file digest for API
5424 my $defaults = load_defaults
();
5426 my $cmd = config_to_command
($storecfg, $vmid, $conf, $defaults,
5427 $forcemachine, $forcecpu);
5429 return PVE
::Tools
::cmd2string
($cmd);
5433 my ($vmid, $skiplock) = @_;
5435 PVE
::QemuConfig-
>lock_config($vmid, sub {
5437 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5439 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5441 mon_cmd
($vmid, "system_reset");
5445 sub get_vm_volumes
{
5449 foreach_volid
($conf, sub {
5450 my ($volid, $attr) = @_;
5452 return if $volid =~ m
|^/|;
5454 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
5457 push @$vollist, $volid;
5463 sub vm_stop_cleanup
{
5464 my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
5469 my $vollist = get_vm_volumes
($conf);
5470 PVE
::Storage
::deactivate_volumes
($storecfg, $vollist);
5473 foreach my $ext (qw(mon qmp pid vnc qga)) {
5474 unlink "/var/run/qemu-server/${vmid}.$ext";
5477 if ($conf->{ivshmem
}) {
5478 my $ivshmem = parse_property_string
($ivshmem_fmt, $conf->{ivshmem
});
5479 # just delete it for now, VMs which have this already open do not
5480 # are affected, but new VMs will get a separated one. If this
5481 # becomes an issue we either add some sort of ref-counting or just
5482 # add a "don't delete on stop" flag to the ivshmem format.
5483 unlink '/dev/shm/pve-shm-' . ($ivshmem->{name
} // $vmid);
5486 foreach my $key (keys %$conf) {
5487 next if $key !~ m/^hostpci(\d+)$/;
5488 my $hostpciindex = $1;
5489 my $d = parse_hostpci
($conf->{$key});
5490 my $uuid = PVE
::SysFSTools
::generate_mdev_uuid
($vmid, $hostpciindex);
5492 foreach my $pci (@{$d->{pciid
}}) {
5493 my $pciid = $pci->{id
};
5494 PVE
::SysFSTools
::pci_cleanup_mdev_device
($pciid, $uuid);
5498 vmconfig_apply_pending
($vmid, $conf, $storecfg) if $apply_pending_changes;
5500 warn $@ if $@; # avoid errors - just warn
5503 # call only in locked context
5505 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive) = @_;
5507 my $pid = check_running
($vmid, $nocheck);
5512 $conf = PVE
::QemuConfig-
>load_config($vmid);
5513 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
5514 if (!defined($timeout) && $shutdown && $conf->{startup
}) {
5515 my $opts = PVE
::JSONSchema
::pve_parse_startup_order
($conf->{startup
});
5516 $timeout = $opts->{down
} if $opts->{down
};
5518 PVE
::GuestHelpers
::exec_hookscript
($conf, $vmid, 'pre-stop');
5523 if (defined($conf) && get_qga_key
($conf, 'enabled')) {
5524 mon_cmd
($vmid, "guest-shutdown", timeout
=> $timeout);
5526 mon_cmd
($vmid, "system_powerdown");
5529 mon_cmd
($vmid, "quit");
5535 $timeout = 60 if !defined($timeout);
5538 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5543 if ($count >= $timeout) {
5545 warn "VM still running - terminating now with SIGTERM\n";
5548 die "VM quit/powerdown failed - got timeout\n";
5551 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5555 if (!check_running
($vmid, $nocheck)) {
5556 warn "Unexpected: VM shutdown command failed, but VM not running anymore..\n";
5560 warn "VM quit/powerdown failed - terminating now with SIGTERM\n";
5563 die "VM quit/powerdown failed\n";
5571 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
5576 if ($count >= $timeout) {
5577 warn "VM still running - terminating now with SIGKILL\n";
5582 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
5585 # Note: use $nocheck to skip tests if VM configuration file exists.
5586 # We need that when migration VMs to other nodes (files already moved)
5587 # Note: we set $keepActive in vzdump stop mode - volumes need to stay active
5589 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
5591 $force = 1 if !defined($force) && !$shutdown;
5594 my $pid = check_running
($vmid, $nocheck, $migratedfrom);
5595 kill 15, $pid if $pid;
5596 my $conf = PVE
::QemuConfig-
>load_config($vmid, $migratedfrom);
5597 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 0);
5601 PVE
::QemuConfig-
>lock_config($vmid, sub {
5602 _do_vm_stop
($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive);
5607 my ($vmid, $timeout) = @_;
5609 PVE
::QemuConfig-
>lock_config($vmid, sub {
5612 # only reboot if running, as qmeventd starts it again on a stop event
5613 return if !check_running
($vmid);
5615 create_reboot_request
($vmid);
5617 my $storecfg = PVE
::Storage
::config
();
5618 _do_vm_stop
($storecfg, $vmid, undef, undef, $timeout, 1);
5622 # avoid that the next normal shutdown will be confused for a reboot
5623 clear_reboot_request
($vmid);
5629 # note: if using the statestorage parameter, the caller has to check privileges
5631 my ($vmid, $skiplock, $includestate, $statestorage) = @_;
5638 PVE
::QemuConfig-
>lock_config($vmid, sub {
5640 $conf = PVE
::QemuConfig-
>load_config($vmid);
5642 my $is_backing_up = PVE
::QemuConfig-
>has_lock($conf, 'backup');
5643 PVE
::QemuConfig-
>check_lock($conf)
5644 if !($skiplock || $is_backing_up);
5646 die "cannot suspend to disk during backup\n"
5647 if $is_backing_up && $includestate;
5649 if ($includestate) {
5650 $conf->{lock} = 'suspending';
5651 my $date = strftime
("%Y-%m-%d", localtime(time()));
5652 $storecfg = PVE
::Storage
::config
();
5653 if (!$statestorage) {
5654 $statestorage = find_vmstate_storage
($conf, $storecfg);
5655 # check permissions for the storage
5656 my $rpcenv = PVE
::RPCEnvironment
::get
();
5657 if ($rpcenv->{type
} ne 'cli') {
5658 my $authuser = $rpcenv->get_user();
5659 $rpcenv->check($authuser, "/storage/$statestorage", ['Datastore.AllocateSpace']);
5664 $vmstate = PVE
::QemuConfig-
>__snapshot_save_vmstate(
5665 $vmid, $conf, "suspend-$date", $storecfg, $statestorage, 1);
5666 $path = PVE
::Storage
::path
($storecfg, $vmstate);
5667 PVE
::QemuConfig-
>write_config($vmid, $conf);
5669 mon_cmd
($vmid, "stop");
5673 if ($includestate) {
5675 PVE
::Storage
::activate_volumes
($storecfg, [$vmstate]);
5678 set_migration_caps
($vmid, 1);
5679 mon_cmd
($vmid, "savevm-start", statefile
=> $path);
5681 my $state = mon_cmd
($vmid, "query-savevm");
5682 if (!$state->{status
}) {
5683 die "savevm not active\n";
5684 } elsif ($state->{status
} eq 'active') {
5687 } elsif ($state->{status
} eq 'completed') {
5688 print "State saved, quitting\n";
5690 } elsif ($state->{status
} eq 'failed' && $state->{error
}) {
5691 die "query-savevm failed with error '$state->{error}'\n"
5693 die "query-savevm returned status '$state->{status}'\n";
5699 PVE
::QemuConfig-
>lock_config($vmid, sub {
5700 $conf = PVE
::QemuConfig-
>load_config($vmid);
5702 # cleanup, but leave suspending lock, to indicate something went wrong
5704 mon_cmd
($vmid, "savevm-end");
5705 PVE
::Storage
::deactivate_volumes
($storecfg, [$vmstate]);
5706 PVE
::Storage
::vdisk_free
($storecfg, $vmstate);
5707 delete $conf->@{qw(vmstate runningmachine runningcpu)};
5708 PVE
::QemuConfig-
>write_config($vmid, $conf);
5714 die "lock changed unexpectedly\n"
5715 if !PVE
::QemuConfig-
>has_lock($conf, 'suspending');
5717 mon_cmd
($vmid, "quit");
5718 $conf->{lock} = 'suspended';
5719 PVE
::QemuConfig-
>write_config($vmid, $conf);
5725 my ($vmid, $skiplock, $nocheck) = @_;
5727 PVE
::QemuConfig-
>lock_config($vmid, sub {
5728 my $res = mon_cmd
($vmid, 'query-status');
5729 my $resume_cmd = 'cont';
5732 if ($res->{status
}) {
5733 return if $res->{status
} eq 'running'; # job done, go home
5734 $resume_cmd = 'system_wakeup' if $res->{status
} eq 'suspended';
5735 $reset = 1 if $res->{status
} eq 'shutdown';
5740 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5742 PVE
::QemuConfig-
>check_lock($conf)
5743 if !($skiplock || PVE
::QemuConfig-
>has_lock($conf, 'backup'));
5747 # required if a VM shuts down during a backup and we get a resume
5748 # request before the backup finishes for example
5749 mon_cmd
($vmid, "system_reset");
5751 mon_cmd
($vmid, $resume_cmd);
5756 my ($vmid, $skiplock, $key) = @_;
5758 PVE
::QemuConfig-
>lock_config($vmid, sub {
5760 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5762 # there is no qmp command, so we use the human monitor command
5763 my $res = PVE
::QemuServer
::Monitor
::hmp_cmd
($vmid, "sendkey $key");
5764 die $res if $res ne '';
5768 # vzdump restore implementaion
5770 sub tar_archive_read_firstfile
{
5771 my $archive = shift;
5773 die "ERROR: file '$archive' does not exist\n" if ! -f
$archive;
5775 # try to detect archive type first
5776 my $pid = open (my $fh, '-|', 'tar', 'tf', $archive) ||
5777 die "unable to open file '$archive'\n";
5778 my $firstfile = <$fh>;
5782 die "ERROR: archive contaions no data\n" if !$firstfile;
5788 sub tar_restore_cleanup
{
5789 my ($storecfg, $statfile) = @_;
5791 print STDERR
"starting cleanup\n";
5793 if (my $fd = IO
::File-
>new($statfile, "r")) {
5794 while (defined(my $line = <$fd>)) {
5795 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
5798 if ($volid =~ m
|^/|) {
5799 unlink $volid || die 'unlink failed\n';
5801 PVE
::Storage
::vdisk_free
($storecfg, $volid);
5803 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
5805 print STDERR
"unable to cleanup '$volid' - $@" if $@;
5807 print STDERR
"unable to parse line in statfile - $line";
5814 sub restore_file_archive
{
5815 my ($archive, $vmid, $user, $opts) = @_;
5817 return restore_vma_archive
($archive, $vmid, $user, $opts)
5820 my $info = PVE
::Storage
::archive_info
($archive);
5821 my $format = $opts->{format
} // $info->{format
};
5822 my $comp = $info->{compression
};
5824 # try to detect archive format
5825 if ($format eq 'tar') {
5826 return restore_tar_archive
($archive, $vmid, $user, $opts);
5828 return restore_vma_archive
($archive, $vmid, $user, $opts, $comp);
5832 # hepler to remove disks that will not be used after restore
5833 my $restore_cleanup_oldconf = sub {
5834 my ($storecfg, $vmid, $oldconf, $virtdev_hash) = @_;
5836 PVE
::QemuConfig-
>foreach_volume($oldconf, sub {
5837 my ($ds, $drive) = @_;
5839 return if drive_is_cdrom
($drive, 1);
5841 my $volid = $drive->{file
};
5842 return if !$volid || $volid =~ m
|^/|;
5844 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
5845 return if !$path || !$owner || ($owner != $vmid);
5847 # Note: only delete disk we want to restore
5848 # other volumes will become unused
5849 if ($virtdev_hash->{$ds}) {
5850 eval { PVE
::Storage
::vdisk_free
($storecfg, $volid); };
5857 # delete vmstate files, after the restore we have no snapshots anymore
5858 foreach my $snapname (keys %{$oldconf->{snapshots
}}) {
5859 my $snap = $oldconf->{snapshots
}->{$snapname};
5860 if ($snap->{vmstate
}) {
5861 eval { PVE
::Storage
::vdisk_free
($storecfg, $snap->{vmstate
}); };
5869 # Helper to parse vzdump backup device hints
5871 # $rpcenv: Environment, used to ckeck storage permissions
5872 # $user: User ID, to check storage permissions
5873 # $storecfg: Storage configuration
5874 # $fh: the file handle for reading the configuration
5875 # $devinfo: should contain device sizes for all backu-up'ed devices
5876 # $options: backup options (pool, default storage)
5878 # Return: $virtdev_hash, updates $devinfo (add devname, virtdev, format, storeid)
5879 my $parse_backup_hints = sub {
5880 my ($rpcenv, $user, $storecfg, $fh, $devinfo, $options) = @_;
5882 my $virtdev_hash = {};
5884 while (defined(my $line = <$fh>)) {
5885 if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
5886 my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
5887 die "archive does not contain data for drive '$virtdev'\n"
5888 if !$devinfo->{$devname};
5890 if (defined($options->{storage
})) {
5891 $storeid = $options->{storage
} || 'local';
5892 } elsif (!$storeid) {
5895 $format = 'raw' if !$format;
5896 $devinfo->{$devname}->{devname
} = $devname;
5897 $devinfo->{$devname}->{virtdev
} = $virtdev;
5898 $devinfo->{$devname}->{format
} = $format;
5899 $devinfo->{$devname}->{storeid
} = $storeid;
5901 # check permission on storage
5902 my $pool = $options->{pool
}; # todo: do we need that?
5903 if ($user ne 'root@pam') {
5904 $rpcenv->check($user, "/storage/$storeid", ['Datastore.AllocateSpace']);
5907 $virtdev_hash->{$virtdev} = $devinfo->{$devname};
5908 } elsif ($line =~ m/^((?:ide|sata|scsi)\d+):\s*(.*)\s*$/) {
5910 my $drive = parse_drive
($virtdev, $2);
5911 if (drive_is_cloudinit
($drive)) {
5912 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
5913 $storeid = $options->{storage
} if defined ($options->{storage
});
5914 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5915 my $format = qemu_img_format
($scfg, $volname); # has 'raw' fallback
5917 $virtdev_hash->{$virtdev} = {
5919 storeid
=> $storeid,
5920 size
=> PVE
::QemuServer
::Cloudinit
::CLOUDINIT_DISK_SIZE
,
5927 return $virtdev_hash;
5930 # Helper to allocate and activate all volumes required for a restore
5932 # $storecfg: Storage configuration
5933 # $virtdev_hash: as returned by parse_backup_hints()
5935 # Returns: { $virtdev => $volid }
5936 my $restore_allocate_devices = sub {
5937 my ($storecfg, $virtdev_hash, $vmid) = @_;
5940 foreach my $virtdev (sort keys %$virtdev_hash) {
5941 my $d = $virtdev_hash->{$virtdev};
5942 my $alloc_size = int(($d->{size
} + 1024 - 1)/1024);
5943 my $storeid = $d->{storeid
};
5944 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5946 # test if requested format is supported
5947 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
5948 my $supported = grep { $_ eq $d->{format
} } @$validFormats;
5949 $d->{format
} = $defFormat if !$supported;
5952 if ($d->{is_cloudinit
}) {
5953 $name = "vm-$vmid-cloudinit";
5954 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
5955 if ($scfg->{path
}) {
5956 $name .= ".$d->{format}";
5960 my $volid = PVE
::Storage
::vdisk_alloc
(
5961 $storecfg, $storeid, $vmid, $d->{format
}, $name, $alloc_size);
5963 print STDERR
"new volume ID is '$volid'\n";
5964 $d->{volid
} = $volid;
5966 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
5968 $map->{$virtdev} = $volid;
5974 my $restore_update_config_line = sub {
5975 my ($cookie, $vmid, $map, $line, $unique) = @_;
5977 return '' if $line =~ m/^\#qmdump\#/;
5978 return '' if $line =~ m/^\#vzdump\#/;
5979 return '' if $line =~ m/^lock:/;
5980 return '' if $line =~ m/^unused\d+:/;
5981 return '' if $line =~ m/^parent:/;
5985 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
5986 if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
5987 # try to convert old 1.X settings
5988 my ($id, $ind, $ethcfg) = ($1, $2, $3);
5989 foreach my $devconfig (PVE
::Tools
::split_list
($ethcfg)) {
5990 my ($model, $macaddr) = split(/\=/, $devconfig);
5991 $macaddr = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if !$macaddr || $unique;
5994 bridge
=> "vmbr$ind",
5995 macaddr
=> $macaddr,
5997 my $netstr = print_net
($net);
5999 $res .= "net$cookie->{netcount}: $netstr\n";
6000 $cookie->{netcount
}++;
6002 } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && $unique) {
6003 my ($id, $netstr) = ($1, $2);
6004 my $net = parse_net
($netstr);
6005 $net->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if $net->{macaddr
};
6006 $netstr = print_net
($net);
6007 $res .= "$id: $netstr\n";
6008 } elsif ($line =~ m/^((ide|scsi|virtio|sata|efidisk)\d+):\s*(\S+)\s*$/) {
6011 my $di = parse_drive
($virtdev, $value);
6012 if (defined($di->{backup
}) && !$di->{backup
}) {
6014 } elsif ($map->{$virtdev}) {
6015 delete $di->{format
}; # format can change on restore
6016 $di->{file
} = $map->{$virtdev};
6017 $value = print_drive
($di);
6018 $res .= "$virtdev: $value\n";
6022 } elsif (($line =~ m/^vmgenid: (.*)/)) {
6024 if ($vmgenid ne '0') {
6025 # always generate a new vmgenid if there was a valid one setup
6026 $vmgenid = generate_uuid
();
6028 $res .= "vmgenid: $vmgenid\n";
6029 } elsif (($line =~ m/^(smbios1: )(.*)/) && $unique) {
6030 my ($uuid, $uuid_str);
6031 UUID
::generate
($uuid);
6032 UUID
::unparse
($uuid, $uuid_str);
6033 my $smbios1 = parse_smbios1
($2);
6034 $smbios1->{uuid
} = $uuid_str;
6035 $res .= $1.print_smbios1
($smbios1)."\n";
6043 my $restore_deactivate_volumes = sub {
6044 my ($storecfg, $devinfo) = @_;
6047 foreach my $devname (keys %$devinfo) {
6048 my $volid = $devinfo->{$devname}->{volid
};
6049 push @$vollist, $volid if $volid;
6052 PVE
::Storage
::deactivate_volumes
($storecfg, $vollist);
6055 my $restore_destroy_volumes = sub {
6056 my ($storecfg, $devinfo) = @_;
6058 foreach my $devname (keys %$devinfo) {
6059 my $volid = $devinfo->{$devname}->{volid
};
6062 if ($volid =~ m
|^/|) {
6063 unlink $volid || die 'unlink failed\n';
6065 PVE
::Storage
::vdisk_free
($storecfg, $volid);
6067 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
6069 print STDERR
"unable to cleanup '$volid' - $@" if $@;
6073 # FIXME For PVE 7.0, remove $content_type and always use 'images'
6075 my ($cfg, $vmid, $content_type) = @_;
6077 my $info = PVE
::Storage
::vdisk_list
($cfg, undef, $vmid, undef, $content_type);
6079 my $volid_hash = {};
6080 foreach my $storeid (keys %$info) {
6081 foreach my $item (@{$info->{$storeid}}) {
6082 next if !($item->{volid
} && $item->{size
});
6083 $item->{path
} = PVE
::Storage
::path
($cfg, $item->{volid
});
6084 $volid_hash->{$item->{volid
}} = $item;
6091 sub update_disk_config
{
6092 my ($vmid, $conf, $volid_hash) = @_;
6095 my $prefix = "VM $vmid";
6097 # used and unused disks
6098 my $referenced = {};
6100 # Note: it is allowed to define multiple storages with same path (alias), so
6101 # we need to check both 'volid' and real 'path' (two different volid can point
6102 # to the same path).
6104 my $referencedpath = {};
6107 PVE
::QemuConfig-
>foreach_volume($conf, sub {
6108 my ($opt, $drive) = @_;
6110 my $volid = $drive->{file
};
6112 my $volume = $volid_hash->{$volid};
6114 # mark volid as "in-use" for next step
6115 $referenced->{$volid} = 1;
6116 if ($volume && (my $path = $volume->{path
})) {
6117 $referencedpath->{$path} = 1;
6120 return if drive_is_cdrom
($drive);
6123 my ($updated, $msg) = PVE
::QemuServer
::Drive
::update_disksize
($drive, $volume->{size
});
6124 if (defined($updated)) {
6126 $conf->{$opt} = print_drive
($updated);
6127 print "$prefix ($opt): $msg\n";
6131 # remove 'unusedX' entry if volume is used
6132 PVE
::QemuConfig-
>foreach_unused_volume($conf, sub {
6133 my ($opt, $drive) = @_;
6135 my $volid = $drive->{file
};
6139 $path = $volid_hash->{$volid}->{path
} if $volid_hash->{$volid};
6140 if ($referenced->{$volid} || ($path && $referencedpath->{$path})) {
6141 print "$prefix remove entry '$opt', its volume '$volid' is in use\n";
6143 delete $conf->{$opt};
6146 $referenced->{$volid} = 1;
6147 $referencedpath->{$path} = 1 if $path;
6150 foreach my $volid (sort keys %$volid_hash) {
6151 next if $volid =~ m/vm-$vmid-state-/;
6152 next if $referenced->{$volid};
6153 my $path = $volid_hash->{$volid}->{path
};
6154 next if !$path; # just to be sure
6155 next if $referencedpath->{$path};
6157 my $key = PVE
::QemuConfig-
>add_unused_volume($conf, $volid);
6158 print "$prefix add unreferenced volume '$volid' as '$key' to config\n";
6159 $referencedpath->{$path} = 1; # avoid to add more than once (aliases)
6166 my ($vmid, $nolock, $dryrun) = @_;
6168 my $cfg = PVE
::Storage
::config
();
6170 print "rescan volumes...\n";
6171 my $volid_hash = scan_volids
($cfg, $vmid, 'images');
6173 my $updatefn = sub {
6176 my $conf = PVE
::QemuConfig-
>load_config($vmid);
6178 PVE
::QemuConfig-
>check_lock($conf);
6181 foreach my $volid (keys %$volid_hash) {
6182 my $info = $volid_hash->{$volid};
6183 $vm_volids->{$volid} = $info if $info->{vmid
} && $info->{vmid
} == $vmid;
6186 my $changes = update_disk_config
($vmid, $conf, $vm_volids);
6188 PVE
::QemuConfig-
>write_config($vmid, $conf) if $changes && !$dryrun;
6191 if (defined($vmid)) {
6195 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
6198 my $vmlist = config_list
();
6199 foreach my $vmid (keys %$vmlist) {
6203 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
6209 sub restore_proxmox_backup_archive
{
6210 my ($archive, $vmid, $user, $options) = @_;
6212 my $storecfg = PVE
::Storage
::config
();
6214 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($archive);
6215 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
6217 my $fingerprint = $scfg->{fingerprint
};
6218 my $keyfile = PVE
::Storage
::PBSPlugin
::pbs_encryption_key_file_name
($storecfg, $storeid);
6220 my $repo = PVE
::PBSClient
::get_repository
($scfg);
6222 # This is only used for `pbs-restore` and the QEMU PBS driver (live-restore)
6223 my $password = PVE
::Storage
::PBSPlugin
::pbs_get_password
($scfg, $storeid);
6224 local $ENV{PBS_PASSWORD
} = $password;
6225 local $ENV{PBS_FINGERPRINT
} = $fingerprint if defined($fingerprint);
6227 my ($vtype, $pbs_backup_name, undef, undef, undef, undef, $format) =
6228 PVE
::Storage
::parse_volname
($storecfg, $archive);
6230 die "got unexpected vtype '$vtype'\n" if $vtype ne 'backup';
6232 die "got unexpected backup format '$format'\n" if $format ne 'pbs-vm';
6234 my $tmpdir = "/var/tmp/vzdumptmp$$";
6238 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6239 # disable interrupts (always do cleanups)
6243 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
6245 # Note: $oldconf is undef if VM does not exists
6246 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
6247 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
6248 my $new_conf_raw = '';
6250 my $rpcenv = PVE
::RPCEnvironment
::get
();
6259 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6261 my $cfgfn = "$tmpdir/qemu-server.conf";
6262 my $firewall_config_fn = "$tmpdir/fw.conf";
6263 my $index_fn = "$tmpdir/index.json";
6265 my $cmd = "restore";
6267 my $param = [$pbs_backup_name, "index.json", $index_fn];
6268 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
6269 my $index = PVE
::Tools
::file_get_contents
($index_fn);
6270 $index = decode_json
($index);
6272 # print Dumper($index);
6273 foreach my $info (@{$index->{files
}}) {
6274 if ($info->{filename
} =~ m/^(drive-\S+).img.fidx$/) {
6276 if ($info->{size
} =~ m/^(\d+)$/) { # untaint size
6277 $devinfo->{$devname}->{size
} = $1;
6279 die "unable to parse file size in 'index.json' - got '$info->{size}'\n";
6284 my $is_qemu_server_backup = scalar(
6285 grep { $_->{filename
} eq 'qemu-server.conf.blob' } @{$index->{files
}}
6287 if (!$is_qemu_server_backup) {
6288 die "backup does not look like a qemu-server backup (missing 'qemu-server.conf' file)\n";
6290 my $has_firewall_config = scalar(grep { $_->{filename
} eq 'fw.conf.blob' } @{$index->{files
}});
6292 $param = [$pbs_backup_name, "qemu-server.conf", $cfgfn];
6293 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
6295 if ($has_firewall_config) {
6296 $param = [$pbs_backup_name, "fw.conf", $firewall_config_fn];
6297 PVE
::Storage
::PBSPlugin
::run_raw_client_cmd
($scfg, $storeid, $cmd, $param);
6299 my $pve_firewall_dir = '/etc/pve/firewall';
6300 mkdir $pve_firewall_dir; # make sure the dir exists
6301 PVE
::Tools
::file_copy
($firewall_config_fn, "${pve_firewall_dir}/$vmid.fw");
6304 my $fh = IO
::File-
>new($cfgfn, "r") ||
6305 die "unable to read qemu-server.conf - $!\n";
6307 my $virtdev_hash = $parse_backup_hints->($rpcenv, $user, $storecfg, $fh, $devinfo, $options);
6309 # fixme: rate limit?
6311 # create empty/temp config
6312 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\nlock: create");
6314 $restore_cleanup_oldconf->($storecfg, $vmid, $oldconf, $virtdev_hash) if $oldconf;
6317 my $map = $restore_allocate_devices->($storecfg, $virtdev_hash, $vmid);
6319 if (!$options->{live
}) {
6320 foreach my $virtdev (sort keys %$virtdev_hash) {
6321 my $d = $virtdev_hash->{$virtdev};
6322 next if $d->{is_cloudinit
}; # no need to restore cloudinit
6324 my $volid = $d->{volid
};
6326 my $path = PVE
::Storage
::path
($storecfg, $volid);
6328 my $pbs_restore_cmd = [
6329 '/usr/bin/pbs-restore',
6330 '--repository', $repo,
6332 "$d->{devname}.img.fidx",
6337 push @$pbs_restore_cmd, '--format', $d->{format
} if $d->{format
};
6338 push @$pbs_restore_cmd, '--keyfile', $keyfile if -e
$keyfile;
6340 if (PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $volid)) {
6341 push @$pbs_restore_cmd, '--skip-zero';
6344 my $dbg_cmdstring = PVE
::Tools
::cmd2string
($pbs_restore_cmd);
6345 print "restore proxmox backup image: $dbg_cmdstring\n";
6346 run_command
($pbs_restore_cmd);
6350 $fh->seek(0, 0) || die "seek failed - $!\n";
6352 my $cookie = { netcount
=> 0 };
6353 while (defined(my $line = <$fh>)) {
6354 $new_conf_raw .= $restore_update_config_line->(
6367 if ($err || !$options->{live
}) {
6368 $restore_deactivate_volumes->($storecfg, $devinfo);
6374 $restore_destroy_volumes->($storecfg, $devinfo);
6378 PVE
::Tools
::file_set_contents
($conffile, $new_conf_raw);
6380 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6382 eval { rescan
($vmid, 1); };
6385 PVE
::AccessControl
::add_vm_to_pool
($vmid, $options->{pool
}) if $options->{pool
};
6387 if ($options->{live
}) {
6394 local $SIG{PIPE
} = sub { die "got signal ($!) - abort\n"; };
6396 my $conf = PVE
::QemuConfig-
>load_config($vmid);
6397 die "cannot do live-restore for template\n" if PVE
::QemuConfig-
>is_template($conf);
6399 pbs_live_restore
($vmid, $conf, $storecfg, $devinfo, $repo, $keyfile, $pbs_backup_name);
6404 warn "destroying partially live-restored VM, all temporary data will be lost!\n";
6405 $restore_deactivate_volumes->($storecfg, $devinfo);
6406 $restore_destroy_volumes->($storecfg, $devinfo);
6407 PVE
::QemuConfig-
>destroy_config($vmid);
6413 sub pbs_live_restore
{
6414 my ($vmid, $conf, $storecfg, $restored_disks, $repo, $keyfile, $snap) = @_;
6416 print "Starting VM for live-restore\n";
6418 my $pbs_backing = {};
6419 for my $ds (keys %$restored_disks) {
6420 $ds =~ m/^drive-(.*)$/;
6421 $pbs_backing->{$1} = {
6422 repository
=> $repo,
6424 archive
=> "$ds.img.fidx",
6426 $pbs_backing->{$1}->{keyfile
} = $keyfile if -e
$keyfile;
6429 my $drives_streamed = 0;
6431 # make sure HA doesn't interrupt our restore by stopping the VM
6432 if (PVE
::HA
::Config
::vm_is_ha_managed
($vmid)) {
6433 run_command
(['ha-manager', 'set', "vm:$vmid", '--state', 'started']);
6436 # start VM with backing chain pointing to PBS backup, environment vars for PBS driver
6437 # in QEMU (PBS_PASSWORD and PBS_FINGERPRINT) are already set by our caller
6438 vm_start_nolock
($storecfg, $vmid, $conf, {paused
=> 1, 'pbs-backing' => $pbs_backing}, {});
6440 my $qmeventd_fd = register_qmeventd_handle
($vmid);
6442 # begin streaming, i.e. data copy from PBS to target disk for every vol,
6443 # this will effectively collapse the backing image chain consisting of
6444 # [target <- alloc-track -> PBS snapshot] to just [target] (alloc-track
6445 # removes itself once all backing images vanish with 'auto-remove=on')
6447 for my $ds (sort keys %$restored_disks) {
6448 my $job_id = "restore-$ds";
6449 mon_cmd
($vmid, 'block-stream',
6450 'job-id' => $job_id,
6453 $jobs->{$job_id} = {};
6456 mon_cmd
($vmid, 'cont');
6457 qemu_drive_mirror_monitor
($vmid, undef, $jobs, 'auto', 0, 'stream');
6459 print "restore-drive jobs finished successfully, removing all tracking block devices"
6460 ." to disconnect from Proxmox Backup Server\n";
6462 for my $ds (sort keys %$restored_disks) {
6463 mon_cmd
($vmid, 'blockdev-del', 'node-name' => "$ds-pbs");
6466 close($qmeventd_fd);
6472 warn "An error occured during live-restore: $err\n";
6473 _do_vm_stop
($storecfg, $vmid, 1, 1, 10, 0, 1);
6474 die "live-restore failed\n";
6478 sub restore_vma_archive
{
6479 my ($archive, $vmid, $user, $opts, $comp) = @_;
6481 my $readfrom = $archive;
6483 my $cfg = PVE
::Storage
::config
();
6485 my $bwlimit = $opts->{bwlimit
};
6487 my $dbg_cmdstring = '';
6488 my $add_pipe = sub {
6490 push @$commands, $cmd;
6491 $dbg_cmdstring .= ' | ' if length($dbg_cmdstring);
6492 $dbg_cmdstring .= PVE
::Tools
::cmd2string
($cmd);
6497 if ($archive eq '-') {
6500 # If we use a backup from a PVE defined storage we also consider that
6501 # storage's rate limit:
6502 my (undef, $volid) = PVE
::Storage
::path_to_volume_id
($cfg, $archive);
6503 if (defined($volid)) {
6504 my ($sid, undef) = PVE
::Storage
::parse_volume_id
($volid);
6505 my $readlimit = PVE
::Storage
::get_bandwidth_limit
('restore', [$sid], $bwlimit);
6507 print STDERR
"applying read rate limit: $readlimit\n";
6508 my $cstream = ['cstream', '-t', $readlimit*1024, '--', $readfrom];
6509 $add_pipe->($cstream);
6515 my $info = PVE
::Storage
::decompressor_info
('vma', $comp);
6516 my $cmd = $info->{decompressor
};
6517 push @$cmd, $readfrom;
6521 my $tmpdir = "/var/tmp/vzdumptmp$$";
6524 # disable interrupts (always do cleanups)
6528 local $SIG{HUP
} = sub { warn "got interrupt - ignored\n"; };
6530 my $mapfifo = "/var/tmp/vzdumptmp$$.fifo";
6531 POSIX
::mkfifo
($mapfifo, 0600);
6533 my $openfifo = sub { open($fifofh, '>', $mapfifo) or die $! };
6535 $add_pipe->(['vma', 'extract', '-v', '-r', $mapfifo, $readfrom, $tmpdir]);
6542 my $rpcenv = PVE
::RPCEnvironment
::get
();
6544 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6546 # Note: $oldconf is undef if VM does not exist
6547 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
6548 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
6549 my $new_conf_raw = '';
6553 my $print_devmap = sub {
6554 my $cfgfn = "$tmpdir/qemu-server.conf";
6556 # we can read the config - that is already extracted
6557 my $fh = IO
::File-
>new($cfgfn, "r") ||
6558 die "unable to read qemu-server.conf - $!\n";
6560 my $fwcfgfn = "$tmpdir/qemu-server.fw";
6562 my $pve_firewall_dir = '/etc/pve/firewall';
6563 mkdir $pve_firewall_dir; # make sure the dir exists
6564 PVE
::Tools
::file_copy
($fwcfgfn, "${pve_firewall_dir}/$vmid.fw");
6567 my $virtdev_hash = $parse_backup_hints->($rpcenv, $user, $cfg, $fh, $devinfo, $opts);
6569 foreach my $info (values %{$virtdev_hash}) {
6570 my $storeid = $info->{storeid
};
6571 next if defined($storage_limits{$storeid});
6573 my $limit = PVE
::Storage
::get_bandwidth_limit
('restore', [$storeid], $bwlimit) // 0;
6574 print STDERR
"rate limit for storage $storeid: $limit KiB/s\n" if $limit;
6575 $storage_limits{$storeid} = $limit * 1024;
6578 foreach my $devname (keys %$devinfo) {
6579 die "found no device mapping information for device '$devname'\n"
6580 if !$devinfo->{$devname}->{virtdev
};
6583 # create empty/temp config
6585 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
6586 $restore_cleanup_oldconf->($cfg, $vmid, $oldconf, $virtdev_hash);
6590 my $map = $restore_allocate_devices->($cfg, $virtdev_hash, $vmid);
6592 # print restore information to $fifofh
6593 foreach my $virtdev (sort keys %$virtdev_hash) {
6594 my $d = $virtdev_hash->{$virtdev};
6595 next if $d->{is_cloudinit
}; # no need to restore cloudinit
6597 my $storeid = $d->{storeid
};
6598 my $volid = $d->{volid
};
6601 if (my $limit = $storage_limits{$storeid}) {
6602 $map_opts .= "throttling.bps=$limit:throttling.group=$storeid:";
6605 my $write_zeros = 1;
6606 if (PVE
::Storage
::volume_has_feature
($cfg, 'sparseinit', $volid)) {
6610 my $path = PVE
::Storage
::path
($cfg, $volid);
6612 print $fifofh "${map_opts}format=$d->{format}:${write_zeros}:$d->{devname}=$path\n";
6614 print "map '$d->{devname}' to '$path' (write zeros = ${write_zeros})\n";
6617 $fh->seek(0, 0) || die "seek failed - $!\n";
6619 my $cookie = { netcount
=> 0 };
6620 while (defined(my $line = <$fh>)) {
6621 $new_conf_raw .= $restore_update_config_line->(
6639 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6640 local $SIG{ALRM
} = sub { die "got timeout\n"; };
6642 $oldtimeout = alarm($timeout);
6649 if ($line =~ m/^DEV:\sdev_id=(\d+)\ssize:\s(\d+)\sdevname:\s(\S+)$/) {
6650 my ($dev_id, $size, $devname) = ($1, $2, $3);
6651 $devinfo->{$devname} = { size
=> $size, dev_id
=> $dev_id };
6652 } elsif ($line =~ m/^CTIME: /) {
6653 # we correctly received the vma config, so we can disable
6654 # the timeout now for disk allocation (set to 10 minutes, so
6655 # that we always timeout if something goes wrong)
6658 print $fifofh "done\n";
6659 my $tmp = $oldtimeout || 0;
6660 $oldtimeout = undef;
6667 print "restore vma archive: $dbg_cmdstring\n";
6668 run_command
($commands, input
=> $input, outfunc
=> $parser, afterfork
=> $openfifo);
6672 alarm($oldtimeout) if $oldtimeout;
6674 $restore_deactivate_volumes->($cfg, $devinfo);
6676 close($fifofh) if $fifofh;
6681 $restore_destroy_volumes->($cfg, $devinfo);
6685 PVE
::Tools
::file_set_contents
($conffile, $new_conf_raw);
6687 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6689 eval { rescan
($vmid, 1); };
6692 PVE
::AccessControl
::add_vm_to_pool
($vmid, $opts->{pool
}) if $opts->{pool
};
6695 sub restore_tar_archive
{
6696 my ($archive, $vmid, $user, $opts) = @_;
6698 if ($archive ne '-') {
6699 my $firstfile = tar_archive_read_firstfile
($archive);
6700 die "ERROR: file '$archive' does not look like a QemuServer vzdump backup\n"
6701 if $firstfile ne 'qemu-server.conf';
6704 my $storecfg = PVE
::Storage
::config
();
6706 # avoid zombie disks when restoring over an existing VM -> cleanup first
6707 # pass keep_empty_config=1 to keep the config (thus VMID) reserved for us
6708 # skiplock=1 because qmrestore has set the 'create' lock itself already
6709 my $vmcfgfn = PVE
::QemuConfig-
>config_file($vmid);
6710 destroy_vm
($storecfg, $vmid, 1, { lock => 'restore' }) if -f
$vmcfgfn;
6712 my $tocmd = "/usr/lib/qemu-server/qmextract";
6714 $tocmd .= " --storage " . PVE
::Tools
::shellquote
($opts->{storage
}) if $opts->{storage
};
6715 $tocmd .= " --pool " . PVE
::Tools
::shellquote
($opts->{pool
}) if $opts->{pool
};
6716 $tocmd .= ' --prealloc' if $opts->{prealloc
};
6717 $tocmd .= ' --info' if $opts->{info
};
6719 # tar option "xf" does not autodetect compression when read from STDIN,
6720 # so we pipe to zcat
6721 my $cmd = "zcat -f|tar xf " . PVE
::Tools
::shellquote
($archive) . " " .
6722 PVE
::Tools
::shellquote
("--to-command=$tocmd");
6724 my $tmpdir = "/var/tmp/vzdumptmp$$";
6727 local $ENV{VZDUMP_TMPDIR
} = $tmpdir;
6728 local $ENV{VZDUMP_VMID
} = $vmid;
6729 local $ENV{VZDUMP_USER
} = $user;
6731 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
6732 my $new_conf_raw = '';
6734 # disable interrupts (always do cleanups)
6738 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
6746 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
6748 if ($archive eq '-') {
6749 print "extracting archive from STDIN\n";
6750 run_command
($cmd, input
=> "<&STDIN");
6752 print "extracting archive '$archive'\n";
6756 return if $opts->{info
};
6760 my $statfile = "$tmpdir/qmrestore.stat";
6761 if (my $fd = IO
::File-
>new($statfile, "r")) {
6762 while (defined (my $line = <$fd>)) {
6763 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
6764 $map->{$1} = $2 if $1;
6766 print STDERR
"unable to parse line in statfile - $line\n";
6772 my $confsrc = "$tmpdir/qemu-server.conf";
6774 my $srcfd = IO
::File-
>new($confsrc, "r") || die "unable to open file '$confsrc'\n";
6776 my $cookie = { netcount
=> 0 };
6777 while (defined (my $line = <$srcfd>)) {
6778 $new_conf_raw .= $restore_update_config_line->(
6790 tar_restore_cleanup
($storecfg, "$tmpdir/qmrestore.stat") if !$opts->{info
};
6796 PVE
::Tools
::file_set_contents
($conffile, $new_conf_raw);
6798 PVE
::Cluster
::cfs_update
(); # make sure we read new file
6800 eval { rescan
($vmid, 1); };
6804 sub foreach_storage_used_by_vm
{
6805 my ($conf, $func) = @_;
6809 PVE
::QemuConfig-
>foreach_volume($conf, sub {
6810 my ($ds, $drive) = @_;
6811 return if drive_is_cdrom
($drive);
6813 my $volid = $drive->{file
};
6815 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
6816 $sidhash->{$sid} = $sid if $sid;
6819 foreach my $sid (sort keys %$sidhash) {
6824 my $qemu_snap_storage = {
6827 sub do_snapshots_with_qemu
{
6828 my ($storecfg, $volid) = @_;
6830 my $storage_name = PVE
::Storage
::parse_volume_id
($volid);
6831 my $scfg = $storecfg->{ids
}->{$storage_name};
6832 die "could not find storage '$storage_name'\n" if !defined($scfg);
6834 if ($qemu_snap_storage->{$scfg->{type
}} && !$scfg->{krbd
}){
6838 if ($volid =~ m/\.(qcow2|qed)$/){
6845 sub qga_check_running
{
6846 my ($vmid, $nowarn) = @_;
6848 eval { mon_cmd
($vmid, "guest-ping", timeout
=> 3); };
6850 warn "Qemu Guest Agent is not running - $@" if !$nowarn;
6856 sub template_create
{
6857 my ($vmid, $conf, $disk) = @_;
6859 my $storecfg = PVE
::Storage
::config
();
6861 PVE
::QemuConfig-
>foreach_volume($conf, sub {
6862 my ($ds, $drive) = @_;
6864 return if drive_is_cdrom
($drive);
6865 return if $disk && $ds ne $disk;
6867 my $volid = $drive->{file
};
6868 return if !PVE
::Storage
::volume_has_feature
($storecfg, 'template', $volid);
6870 my $voliddst = PVE
::Storage
::vdisk_create_base
($storecfg, $volid);
6871 $drive->{file
} = $voliddst;
6872 $conf->{$ds} = print_drive
($drive);
6873 PVE
::QemuConfig-
>write_config($vmid, $conf);
6877 sub convert_iscsi_path
{
6880 if ($path =~ m
|^iscsi
://([^/]+)/([^/]+)/(.+)$|) {
6885 my $initiator_name = get_initiator_name
();
6887 return "file.driver=iscsi,file.transport=tcp,file.initiator-name=$initiator_name,".
6888 "file.portal=$portal,file.target=$target,file.lun=$lun,driver=raw";
6891 die "cannot convert iscsi path '$path', unkown format\n";
6894 sub qemu_img_convert
{
6895 my ($src_volid, $dst_volid, $size, $snapname, $is_zero_initialized) = @_;
6897 my $storecfg = PVE
::Storage
::config
();
6898 my ($src_storeid, $src_volname) = PVE
::Storage
::parse_volume_id
($src_volid, 1);
6899 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid, 1);
6901 die "destination '$dst_volid' is not a valid volid form qemu-img convert\n" if !$dst_storeid;
6905 my $src_is_iscsi = 0;
6909 PVE
::Storage
::activate_volumes
($storecfg, [$src_volid], $snapname);
6910 my $src_scfg = PVE
::Storage
::storage_config
($storecfg, $src_storeid);
6911 $src_format = qemu_img_format
($src_scfg, $src_volname);
6912 $src_path = PVE
::Storage
::path
($storecfg, $src_volid, $snapname);
6913 $src_is_iscsi = ($src_path =~ m
|^iscsi
://|);
6914 $cachemode = 'none' if $src_scfg->{type
} eq 'zfspool';
6915 } elsif (-f
$src_volid) {
6916 $src_path = $src_volid;
6917 if ($src_path =~ m/\.($PVE::QemuServer::Drive::QEMU_FORMAT_RE)$/) {
6922 die "source '$src_volid' is not a valid volid nor path for qemu-img convert\n" if !$src_path;
6924 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
6925 my $dst_format = qemu_img_format
($dst_scfg, $dst_volname);
6926 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
6927 my $dst_is_iscsi = ($dst_path =~ m
|^iscsi
://|);
6930 push @$cmd, '/usr/bin/qemu-img', 'convert', '-p', '-n';
6931 push @$cmd, '-l', "snapshot.name=$snapname"
6932 if $snapname && $src_format && $src_format eq "qcow2";
6933 push @$cmd, '-t', 'none' if $dst_scfg->{type
} eq 'zfspool';
6934 push @$cmd, '-T', $cachemode if defined($cachemode);
6936 if ($src_is_iscsi) {
6937 push @$cmd, '--image-opts';
6938 $src_path = convert_iscsi_path
($src_path);
6939 } elsif ($src_format) {
6940 push @$cmd, '-f', $src_format;
6943 if ($dst_is_iscsi) {
6944 push @$cmd, '--target-image-opts';
6945 $dst_path = convert_iscsi_path
($dst_path);
6947 push @$cmd, '-O', $dst_format;
6950 push @$cmd, $src_path;
6952 if (!$dst_is_iscsi && $is_zero_initialized) {
6953 push @$cmd, "zeroinit:$dst_path";
6955 push @$cmd, $dst_path;
6960 if($line =~ m/\((\S+)\/100\
%\)/){
6962 my $transferred = int($size * $percent / 100);
6963 my $total_h = render_bytes
($size, 1);
6964 my $transferred_h = render_bytes
($transferred, 1);
6966 print "transferred $transferred_h of $total_h ($percent%)";
6971 eval { run_command
($cmd, timeout
=> undef, outfunc
=> $parser); };
6973 die "copy failed: $err" if $err;
6976 sub qemu_img_format
{
6977 my ($scfg, $volname) = @_;
6979 if ($scfg->{path
} && $volname =~ m/\.($PVE::QemuServer::Drive::QEMU_FORMAT_RE)$/) {
6986 sub qemu_drive_mirror
{
6987 my ($vmid, $drive, $dst_volid, $vmiddst, $is_zero_initialized, $jobs, $completion, $qga, $bwlimit, $src_bitmap) = @_;
6989 $jobs = {} if !$jobs;
6993 $jobs->{"drive-$drive"} = {};
6995 if ($dst_volid =~ /^nbd:/) {
6996 $qemu_target = $dst_volid;
6999 my $storecfg = PVE
::Storage
::config
();
7000 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid);
7002 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
7004 $format = qemu_img_format
($dst_scfg, $dst_volname);
7006 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
7008 $qemu_target = $is_zero_initialized ?
"zeroinit:$dst_path" : $dst_path;
7011 my $opts = { timeout
=> 10, device
=> "drive-$drive", mode
=> "existing", sync
=> "full", target
=> $qemu_target };
7012 $opts->{format
} = $format if $format;
7014 if (defined($src_bitmap)) {
7015 $opts->{sync
} = 'incremental';
7016 $opts->{bitmap
} = $src_bitmap;
7017 print "drive mirror re-using dirty bitmap '$src_bitmap'\n";
7020 if (defined($bwlimit)) {
7021 $opts->{speed
} = $bwlimit * 1024;
7022 print "drive mirror is starting for drive-$drive with bandwidth limit: ${bwlimit} KB/s\n";
7024 print "drive mirror is starting for drive-$drive\n";
7027 # if a job already runs for this device we get an error, catch it for cleanup
7028 eval { mon_cmd
($vmid, "drive-mirror", %$opts); };
7030 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
7032 die "mirroring error: $err\n";
7035 qemu_drive_mirror_monitor
($vmid, $vmiddst, $jobs, $completion, $qga);
7038 # $completion can be either
7039 # 'complete': wait until all jobs are ready, block-job-complete them (default)
7040 # 'cancel': wait until all jobs are ready, block-job-cancel them
7041 # 'skip': wait until all jobs are ready, return with block jobs in ready state
7042 # 'auto': wait until all jobs disappear, only use for jobs which complete automatically
7043 sub qemu_drive_mirror_monitor
{
7044 my ($vmid, $vmiddst, $jobs, $completion, $qga, $op) = @_;
7046 $completion //= 'complete';
7050 my $err_complete = 0;
7052 my $starttime = time ();
7054 die "block job ('$op') timed out\n" if $err_complete > 300;
7056 my $stats = mon_cmd
($vmid, "query-block-jobs");
7059 my $running_jobs = {};
7060 for my $stat (@$stats) {
7061 next if $stat->{type
} ne $op;
7062 $running_jobs->{$stat->{device
}} = $stat;
7065 my $readycounter = 0;
7067 for my $job_id (sort keys %$jobs) {
7068 my $job = $running_jobs->{$job_id};
7070 my $vanished = !defined($job);
7071 my $complete = defined($jobs->{$job_id}->{complete
}) && $vanished;
7072 if($complete || ($vanished && $completion eq 'auto')) {
7073 print "$job_id: $op-job finished\n";
7074 delete $jobs->{$job_id};
7078 die "$job_id: '$op' has been cancelled\n" if !defined($job);
7080 my $busy = $job->{busy
};
7081 my $ready = $job->{ready
};
7082 if (my $total = $job->{len
}) {
7083 my $transferred = $job->{offset
} || 0;
7084 my $remaining = $total - $transferred;
7085 my $percent = sprintf "%.2f", ($transferred * 100 / $total);
7087 my $duration = $ctime - $starttime;
7088 my $total_h = render_bytes
($total, 1);
7089 my $transferred_h = render_bytes
($transferred, 1);
7091 my $status = sprintf(
7092 "transferred $transferred_h of $total_h ($percent%%) in %s",
7093 render_duration
($duration),
7098 $status .= ", still busy"; # shouldn't even happen? but mirror is weird
7100 $status .= ", ready";
7103 print "$job_id: $status\n" if !$jobs->{$job_id}->{ready
};
7104 $jobs->{$job_id}->{ready
} = $ready;
7107 $readycounter++ if $job->{ready
};
7110 last if scalar(keys %$jobs) == 0;
7112 if ($readycounter == scalar(keys %$jobs)) {
7113 print "all '$op' jobs are ready\n";
7115 # do the complete later (or has already been done)
7116 last if $completion eq 'skip' || $completion eq 'auto';
7118 if ($vmiddst && $vmiddst != $vmid) {
7119 my $agent_running = $qga && qga_check_running
($vmid);
7120 if ($agent_running) {
7121 print "freeze filesystem\n";
7122 eval { mon_cmd
($vmid, "guest-fsfreeze-freeze"); };
7124 print "suspend vm\n";
7125 eval { PVE
::QemuServer
::vm_suspend
($vmid, 1); };
7128 # if we clone a disk for a new target vm, we don't switch the disk
7129 PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs);
7131 if ($agent_running) {
7132 print "unfreeze filesystem\n";
7133 eval { mon_cmd
($vmid, "guest-fsfreeze-thaw"); };
7135 print "resume vm\n";
7136 eval { PVE
::QemuServer
::vm_resume
($vmid, 1, 1); };
7142 for my $job_id (sort keys %$jobs) {
7143 # try to switch the disk if source and destination are on the same guest
7144 print "$job_id: Completing block job_id...\n";
7147 if ($completion eq 'complete') {
7148 $op = 'block-job-complete';
7149 } elsif ($completion eq 'cancel') {
7150 $op = 'block-job-cancel';
7152 die "invalid completion value: $completion\n";
7154 eval { mon_cmd
($vmid, $op, device
=> $job_id) };
7155 if ($@ =~ m/cannot be completed/) {
7156 print "$job_id: block job cannot be completed, trying again.\n";
7159 print "$job_id: Completed successfully.\n";
7160 $jobs->{$job_id}->{complete
} = 1;
7171 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
7172 die "block job ($op) error: $err";
7176 sub qemu_blockjobs_cancel
{
7177 my ($vmid, $jobs) = @_;
7179 foreach my $job (keys %$jobs) {
7180 print "$job: Cancelling block job\n";
7181 eval { mon_cmd
($vmid, "block-job-cancel", device
=> $job); };
7182 $jobs->{$job}->{cancel
} = 1;
7186 my $stats = mon_cmd
($vmid, "query-block-jobs");
7188 my $running_jobs = {};
7189 foreach my $stat (@$stats) {
7190 $running_jobs->{$stat->{device
}} = $stat;
7193 foreach my $job (keys %$jobs) {
7195 if (defined($jobs->{$job}->{cancel
}) && !defined($running_jobs->{$job})) {
7196 print "$job: Done.\n";
7197 delete $jobs->{$job};
7201 last if scalar(keys %$jobs) == 0;
7208 my ($storecfg, $vmid, $running, $drivename, $drive, $snapname,
7209 $newvmid, $storage, $format, $full, $newvollist, $jobs, $completion, $qga, $bwlimit, $conf) = @_;
7214 print "create linked clone of drive $drivename ($drive->{file})\n";
7215 $newvolid = PVE
::Storage
::vdisk_clone
($storecfg, $drive->{file
}, $newvmid, $snapname);
7216 push @$newvollist, $newvolid;
7219 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
7220 $storeid = $storage if $storage;
7222 my $dst_format = resolve_dst_disk_format
($storecfg, $storeid, $volname, $format);
7224 print "create full clone of drive $drivename ($drive->{file})\n";
7227 if (drive_is_cloudinit
($drive)) {
7228 $name = "vm-$newvmid-cloudinit";
7229 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
7230 if ($scfg->{path
}) {
7231 $name .= ".$dst_format";
7234 $size = PVE
::QemuServer
::Cloudinit
::CLOUDINIT_DISK_SIZE
;
7235 } elsif ($drivename eq 'efidisk0') {
7236 $size = get_efivars_size
($conf);
7238 ($size) = PVE
::Storage
::volume_size_info
($storecfg, $drive->{file
}, 10);
7240 $newvolid = PVE
::Storage
::vdisk_alloc
(
7241 $storecfg, $storeid, $newvmid, $dst_format, $name, ($size/1024)
7243 push @$newvollist, $newvolid;
7245 PVE
::Storage
::activate_volumes
($storecfg, [$newvolid]);
7247 if (drive_is_cloudinit
($drive)) {
7248 # when cloning multiple disks (e.g. during clone_vm) it might be the last disk
7249 # if this is the case, we have to complete any block-jobs still there from
7250 # previous drive-mirrors
7251 if (($completion eq 'complete') && (scalar(keys %$jobs) > 0)) {
7252 qemu_drive_mirror_monitor
($vmid, $newvmid, $jobs, $completion, $qga);
7257 my $sparseinit = PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $newvolid);
7258 if (!$running || $snapname) {
7259 # TODO: handle bwlimits
7260 if ($drivename eq 'efidisk0') {
7261 # the relevant data on the efidisk may be smaller than the source
7262 # e.g. on RBD/ZFS, so we use dd to copy only the amount
7263 # that is given by the OVMF_VARS.fd
7264 my $src_path = PVE
::Storage
::path
($storecfg, $drive->{file
});
7265 my $dst_path = PVE
::Storage
::path
($storecfg, $newvolid);
7267 # better for Ceph if block size is not too small, see bug #3324
7270 run_command
(['qemu-img', 'dd', '-n', '-O', $dst_format, "bs=$bs", "osize=$size",
7271 "if=$src_path", "of=$dst_path"]);
7273 qemu_img_convert
($drive->{file
}, $newvolid, $size, $snapname, $sparseinit);
7277 my $kvmver = get_running_qemu_version
($vmid);
7278 if (!min_version
($kvmver, 2, 7)) {
7279 die "drive-mirror with iothread requires qemu version 2.7 or higher\n"
7280 if $drive->{iothread
};
7283 qemu_drive_mirror
($vmid, $drivename, $newvolid, $newvmid, $sparseinit, $jobs,
7284 $completion, $qga, $bwlimit);
7289 my ($size) = eval { PVE
::Storage
::volume_size_info
($storecfg, $newvolid, 10) };
7292 $disk->{format
} = undef;
7293 $disk->{file
} = $newvolid;
7294 $disk->{size
} = $size if defined($size);
7299 sub get_running_qemu_version
{
7301 my $res = mon_cmd
($vmid, "query-version");
7302 return "$res->{qemu}->{major}.$res->{qemu}->{minor}";
7305 sub qemu_use_old_bios_files
{
7306 my ($machine_type) = @_;
7308 return if !$machine_type;
7310 my $use_old_bios_files = undef;
7312 if ($machine_type =~ m/^(\S+)\.pxe$/) {
7314 $use_old_bios_files = 1;
7316 my $version = extract_version
($machine_type, kvm_user_version
());
7317 # Note: kvm version < 2.4 use non-efi pxe files, and have problems when we
7318 # load new efi bios files on migration. So this hack is required to allow
7319 # live migration from qemu-2.2 to qemu-2.4, which is sometimes used when
7320 # updrading from proxmox-ve-3.X to proxmox-ve 4.0
7321 $use_old_bios_files = !min_version
($version, 2, 4);
7324 return ($use_old_bios_files, $machine_type);
7327 sub get_efivars_size
{
7329 my $arch = get_vm_arch
($conf);
7330 my (undef, $ovmf_vars) = get_ovmf_files
($arch);
7331 die "uefi vars image '$ovmf_vars' not found\n" if ! -f
$ovmf_vars;
7332 return -s
$ovmf_vars;
7335 sub update_efidisk_size
{
7338 return if !defined($conf->{efidisk0
});
7340 my $disk = PVE
::QemuServer
::parse_drive
('efidisk0', $conf->{efidisk0
});
7341 $disk->{size
} = get_efivars_size
($conf);
7342 $conf->{efidisk0
} = print_drive
($disk);
7347 sub create_efidisk
($$$$$) {
7348 my ($storecfg, $storeid, $vmid, $fmt, $arch) = @_;
7350 my (undef, $ovmf_vars) = get_ovmf_files
($arch);
7351 die "EFI vars default image not found\n" if ! -f
$ovmf_vars;
7353 my $vars_size_b = -s
$ovmf_vars;
7354 my $vars_size = PVE
::Tools
::convert_size
($vars_size_b, 'b' => 'kb');
7355 my $volid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $vmid, $fmt, undef, $vars_size);
7356 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
7358 qemu_img_convert
($ovmf_vars, $volid, $vars_size_b, undef, 0);
7359 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $volid, 3);
7361 return ($volid, $size/1024);
7364 sub vm_iothreads_list
{
7367 my $res = mon_cmd
($vmid, 'query-iothreads');
7370 foreach my $iothread (@$res) {
7371 $iothreads->{ $iothread->{id
} } = $iothread->{"thread-id"};
7378 my ($conf, $drive) = @_;
7382 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)) {
7384 } elsif ($conf->{scsihw
} && ($conf->{scsihw
} eq 'virtio-scsi-single')) {
7390 my $controller = int($drive->{index} / $maxdev);
7391 my $controller_prefix = ($conf->{scsihw
} && $conf->{scsihw
} eq 'virtio-scsi-single')
7395 return ($maxdev, $controller, $controller_prefix);
7398 sub windows_version
{
7401 return 0 if !$ostype;
7405 if($ostype eq 'wxp' || $ostype eq 'w2k3' || $ostype eq 'w2k') {
7407 } elsif($ostype eq 'w2k8' || $ostype eq 'wvista') {
7409 } elsif ($ostype =~ m/^win(\d+)$/) {
7416 sub resolve_dst_disk_format
{
7417 my ($storecfg, $storeid, $src_volname, $format) = @_;
7418 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
7421 # if no target format is specified, use the source disk format as hint
7423 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
7424 $format = qemu_img_format
($scfg, $src_volname);
7430 # test if requested format is supported - else use default
7431 my $supported = grep { $_ eq $format } @$validFormats;
7432 $format = $defFormat if !$supported;
7436 # NOTE: if this logic changes, please update docs & possibly gui logic
7437 sub find_vmstate_storage
{
7438 my ($conf, $storecfg) = @_;
7440 # first, return storage from conf if set
7441 return $conf->{vmstatestorage
} if $conf->{vmstatestorage
};
7443 my ($target, $shared, $local);
7445 foreach_storage_used_by_vm
($conf, sub {
7447 my $scfg = PVE
::Storage
::storage_config
($storecfg, $sid);
7448 my $dst = $scfg->{shared
} ? \
$shared : \
$local;
7449 $$dst = $sid if !$$dst || $scfg->{path
}; # prefer file based storage
7452 # second, use shared storage where VM has at least one disk
7453 # third, use local storage where VM has at least one disk
7454 # fall back to local storage
7455 $target = $shared // $local // 'local';
7461 my ($uuid, $uuid_str);
7462 UUID
::generate
($uuid);
7463 UUID
::unparse
($uuid, $uuid_str);
7467 sub generate_smbios1_uuid
{
7468 return "uuid=".generate_uuid
();
7474 mon_cmd
($vmid, 'nbd-server-stop');
7477 sub create_reboot_request
{
7479 open(my $fh, '>', "/run/qemu-server/$vmid.reboot")
7480 or die "failed to create reboot trigger file: $!\n";
7484 sub clear_reboot_request
{
7486 my $path = "/run/qemu-server/$vmid.reboot";
7489 $res = unlink($path);
7490 die "could not remove reboot request for $vmid: $!"
7491 if !$res && $! != POSIX
::ENOENT
;
7496 sub bootorder_from_legacy
{
7497 my ($conf, $bootcfg) = @_;
7499 my $boot = $bootcfg->{legacy
} || $boot_fmt->{legacy
}->{default};
7500 my $bootindex_hash = {};
7502 foreach my $o (split(//, $boot)) {
7503 $bootindex_hash->{$o} = $i*100;
7509 PVE
::QemuConfig-
>foreach_volume($conf, sub {
7510 my ($ds, $drive) = @_;
7512 if (drive_is_cdrom
($drive, 1)) {
7513 if ($bootindex_hash->{d
}) {
7514 $bootorder->{$ds} = $bootindex_hash->{d
};
7515 $bootindex_hash->{d
} += 1;
7517 } elsif ($bootindex_hash->{c
}) {
7518 $bootorder->{$ds} = $bootindex_hash->{c
}
7519 if $conf->{bootdisk
} && $conf->{bootdisk
} eq $ds;
7520 $bootindex_hash->{c
} += 1;
7524 if ($bootindex_hash->{n
}) {
7525 for (my $i = 0; $i < $MAX_NETS; $i++) {
7526 my $netname = "net$i";
7527 next if !$conf->{$netname};
7528 $bootorder->{$netname} = $bootindex_hash->{n
};
7529 $bootindex_hash->{n
} += 1;
7536 # Generate default device list for 'boot: order=' property. Matches legacy
7537 # default boot order, but with explicit device names. This is important, since
7538 # the fallback for when neither 'order' nor the old format is specified relies
7539 # on 'bootorder_from_legacy' above, and it would be confusing if this diverges.
7540 sub get_default_bootdevices
{
7546 my $first = PVE
::QemuServer
::Drive
::resolve_first_disk
($conf, 0);
7547 push @ret, $first if $first;
7550 $first = PVE
::QemuServer
::Drive
::resolve_first_disk
($conf, 1);
7551 push @ret, $first if $first;
7554 for (my $i = 0; $i < $MAX_NETS; $i++) {
7555 my $netname = "net$i";
7556 next if !$conf->{$netname};
7557 push @ret, $netname;
7564 sub device_bootorder
{
7567 return bootorder_from_legacy
($conf) if !defined($conf->{boot
});
7569 my $boot = parse_property_string
($boot_fmt, $conf->{boot
});
7572 if (!defined($boot) || $boot->{legacy
}) {
7573 $bootorder = bootorder_from_legacy
($conf, $boot);
7574 } elsif ($boot->{order
}) {
7575 my $i = 100; # start at 100 to allow user to insert devices before us with -args
7576 for my $dev (PVE
::Tools
::split_list
($boot->{order
})) {
7577 $bootorder->{$dev} = $i++;
7584 sub register_qmeventd_handle
{
7588 my $peer = "/var/run/qmeventd.sock";
7593 $fh = IO
::Socket
::UNIX-
>new(Peer
=> $peer, Blocking
=> 0, Timeout
=> 1);
7595 if ($! != EINTR
&& $! != EAGAIN
) {
7596 die "unable to connect to qmeventd socket (vmid: $vmid) - $!\n";
7599 die "unable to connect to qmeventd socket (vmid: $vmid) - timeout "
7600 . "after $count retries\n";
7605 # send handshake to mark VM as backing up
7606 print $fh to_json
({vzdump
=> {vmid
=> "$vmid"}});
7608 # return handle to be closed later when inhibit is no longer required
7612 # bash completion helper
7614 sub complete_backup_archives
{
7615 my ($cmdname, $pname, $cvalue) = @_;
7617 my $cfg = PVE
::Storage
::config
();
7621 if ($cvalue =~ m/^([^:]+):/) {
7625 my $data = PVE
::Storage
::template_list
($cfg, $storeid, 'backup');
7628 foreach my $id (keys %$data) {
7629 foreach my $item (@{$data->{$id}}) {
7630 next if $item->{format
} !~ m/^vma\.(${\PVE::Storage::Plugin::COMPRESSOR_RE})$/;
7631 push @$res, $item->{volid
} if defined($item->{volid
});
7638 my $complete_vmid_full = sub {
7641 my $idlist = vmstatus
();
7645 foreach my $id (keys %$idlist) {
7646 my $d = $idlist->{$id};
7647 if (defined($running)) {
7648 next if $d->{template
};
7649 next if $running && $d->{status
} ne 'running';
7650 next if !$running && $d->{status
} eq 'running';
7659 return &$complete_vmid_full();
7662 sub complete_vmid_stopped
{
7663 return &$complete_vmid_full(0);
7666 sub complete_vmid_running
{
7667 return &$complete_vmid_full(1);
7670 sub complete_storage
{
7672 my $cfg = PVE
::Storage
::config
();
7673 my $ids = $cfg->{ids
};
7676 foreach my $sid (keys %$ids) {
7677 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, undef, 1);
7678 next if !$ids->{$sid}->{content
}->{images
};
7685 sub complete_migration_storage
{
7686 my ($cmd, $param, $current_value, $all_args) = @_;
7688 my $targetnode = @$all_args[1];
7690 my $cfg = PVE
::Storage
::config
();
7691 my $ids = $cfg->{ids
};
7694 foreach my $sid (keys %$ids) {
7695 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, $targetnode, 1);
7696 next if !$ids->{$sid}->{content
}->{images
};
7705 my $qmpstatus = eval {
7706 PVE
::QemuConfig
::assert_config_exists_on_node
($vmid);
7707 mon_cmd
($vmid, "query-status");
7710 return $qmpstatus && $qmpstatus->{status
} eq "paused";