1 package PVE
::QemuServer
;
22 use Storable
qw(dclone);
23 use PVE
::Exception
qw(raise raise_param_exc);
25 use PVE
::Tools
qw(run_command lock_file lock_file_full file_read_firstline dir_glob_foreach);
26 use PVE
::JSONSchema
qw(get_standard_option);
27 use PVE
::Cluster
qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
32 use PVE
::RPCEnvironment
;
33 use PVE
::QemuServer
::PCI
qw(print_pci_addr print_pcie_addr);
34 use PVE
::QemuServer
::Memory
;
35 use PVE
::QemuServer
::USB
qw(parse_usb_device);
36 use Time
::HiRes
qw(gettimeofday);
37 use File
::Copy
qw(copy);
40 my $OVMF_CODE = '/usr/share/kvm/OVMF_CODE-pure-efi.fd';
41 my $OVMF_VARS = '/usr/share/kvm/OVMF_VARS-pure-efi.fd';
43 my $qemu_snap_storage = {rbd
=> 1, sheepdog
=> 1};
45 my $cpuinfo = PVE
::ProcFSTools
::read_cpuinfo
();
47 # Note about locking: we use flock on the config file protect
48 # against concurent actions.
49 # Aditionaly, we have a 'lock' setting in the config file. This
50 # can be set to 'migrate', 'backup', 'snapshot' or 'rollback'. Most actions are not
51 # allowed when such lock is set. But you can ignore this kind of
52 # lock with the --skiplock flag.
54 cfs_register_file
('/qemu-server/',
58 PVE
::JSONSchema
::register_standard_option
('pve-qm-stateuri', {
59 description
=> "Some command save/restore state from this location.",
65 PVE
::JSONSchema
::register_standard_option
('pve-snapshot-name', {
66 description
=> "The name of the snapshot.",
67 type
=> 'string', format
=> 'pve-configid',
71 PVE
::JSONSchema
::register_standard_option
('pve-qm-image-format', {
73 enum
=> [qw(raw cow qcow qed qcow2 vmdk cloop)],
74 description
=> "The drive's backing file's data format.",
78 #no warnings 'redefine';
81 my ($controller, $vmid, $option, $value) = @_;
83 my $path = "/sys/fs/cgroup/$controller/qemu.slice/$vmid.scope/$option";
84 PVE
::ProcFSTools
::write_proc_entry
($path, $value);
88 my $nodename = PVE
::INotify
::nodename
();
90 mkdir "/etc/pve/nodes/$nodename";
91 my $confdir = "/etc/pve/nodes/$nodename/qemu-server";
94 my $var_run_tmpdir = "/var/run/qemu-server";
95 mkdir $var_run_tmpdir;
97 my $lock_dir = "/var/lock/qemu-server";
100 my $pcisysfs = "/sys/bus/pci";
102 my $cpu_vendor_list = {
104 486 => 'GenuineIntel',
105 pentium
=> 'GenuineIntel',
106 pentium2
=> 'GenuineIntel',
107 pentium3
=> 'GenuineIntel',
108 coreduo
=> 'GenuineIntel',
109 core2duo
=> 'GenuineIntel',
110 Conroe
=> 'GenuineIntel',
111 Penryn
=> 'GenuineIntel',
112 Nehalem
=> 'GenuineIntel',
113 Westmere
=> 'GenuineIntel',
114 SandyBridge
=> 'GenuineIntel',
115 IvyBridge
=> 'GenuineIntel',
116 Haswell
=> 'GenuineIntel',
117 'Haswell-noTSX' => 'GenuineIntel',
118 Broadwell
=> 'GenuineIntel',
119 'Broadwell-noTSX' => 'GenuineIntel',
120 'Skylake-Client' => 'GenuineIntel',
123 athlon
=> 'AuthenticAMD',
124 phenom
=> 'AuthenticAMD',
125 Opteron_G1
=> 'AuthenticAMD',
126 Opteron_G2
=> 'AuthenticAMD',
127 Opteron_G3
=> 'AuthenticAMD',
128 Opteron_G4
=> 'AuthenticAMD',
129 Opteron_G5
=> 'AuthenticAMD',
131 # generic types, use vendor from host node
141 description
=> "Emulated CPU type.",
143 enum
=> [ sort { "\L$a" cmp "\L$b" } keys %$cpu_vendor_list ],
148 description
=> "Do not identify as a KVM virtual machine.",
159 enum
=> [qw(i6300esb ib700)],
160 description
=> "Watchdog type to emulate.",
161 default => 'i6300esb',
166 enum
=> [qw(reset shutdown poweroff pause debug none)],
167 description
=> "The action to perform if after activation the guest fails to poll the watchdog in time.",
171 PVE
::JSONSchema
::register_format
('pve-qm-watchdog', $watchdog_fmt);
177 description
=> "Specifies whether a VM will be started during system bootup.",
183 description
=> "Automatic restart after crash (currently ignored).",
188 type
=> 'string', format
=> 'pve-hotplug-features',
189 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'.",
190 default => 'network,disk,usb',
195 description
=> "Allow reboot. If set to '0' the VM exit on reboot.",
201 description
=> "Lock/unlock the VM.",
202 enum
=> [qw(migrate backup snapshot rollback)],
207 description
=> "Limit of CPU usage.",
208 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.",
216 description
=> "CPU weight for a VM.",
217 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.\n\nNOTE: You can disable fair-scheduler configuration by setting this to 0.",
225 description
=> "Amount of RAM for the VM in MB. This is the maximum available memory when you use the balloon device.",
232 description
=> "Amount of target RAM for the VM in MB. Using zero disables the ballon driver.",
238 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",
246 description
=> "Keybord layout for vnc server. Default is read from the '/etc/pve/datacenter.conf' configuration file.",
247 enum
=> PVE
::Tools
::kvmkeymaplist
(),
252 type
=> 'string', format
=> 'dns-name',
253 description
=> "Set a name for the VM. Only used on the configuration web interface.",
258 description
=> "SCSI controller model",
259 enum
=> [qw(lsi lsi53c810 virtio-scsi-pci virtio-scsi-single megasas pvscsi)],
265 description
=> "Description for the VM. Only used on the configuration web interface. This is saved as comment inside the configuration file.",
270 enum
=> [qw(other wxp w2k w2k3 w2k8 wvista win7 win8 win10 l24 l26 solaris)],
271 description
=> "Specify guest operating system.",
272 verbose_description
=> <<EODESC,
273 Specify guest operating system. This is used to enable special
274 optimization/features for specific operating systems:
277 other;; unspecified OS
278 wxp;; Microsoft Windows XP
279 w2k;; Microsoft Windows 2000
280 w2k3;; Microsoft Windows 2003
281 w2k8;; Microsoft Windows 2008
282 wvista;; Microsoft Windows Vista
283 win7;; Microsoft Windows 7
284 win8;; Microsoft Windows 8/2012
285 l24;; Linux 2.4 Kernel
286 l26;; Linux 2.6/3.X Kernel
287 solaris;; Solaris/OpenSolaris/OpenIndiania kernel
293 description
=> "Boot on floppy (a), hard disk (c), CD-ROM (d), or network (n).",
294 pattern
=> '[acdn]{1,4}',
299 type
=> 'string', format
=> 'pve-qm-bootdisk',
300 description
=> "Enable booting from specified disk.",
301 pattern
=> '(ide|sata|scsi|virtio)\d+',
306 description
=> "The number of CPUs. Please use option -sockets instead.",
313 description
=> "The number of CPU sockets.",
320 description
=> "The number of cores per socket.",
327 description
=> "Enable/disable NUMA.",
333 description
=> "Enable/disable hugepages memory.",
334 enum
=> [qw(any 2 1024)],
339 description
=> "Number of hotplugged vcpus.",
346 description
=> "Enable/disable ACPI.",
352 description
=> "Enable/disable Qemu GuestAgent.",
358 description
=> "Enable/disable KVM hardware virtualization.",
364 description
=> "Enable/disable time drift fix.",
370 description
=> "Set the real time clock to local time. This is enabled by default if ostype indicates a Microsoft OS.",
375 description
=> "Freeze CPU at startup (use 'c' monitor command to start execution).",
380 description
=> "Select the VGA type.",
381 verbose_description
=> "Select the VGA type. If you want to use high resolution" .
382 " modes (>= 1280x1024x16) then you should use the options " .
383 "'std' or 'vmware'. Default is 'std' for win8/win7/w2k8, and " .
384 "'cirrus' for other OS types. The 'qxl' option enables the SPICE " .
385 "display sever. For win* OS you can select how many independent " .
386 "displays you want, Linux guests can add displays them self. " .
387 "You can also run without any graphic card, using a serial device" .
389 enum
=> [qw(std cirrus vmware qxl serial0 serial1 serial2 serial3 qxl2 qxl3 qxl4)],
393 type
=> 'string', format
=> 'pve-qm-watchdog',
394 description
=> "Create a virtual hardware watchdog device.",
395 verbose_description
=> "Create a virtual hardware watchdog device. Once enabled" .
396 " (by a guest action), the watchdog must be periodically polled " .
397 "by an agent inside the guest or else the watchdog will reset " .
398 "the guest (or execute the respective action specified)",
403 typetext
=> "(now | YYYY-MM-DD | YYYY-MM-DDTHH:MM:SS)",
404 description
=> "Set the initial date of the real time clock. Valid format for date are: 'now' or '2006-06-17T16:01:21' or '2006-06-17'.",
405 pattern
=> '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
408 startup
=> get_standard_option
('pve-startup-order'),
412 description
=> "Enable/disable Template.",
418 description
=> "Arbitrary arguments passed to kvm.",
419 verbose_description
=> <<EODESCR,
420 Arbitrary arguments passed to kvm, for example:
422 args: -no-reboot -no-hpet
424 NOTE: this option is for experts only.
431 description
=> "Enable/disable the USB tablet device.",
432 verbose_description
=> "Enable/disable the USB tablet device. This device is " .
433 "usually needed to allow absolute mouse positioning with VNC. " .
434 "Else the mouse runs out of sync with normal VNC clients. " .
435 "If you're running lots of console-only guests on one host, " .
436 "you may consider disabling this to save some context switches. " .
437 "This is turned off by default if you use spice (-vga=qxl).",
442 description
=> "Set maximum speed (in MB/s) for migrations. Value 0 is no limit.",
446 migrate_downtime
=> {
449 description
=> "Set maximum tolerated downtime (in seconds) for migrations.",
455 type
=> 'string', format
=> 'pve-qm-ide',
456 typetext
=> '<volume>',
457 description
=> "This is an alias for option -ide2",
461 description
=> "Emulated CPU type.",
465 parent
=> get_standard_option
('pve-snapshot-name', {
467 description
=> "Parent snapshot name. This is used internally, and should not be modified.",
471 description
=> "Timestamp for snapshots.",
477 type
=> 'string', format
=> 'pve-volume-id',
478 description
=> "Reference to a volume which stores the VM state. This is used internally for snapshots.",
480 vmstatestorage
=> get_standard_option
('pve-storage-id', {
481 description
=> "Default storage for VM state volumes/files.",
485 description
=> "Specific the Qemu machine type.",
487 pattern
=> '(pc|pc(-i440fx)?-\d+\.\d+(\.pxe)?|q35|pc-q35-\d+\.\d+(\.pxe)?)',
492 description
=> "Specify SMBIOS type 1 fields.",
493 type
=> 'string', format
=> 'pve-qm-smbios1',
500 description
=> "Sets the protection flag of the VM. This will disable the remove VM and remove disk operations.",
506 enum
=> [ qw(seabios ovmf) ],
507 description
=> "Select BIOS implementation.",
508 default => 'seabios',
512 # what about other qemu settings ?
514 #machine => 'string',
527 ##soundhw => 'string',
529 while (my ($k, $v) = each %$confdesc) {
530 PVE
::JSONSchema
::register_standard_option
("pve-qm-$k", $v);
533 my $MAX_IDE_DISKS = 4;
534 my $MAX_SCSI_DISKS = 14;
535 my $MAX_VIRTIO_DISKS = 16;
536 my $MAX_SATA_DISKS = 6;
537 my $MAX_USB_DEVICES = 5;
539 my $MAX_UNUSED_DISKS = 8;
540 my $MAX_HOSTPCI_DEVICES = 4;
541 my $MAX_SERIAL_PORTS = 4;
542 my $MAX_PARALLEL_PORTS = 3;
548 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
549 description
=> "CPUs accessing this NUMA node.",
550 format_description
=> "id[-id];...",
554 description
=> "Amount of memory this NUMA node provides.",
559 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
560 description
=> "Host NUMA nodes to use.",
561 format_description
=> "id[-id];...",
566 enum
=> [qw(preferred bind interleave)],
567 description
=> "NUMA allocation policy.",
571 PVE
::JSONSchema
::register_format
('pve-qm-numanode', $numa_fmt);
574 type
=> 'string', format
=> $numa_fmt,
575 description
=> "NUMA topology.",
577 PVE
::JSONSchema
::register_standard_option
("pve-qm-numanode", $numadesc);
579 for (my $i = 0; $i < $MAX_NUMA; $i++) {
580 $confdesc->{"numa$i"} = $numadesc;
583 my $nic_model_list = ['rtl8139', 'ne2k_pci', 'e1000', 'pcnet', 'virtio',
584 'ne2k_isa', 'i82551', 'i82557b', 'i82559er', 'vmxnet3',
585 'e1000-82540em', 'e1000-82544gc', 'e1000-82545em'];
586 my $nic_model_list_txt = join(' ', sort @$nic_model_list);
588 my $net_fmt_bridge_descr = <<__EOD__;
589 Bridge to attach the network device to. The Proxmox VE standard bridge
592 If you do not specify a bridge, we create a kvm user (NATed) network
593 device, which provides DHCP and DNS services. The following addresses
600 The DHCP server assign addresses to the guest starting from 10.0.2.15.
606 pattern
=> qr/[0-9a-f]{2}(?::[0-9a-f]{2}){5}/i,
607 description
=> "MAC address. That address must be unique withing your network. This is automatically generated if not specified.",
608 format_description
=> "XX:XX:XX:XX:XX:XX",
613 description
=> "Network Card Model. The 'virtio' model provides the best performance with very low CPU overhead. If your guest does not support this driver, it is usually best to use 'e1000'.",
614 enum
=> $nic_model_list,
617 (map { $_ => { keyAlias
=> 'model', alias
=> 'macaddr' }} @$nic_model_list),
620 description
=> $net_fmt_bridge_descr,
621 format_description
=> 'bridge',
626 minimum
=> 0, maximum
=> 16,
627 description
=> 'Number of packet queues to be used on the device.',
633 description
=> "Rate limit in mbps (megabytes per second) as floating point number.",
638 minimum
=> 1, maximum
=> 4094,
639 description
=> 'VLAN tag to apply to packets on this interface.',
644 pattern
=> qr/\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*/,
645 description
=> 'VLAN trunks to pass through this interface.',
646 format_description
=> 'vlanid[;vlanid...]',
651 description
=> 'Whether this interface should be protected by the firewall.',
656 description
=> 'Whether this interface should be disconnected (like pulling the plug).',
663 type
=> 'string', format
=> $net_fmt,
664 description
=> "Specify network devices.",
667 PVE
::JSONSchema
::register_standard_option
("pve-qm-net", $netdesc);
669 for (my $i = 0; $i < $MAX_NETS; $i++) {
670 $confdesc->{"net$i"} = $netdesc;
673 PVE
::JSONSchema
::register_format
('pve-volume-id-or-qm-path', \
&verify_volume_id_or_qm_path
);
674 sub verify_volume_id_or_qm_path
{
675 my ($volid, $noerr) = @_;
677 if ($volid eq 'none' || $volid eq 'cdrom' || $volid =~ m
|^/|) {
681 # if its neither 'none' nor 'cdrom' nor a path, check if its a volume-id
682 $volid = eval { PVE
::JSONSchema
::check_format
('pve-volume-id', $volid, '') };
684 return undef if $noerr;
692 my %drivedesc_base = (
693 volume
=> { alias
=> 'file' },
696 format
=> 'pve-volume-id-or-qm-path',
698 format_description
=> 'volume',
699 description
=> "The drive's backing volume.",
703 enum
=> [qw(cdrom disk)],
704 description
=> "The drive's media type.",
710 description
=> "Force the drive's physical geometry to have a specific cylinder count.",
715 description
=> "Force the drive's physical geometry to have a specific head count.",
720 description
=> "Force the drive's physical geometry to have a specific sector count.",
725 enum
=> [qw(none lba auto)],
726 description
=> "Force disk geometry bios translation mode.",
731 description
=> "Whether the drive should be included when making snapshots.",
736 enum
=> [qw(none writethrough writeback unsafe directsync)],
737 description
=> "The drive's cache mode",
740 format
=> get_standard_option
('pve-qm-image-format'),
743 format
=> 'disk-size',
744 format_description
=> 'DiskSize',
745 description
=> "Disk size. This is purely informational and has no effect.",
750 description
=> "Whether the drive should be included when making backups.",
755 description
=> 'Whether the drive should considered for replication jobs.',
761 enum
=> [qw(ignore report stop)],
762 description
=> 'Read error action.',
767 enum
=> [qw(enospc ignore report stop)],
768 description
=> 'Write error action.',
773 enum
=> [qw(native threads)],
774 description
=> 'AIO type to use.',
779 enum
=> [qw(ignore on)],
780 description
=> 'Controls whether to pass discard/trim requests to the underlying storage.',
785 description
=> 'Controls whether to detect and try to optimize writes of zeroes.',
790 format
=> 'urlencoded',
791 format_description
=> 'serial',
792 maxLength
=> 20*3, # *3 since it's %xx url enoded
793 description
=> "The drive's reported serial number, url-encoded, up to 20 bytes long.",
798 my %iothread_fmt = ( iothread
=> {
800 description
=> "Whether to use iothreads for this drive",
807 format
=> 'urlencoded',
808 format_description
=> 'model',
809 maxLength
=> 40*3, # *3 since it's %xx url enoded
810 description
=> "The drive's reported model name, url-encoded, up to 40 bytes long.",
818 description
=> "Number of queues.",
824 my %scsiblock_fmt = (
827 description
=> "whether to use scsi-block for full passthrough of host block device\n\nWARNING: can lead to I/O errors in combination with low memory or high memory fragmentation on host",
833 my $add_throttle_desc = sub {
834 my ($key, $type, $what, $unit, $longunit, $minimum) = @_;
837 format_description
=> $unit,
838 description
=> "Maximum $what in $longunit.",
841 $d->{minimum
} = $minimum if defined($minimum);
842 $drivedesc_base{$key} = $d;
844 # throughput: (leaky bucket)
845 $add_throttle_desc->('bps', 'integer', 'r/w speed', 'bps', 'bytes per second');
846 $add_throttle_desc->('bps_rd', 'integer', 'read speed', 'bps', 'bytes per second');
847 $add_throttle_desc->('bps_wr', 'integer', 'write speed', 'bps', 'bytes per second');
848 $add_throttle_desc->('mbps', 'number', 'r/w speed', 'mbps', 'megabytes per second');
849 $add_throttle_desc->('mbps_rd', 'number', 'read speed', 'mbps', 'megabytes per second');
850 $add_throttle_desc->('mbps_wr', 'number', 'write speed', 'mbps', 'megabytes per second');
851 $add_throttle_desc->('iops', 'integer', 'r/w I/O', 'iops', 'operations per second');
852 $add_throttle_desc->('iops_rd', 'integer', 'read I/O', 'iops', 'operations per second');
853 $add_throttle_desc->('iops_wr', 'integer', 'write I/O', 'iops', 'operations per second');
855 # pools: (pool of IO before throttling starts taking effect)
856 $add_throttle_desc->('mbps_max', 'number', 'unthrottled r/w pool', 'mbps', 'megabytes per second');
857 $add_throttle_desc->('mbps_rd_max', 'number', 'unthrottled read pool', 'mbps', 'megabytes per second');
858 $add_throttle_desc->('mbps_wr_max', 'number', 'unthrottled write pool', 'mbps', 'megabytes per second');
859 $add_throttle_desc->('iops_max', 'integer', 'unthrottled r/w I/O pool', 'iops', 'operations per second');
860 $add_throttle_desc->('iops_rd_max', 'integer', 'unthrottled read I/O pool', 'iops', 'operations per second');
861 $add_throttle_desc->('iops_wr_max', 'integer', 'unthrottled write I/O pool', 'iops', 'operations per second');
864 $add_throttle_desc->('bps_max_length', 'integer', 'length of I/O bursts', 'seconds', 'seconds', 1);
865 $add_throttle_desc->('bps_rd_max_length', 'integer', 'length of read I/O bursts', 'seconds', 'seconds', 1);
866 $add_throttle_desc->('bps_wr_max_length', 'integer', 'length of write I/O bursts', 'seconds', 'seconds', 1);
867 $add_throttle_desc->('iops_max_length', 'integer', 'length of I/O bursts', 'seconds', 'seconds', 1);
868 $add_throttle_desc->('iops_rd_max_length', 'integer', 'length of read I/O bursts', 'seconds', 'seconds', 1);
869 $add_throttle_desc->('iops_wr_max_length', 'integer', 'length of write I/O bursts', 'seconds', 'seconds', 1);
872 $drivedesc_base{'bps_rd_length'} = { alias
=> 'bps_rd_max_length' };
873 $drivedesc_base{'bps_wr_length'} = { alias
=> 'bps_wr_max_length' };
874 $drivedesc_base{'iops_rd_length'} = { alias
=> 'iops_rd_max_length' };
875 $drivedesc_base{'iops_wr_length'} = { alias
=> 'iops_wr_max_length' };
881 PVE
::JSONSchema
::register_format
("pve-qm-ide", $ide_fmt);
885 type
=> 'string', format
=> $ide_fmt,
886 description
=> "Use volume as IDE hard disk or CD-ROM (n is 0 to " .($MAX_IDE_DISKS -1) . ").",
888 PVE
::JSONSchema
::register_standard_option
("pve-qm-ide", $idedesc);
898 type
=> 'string', format
=> $scsi_fmt,
899 description
=> "Use volume as SCSI hard disk or CD-ROM (n is 0 to " . ($MAX_SCSI_DISKS - 1) . ").",
901 PVE
::JSONSchema
::register_standard_option
("pve-qm-scsi", $scsidesc);
908 type
=> 'string', format
=> $sata_fmt,
909 description
=> "Use volume as SATA hard disk or CD-ROM (n is 0 to " . ($MAX_SATA_DISKS - 1). ").",
911 PVE
::JSONSchema
::register_standard_option
("pve-qm-sata", $satadesc);
919 type
=> 'string', format
=> $virtio_fmt,
920 description
=> "Use volume as VIRTIO hard disk (n is 0 to " . ($MAX_VIRTIO_DISKS - 1) . ").",
922 PVE
::JSONSchema
::register_standard_option
("pve-qm-virtio", $virtiodesc);
933 volume
=> { alias
=> 'file' },
936 format
=> 'pve-volume-id-or-qm-path',
938 format_description
=> 'volume',
939 description
=> "The drive's backing volume.",
941 format
=> get_standard_option
('pve-qm-image-format'),
944 format
=> 'disk-size',
945 format_description
=> 'DiskSize',
946 description
=> "Disk size. This is purely informational and has no effect.",
953 type
=> 'string', format
=> $efidisk_fmt,
954 description
=> "Configure a Disk for storing EFI vars",
957 PVE
::JSONSchema
::register_standard_option
("pve-qm-efidisk", $efidisk_desc);
962 type
=> 'string', format
=> 'pve-qm-usb-device',
963 format_description
=> 'HOSTUSBDEVICE|spice',
964 description
=> <<EODESCR,
965 The Host USB device or port or the value 'spice'. HOSTUSBDEVICE syntax is:
967 'bus-port(.port)*' (decimal numbers) or
968 'vendor_id:product_id' (hexadeciaml numbers) or
971 You can use the 'lsusb -t' command to list existing usb devices.
973 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
975 The value 'spice' can be used to add a usb redirection devices for spice.
981 description
=> "Specifies whether if given host option is a USB3 device or port (this does currently not work reliably with spice redirection and is then ignored).",
988 type
=> 'string', format
=> $usb_fmt,
989 description
=> "Configure an USB device (n is 0 to 4).",
991 PVE
::JSONSchema
::register_standard_option
("pve-qm-usb", $usbdesc);
993 # NOTE: the match-groups of this regex are used in parse_hostpci
994 my $PCIRE = qr/([a-f0-9]{2}:[a-f0-9]{2})(?:\.([a-f0-9]))?/;
999 pattern
=> qr/$PCIRE(;$PCIRE)*/,
1000 format_description
=> 'HOSTPCIID[;HOSTPCIID2...]',
1001 description
=> <<EODESCR,
1002 Host PCI device pass through. The PCI ID of a host's PCI device or a list
1003 of PCI virtual functions of the host. HOSTPCIID syntax is:
1005 'bus:dev.func' (hexadecimal numbers)
1007 You can us the 'lspci' command to list existing PCI devices.
1012 description
=> "Specify whether or not the device's ROM will be visible in the guest's memory map.",
1018 pattern
=> '[^,;]+',
1019 format_description
=> 'string',
1020 description
=> "Custom pci device rom filename (must be located in /usr/share/kvm/).",
1025 description
=> "Choose the PCI-express bus (needs the 'q35' machine model).",
1031 description
=> "Enable vfio-vga device support.",
1036 PVE
::JSONSchema
::register_format
('pve-qm-hostpci', $hostpci_fmt);
1040 type
=> 'string', format
=> 'pve-qm-hostpci',
1041 description
=> "Map host PCI devices into guest.",
1042 verbose_description
=> <<EODESCR,
1043 Map host PCI devices into guest.
1045 NOTE: This option allows direct access to host hardware. So it is no longer
1046 possible to migrate such machines - use with special care.
1048 CAUTION: Experimental! User reported problems with this option.
1051 PVE
::JSONSchema
::register_standard_option
("pve-qm-hostpci", $hostpcidesc);
1056 pattern
=> '(/dev/.+|socket)',
1057 description
=> "Create a serial device inside the VM (n is 0 to 3)",
1058 verbose_description
=> <<EODESCR,
1059 Create a serial device inside the VM (n is 0 to 3), and pass through a
1060 host serial device (i.e. /dev/ttyS0), or create a unix socket on the
1061 host side (use 'qm terminal' to open a terminal connection).
1063 NOTE: If you pass through a host serial device, it is no longer possible to migrate such machines - use with special care.
1065 CAUTION: Experimental! User reported problems with this option.
1072 pattern
=> '/dev/parport\d+|/dev/usb/lp\d+',
1073 description
=> "Map host parallel devices (n is 0 to 2).",
1074 verbose_description
=> <<EODESCR,
1075 Map host parallel devices (n is 0 to 2).
1077 NOTE: This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
1079 CAUTION: Experimental! User reported problems with this option.
1083 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
1084 $confdesc->{"parallel$i"} = $paralleldesc;
1087 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
1088 $confdesc->{"serial$i"} = $serialdesc;
1091 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
1092 $confdesc->{"hostpci$i"} = $hostpcidesc;
1095 for (my $i = 0; $i < $MAX_IDE_DISKS; $i++) {
1096 $drivename_hash->{"ide$i"} = 1;
1097 $confdesc->{"ide$i"} = $idedesc;
1100 for (my $i = 0; $i < $MAX_SATA_DISKS; $i++) {
1101 $drivename_hash->{"sata$i"} = 1;
1102 $confdesc->{"sata$i"} = $satadesc;
1105 for (my $i = 0; $i < $MAX_SCSI_DISKS; $i++) {
1106 $drivename_hash->{"scsi$i"} = 1;
1107 $confdesc->{"scsi$i"} = $scsidesc ;
1110 for (my $i = 0; $i < $MAX_VIRTIO_DISKS; $i++) {
1111 $drivename_hash->{"virtio$i"} = 1;
1112 $confdesc->{"virtio$i"} = $virtiodesc;
1115 $drivename_hash->{efidisk0
} = 1;
1116 $confdesc->{efidisk0
} = $efidisk_desc;
1118 for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
1119 $confdesc->{"usb$i"} = $usbdesc;
1124 type
=> 'string', format
=> 'pve-volume-id',
1125 description
=> "Reference to unused volumes. This is used internally, and should not be modified manually.",
1128 for (my $i = 0; $i < $MAX_UNUSED_DISKS; $i++) {
1129 $confdesc->{"unused$i"} = $unuseddesc;
1132 my $kvm_api_version = 0;
1136 return $kvm_api_version if $kvm_api_version;
1138 my $fh = IO
::File-
>new("</dev/kvm") ||
1141 if (my $v = $fh->ioctl(KVM_GET_API_VERSION
(), 0)) {
1142 $kvm_api_version = $v;
1147 return $kvm_api_version;
1150 my $kvm_user_version;
1152 sub kvm_user_version
{
1154 return $kvm_user_version if $kvm_user_version;
1156 $kvm_user_version = 'unknown';
1160 if ($line =~ m/^QEMU( PC)? emulator version (\d+\.\d+(\.\d+)?)(\.\d+)?[,\s]/) {
1161 $kvm_user_version = $2;
1165 eval { run_command
("kvm -version", outfunc
=> $code); };
1168 return $kvm_user_version;
1172 my $kernel_has_vhost_net = -c
'/dev/vhost-net';
1174 sub valid_drive_names
{
1175 # order is important - used to autoselect boot disk
1176 return ((map { "ide$_" } (0 .. ($MAX_IDE_DISKS - 1))),
1177 (map { "scsi$_" } (0 .. ($MAX_SCSI_DISKS - 1))),
1178 (map { "virtio$_" } (0 .. ($MAX_VIRTIO_DISKS - 1))),
1179 (map { "sata$_" } (0 .. ($MAX_SATA_DISKS - 1))),
1183 sub is_valid_drivename
{
1186 return defined($drivename_hash->{$dev});
1191 return defined($confdesc->{$key});
1195 return $nic_model_list;
1198 sub os_list_description
{
1202 wxp
=> 'Windows XP',
1203 w2k
=> 'Windows 2000',
1204 w2k3
=>, 'Windows 2003',
1205 w2k8
=> 'Windows 2008',
1206 wvista
=> 'Windows Vista',
1207 win7
=> 'Windows 7',
1208 win8
=> 'Windows 8/2012',
1209 win10
=> 'Windows 10/2016',
1217 sub get_cdrom_path
{
1219 return $cdrom_path if $cdrom_path;
1221 return $cdrom_path = "/dev/cdrom" if -l
"/dev/cdrom";
1222 return $cdrom_path = "/dev/cdrom1" if -l
"/dev/cdrom1";
1223 return $cdrom_path = "/dev/cdrom2" if -l
"/dev/cdrom2";
1227 my ($storecfg, $vmid, $cdrom) = @_;
1229 if ($cdrom eq 'cdrom') {
1230 return get_cdrom_path
();
1231 } elsif ($cdrom eq 'none') {
1233 } elsif ($cdrom =~ m
|^/|) {
1236 return PVE
::Storage
::path
($storecfg, $cdrom);
1240 # try to convert old style file names to volume IDs
1241 sub filename_to_volume_id
{
1242 my ($vmid, $file, $media) = @_;
1244 if (!($file eq 'none' || $file eq 'cdrom' ||
1245 $file =~ m
|^/dev/.+| || $file =~ m/^([^:]+):(.+)$/)) {
1247 return undef if $file =~ m
|/|;
1249 if ($media && $media eq 'cdrom') {
1250 $file = "local:iso/$file";
1252 $file = "local:$vmid/$file";
1259 sub verify_media_type
{
1260 my ($opt, $vtype, $media) = @_;
1265 if ($media eq 'disk') {
1267 } elsif ($media eq 'cdrom') {
1270 die "internal error";
1273 return if ($vtype eq $etype);
1275 raise_param_exc
({ $opt => "unexpected media type ($vtype != $etype)" });
1278 sub cleanup_drive_path
{
1279 my ($opt, $storecfg, $drive) = @_;
1281 # try to convert filesystem paths to volume IDs
1283 if (($drive->{file
} !~ m/^(cdrom|none)$/) &&
1284 ($drive->{file
} !~ m
|^/dev/.+|) &&
1285 ($drive->{file
} !~ m/^([^:]+):(.+)$/) &&
1286 ($drive->{file
} !~ m/^\d+$/)) {
1287 my ($vtype, $volid) = PVE
::Storage
::path_to_volume_id
($storecfg, $drive->{file
});
1288 raise_param_exc
({ $opt => "unable to associate path '$drive->{file}' to any storage"}) if !$vtype;
1289 $drive->{media
} = 'cdrom' if !$drive->{media
} && $vtype eq 'iso';
1290 verify_media_type
($opt, $vtype, $drive->{media
});
1291 $drive->{file
} = $volid;
1294 $drive->{media
} = 'cdrom' if !$drive->{media
} && $drive->{file
} =~ m/^(cdrom|none)$/;
1297 sub parse_hotplug_features
{
1302 return $res if $data eq '0';
1304 $data = $confdesc->{hotplug
}->{default} if $data eq '1';
1306 foreach my $feature (PVE
::Tools
::split_list
($data)) {
1307 if ($feature =~ m/^(network|disk|cpu|memory|usb)$/) {
1310 die "invalid hotplug feature '$feature'\n";
1316 PVE
::JSONSchema
::register_format
('pve-hotplug-features', \
&pve_verify_hotplug_features
);
1317 sub pve_verify_hotplug_features
{
1318 my ($value, $noerr) = @_;
1320 return $value if parse_hotplug_features
($value);
1322 return undef if $noerr;
1324 die "unable to parse hotplug option\n";
1327 # ideX = [volume=]volume-id[,media=d][,cyls=c,heads=h,secs=s[,trans=t]]
1328 # [,snapshot=on|off][,cache=on|off][,format=f][,backup=yes|no]
1329 # [,rerror=ignore|report|stop][,werror=enospc|ignore|report|stop]
1330 # [,aio=native|threads][,discard=ignore|on][,detect_zeroes=on|off]
1331 # [,iothread=on][,serial=serial][,model=model]
1334 my ($key, $data) = @_;
1336 my ($interface, $index);
1338 if ($key =~ m/^([^\d]+)(\d+)$/) {
1345 my $desc = $key =~ /^unused\d+$/ ?
$alldrive_fmt
1346 : $confdesc->{$key}->{format
};
1348 warn "invalid drive key: $key\n";
1351 my $res = eval { PVE
::JSONSchema
::parse_property_string
($desc, $data) };
1352 return undef if !$res;
1353 $res->{interface
} = $interface;
1354 $res->{index} = $index;
1357 foreach my $opt (qw(bps bps_rd bps_wr)) {
1358 if (my $bps = defined(delete $res->{$opt})) {
1359 if (defined($res->{"m$opt"})) {
1360 warn "both $opt and m$opt specified\n";
1364 $res->{"m$opt"} = sprintf("%.3f", $bps / (1024*1024.0));
1368 # can't use the schema's 'requires' because of the mbps* => bps* "transforming aliases"
1369 for my $requirement (
1370 [mbps_max
=> 'mbps'],
1371 [mbps_rd_max
=> 'mbps_rd'],
1372 [mbps_wr_max
=> 'mbps_wr'],
1373 [miops_max
=> 'miops'],
1374 [miops_rd_max
=> 'miops_rd'],
1375 [miops_wr_max
=> 'miops_wr'],
1376 [bps_max_length
=> 'mbps_max'],
1377 [bps_rd_max_length
=> 'mbps_rd_max'],
1378 [bps_wr_max_length
=> 'mbps_wr_max'],
1379 [iops_max_length
=> 'iops_max'],
1380 [iops_rd_max_length
=> 'iops_rd_max'],
1381 [iops_wr_max_length
=> 'iops_wr_max']) {
1382 my ($option, $requires) = @$requirement;
1383 if ($res->{$option} && !$res->{$requires}) {
1384 warn "$option requires $requires\n";
1389 return undef if $error;
1391 return undef if $res->{mbps_rd
} && $res->{mbps
};
1392 return undef if $res->{mbps_wr
} && $res->{mbps
};
1393 return undef if $res->{iops_rd
} && $res->{iops
};
1394 return undef if $res->{iops_wr
} && $res->{iops
};
1396 if ($res->{media
} && ($res->{media
} eq 'cdrom')) {
1397 return undef if $res->{snapshot
} || $res->{trans
} || $res->{format
};
1398 return undef if $res->{heads
} || $res->{secs
} || $res->{cyls
};
1399 return undef if $res->{interface
} eq 'virtio';
1402 if (my $size = $res->{size
}) {
1403 return undef if !defined($res->{size
} = PVE
::JSONSchema
::parse_size
($size));
1410 my ($vmid, $drive) = @_;
1411 my $data = { %$drive };
1412 delete $data->{$_} for qw(index interface);
1413 return PVE
::JSONSchema
::print_property_string
($data, $alldrive_fmt);
1417 my($fh, $noerr) = @_;
1420 my $SG_GET_VERSION_NUM = 0x2282;
1422 my $versionbuf = "\x00" x
8;
1423 my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
1425 die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
1428 my $version = unpack("I", $versionbuf);
1429 if ($version < 30000) {
1430 die "scsi generic interface too old\n" if !$noerr;
1434 my $buf = "\x00" x
36;
1435 my $sensebuf = "\x00" x
8;
1436 my $cmd = pack("C x3 C x1", 0x12, 36);
1438 # see /usr/include/scsi/sg.h
1439 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";
1441 my $packet = pack($sg_io_hdr_t, ord('S'), -3, length($cmd),
1442 length($sensebuf), 0, length($buf), $buf,
1443 $cmd, $sensebuf, 6000);
1445 $ret = ioctl($fh, $SG_IO, $packet);
1447 die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
1451 my @res = unpack($sg_io_hdr_t, $packet);
1452 if ($res[17] || $res[18]) {
1453 die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
1458 (my $byte0, my $byte1, $res->{vendor
},
1459 $res->{product
}, $res->{revision
}) = unpack("C C x6 A8 A16 A4", $buf);
1461 $res->{removable
} = $byte1 & 128 ?
1 : 0;
1462 $res->{type
} = $byte0 & 31;
1470 my $fh = IO
::File-
>new("+<$path") || return undef;
1471 my $res = scsi_inquiry
($fh, 1);
1477 sub machine_type_is_q35
{
1480 return $conf->{machine
} && ($conf->{machine
} =~ m/q35/) ?
1 : 0;
1483 sub print_tabletdevice_full
{
1486 my $q35 = machine_type_is_q35
($conf);
1488 # we use uhci for old VMs because tablet driver was buggy in older qemu
1489 my $usbbus = $q35 ?
"ehci" : "uhci";
1491 return "usb-tablet,id=tablet,bus=$usbbus.0,port=1";
1494 sub print_drivedevice_full
{
1495 my ($storecfg, $conf, $vmid, $drive, $bridges) = @_;
1500 if ($drive->{interface
} eq 'virtio') {
1501 my $pciaddr = print_pci_addr
("$drive->{interface}$drive->{index}", $bridges);
1502 $device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
1503 $device .= ",iothread=iothread-$drive->{interface}$drive->{index}" if $drive->{iothread
};
1504 } elsif ($drive->{interface
} eq 'scsi') {
1506 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
1507 my $unit = $drive->{index} % $maxdev;
1508 my $devicetype = 'hd';
1510 if (drive_is_cdrom
($drive)) {
1513 if ($drive->{file
} =~ m
|^/|) {
1514 $path = $drive->{file
};
1515 if (my $info = path_is_scsi
($path)) {
1516 if ($info->{type
} == 0 && $drive->{scsiblock
}) {
1517 $devicetype = 'block';
1518 } elsif ($info->{type
} == 1) { # tape
1519 $devicetype = 'generic';
1523 $path = PVE
::Storage
::path
($storecfg, $drive->{file
});
1526 if($path =~ m/^iscsi\:\/\
//){
1527 $devicetype = 'generic';
1531 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)){
1532 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,scsi-id=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1534 $device = "scsi-$devicetype,bus=$controller_prefix$controller.0,channel=0,scsi-id=0,lun=$drive->{index},drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1537 } elsif ($drive->{interface
} eq 'ide'){
1539 my $controller = int($drive->{index} / $maxdev);
1540 my $unit = $drive->{index} % $maxdev;
1541 my $devicetype = ($drive->{media
} && $drive->{media
} eq 'cdrom') ?
"cd" : "hd";
1543 $device = "ide-$devicetype,bus=ide.$controller,unit=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1544 if ($devicetype eq 'hd' && (my $model = $drive->{model
})) {
1545 $model = URI
::Escape
::uri_unescape
($model);
1546 $device .= ",model=$model";
1548 } elsif ($drive->{interface
} eq 'sata'){
1549 my $controller = int($drive->{index} / $MAX_SATA_DISKS);
1550 my $unit = $drive->{index} % $MAX_SATA_DISKS;
1551 $device = "ide-drive,bus=ahci$controller.$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
1552 } elsif ($drive->{interface
} eq 'usb') {
1554 # -device ide-drive,bus=ide.1,unit=0,drive=drive-ide0-1-0,id=ide0-1-0
1556 die "unsupported interface type";
1559 $device .= ",bootindex=$drive->{bootindex}" if $drive->{bootindex
};
1564 sub get_initiator_name
{
1567 my $fh = IO
::File-
>new('/etc/iscsi/initiatorname.iscsi') || return undef;
1568 while (defined(my $line = <$fh>)) {
1569 next if $line !~ m/^\s*InitiatorName\s*=\s*([\.\-:\w]+)/;
1578 sub print_drive_full
{
1579 my ($storecfg, $vmid, $drive) = @_;
1582 my $volid = $drive->{file
};
1585 if (drive_is_cdrom
($drive)) {
1586 $path = get_iso_path
($storecfg, $vmid, $volid);
1588 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
1590 $path = PVE
::Storage
::path
($storecfg, $volid);
1591 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
1592 $format = qemu_img_format
($scfg, $volname);
1600 my @qemu_drive_options = qw(heads secs cyls trans media format cache snapshot rerror werror aio discard);
1601 foreach my $o (@qemu_drive_options) {
1602 $opts .= ",$o=$drive->{$o}" if $drive->{$o};
1604 foreach my $type (['', '-total'], [_rd
=> '-read'], [_wr
=> '-write']) {
1605 my ($dir, $qmpname) = @$type;
1606 if (my $v = $drive->{"mbps$dir"}) {
1607 $opts .= ",throttling.bps$qmpname=".int($v*1024*1024);
1609 if (my $v = $drive->{"mbps${dir}_max"}) {
1610 $opts .= ",throttling.bps$qmpname-max=".int($v*1024*1024);
1612 if (my $v = $drive->{"bps${dir}_max_length"}) {
1613 $opts .= ",throttling.bps$qmpname-max-length=$v";
1615 if (my $v = $drive->{"iops${dir}"}) {
1616 $opts .= ",throttling.iops$qmpname=$v";
1618 if (my $v = $drive->{"iops${dir}_max"}) {
1619 $opts .= ",throttling.iops$qmpname-max=$v";
1621 if (my $v = $drive->{"iops${dir}_max_length"}) {
1622 $opts .= ",throttling.iops$qmpname-max-length=$v";
1626 if (my $serial = $drive->{serial
}) {
1627 $serial = URI
::Escape
::uri_unescape
($serial);
1628 $opts .= ",serial=$serial";
1631 $opts .= ",format=$format" if $format && !$drive->{format
};
1633 my $cache_direct = 0;
1635 if (my $cache = $drive->{cache
}) {
1636 $cache_direct = $cache =~ /^(?:off|none|directsync)$/;
1637 } elsif (!drive_is_cdrom
($drive)) {
1638 $opts .= ",cache=none";
1642 # aio native works only with O_DIRECT
1643 if (!$drive->{aio
}) {
1645 $opts .= ",aio=native";
1647 $opts .= ",aio=threads";
1651 if (!drive_is_cdrom
($drive)) {
1653 if (defined($drive->{detect_zeroes
}) && !$drive->{detect_zeroes
}) {
1654 $detectzeroes = 'off';
1655 } elsif ($drive->{discard
}) {
1656 $detectzeroes = $drive->{discard
} eq 'on' ?
'unmap' : 'on';
1658 # This used to be our default with discard not being specified:
1659 $detectzeroes = 'on';
1661 $opts .= ",detect-zeroes=$detectzeroes" if $detectzeroes;
1664 my $pathinfo = $path ?
"file=$path," : '';
1666 return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
1669 sub print_netdevice_full
{
1670 my ($vmid, $conf, $net, $netid, $bridges, $use_old_bios_files) = @_;
1672 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
1674 my $device = $net->{model
};
1675 if ($net->{model
} eq 'virtio') {
1676 $device = 'virtio-net-pci';
1679 my $pciaddr = print_pci_addr
("$netid", $bridges);
1680 my $tmpstr = "$device,mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
1681 if ($net->{queues
} && $net->{queues
} > 1 && $net->{model
} eq 'virtio'){
1682 #Consider we have N queues, the number of vectors needed is 2*N + 2 (plus one config interrupt and control vq)
1683 my $vectors = $net->{queues
} * 2 + 2;
1684 $tmpstr .= ",vectors=$vectors,mq=on";
1686 $tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex
} ;
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, $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 $vhostparam = ',vhost=on' if $kernel_has_vhost_net && $net->{model
} eq 'virtio';
1726 my $vmname = $conf->{name
} || "vm$vmid";
1729 my $script = $hotplug ?
"pve-bridge-hotplug" : "pve-bridge";
1731 if ($net->{bridge
}) {
1732 $netdev = "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/$script,downscript=/var/lib/qemu-server/pve-bridgedown$vhostparam";
1734 $netdev = "type=user,id=$netid,hostname=$vmname";
1737 $netdev .= ",queues=$net->{queues}" if ($net->{queues
} && $net->{model
} eq 'virtio');
1743 sub print_cpu_device
{
1744 my ($conf, $id) = @_;
1746 my $kvm = $conf->{kvm
} // 1;
1747 my $cpu = $kvm ?
"kvm64" : "qemu64";
1748 if (my $cputype = $conf->{cpu
}) {
1749 my $cpuconf = PVE
::JSONSchema
::parse_property_string
($cpu_fmt, $cputype)
1750 or die "Cannot parse cpu description: $cputype\n";
1751 $cpu = $cpuconf->{cputype
};
1754 my $cores = $conf->{cores
} || 1;
1756 my $current_core = ($id - 1) % $cores;
1757 my $current_socket = int(($id - 1 - $current_core)/$cores);
1759 return "$cpu-x86_64-cpu,id=cpu$id,socket-id=$current_socket,core-id=$current_core,thread-id=0";
1762 sub drive_is_cdrom
{
1765 return $drive && $drive->{media
} && ($drive->{media
} eq 'cdrom');
1769 sub parse_number_sets
{
1772 foreach my $part (split(/;/, $set)) {
1773 if ($part =~ /^\s*(\d+)(?:-(\d+))?\s*$/) {
1774 die "invalid range: $part ($2 < $1)\n" if defined($2) && $2 < $1;
1775 push @$res, [ $1, $2 ];
1777 die "invalid range: $part\n";
1786 my $res = PVE
::JSONSchema
::parse_property_string
($numa_fmt, $data);
1787 $res->{cpus
} = parse_number_sets
($res->{cpus
}) if defined($res->{cpus
});
1788 $res->{hostnodes
} = parse_number_sets
($res->{hostnodes
}) if defined($res->{hostnodes
});
1795 return undef if !$value;
1797 my $res = PVE
::JSONSchema
::parse_property_string
($hostpci_fmt, $value);
1799 my @idlist = split(/;/, $res->{host
});
1800 delete $res->{host
};
1801 foreach my $id (@idlist) {
1802 if ($id =~ /^$PCIRE$/) {
1804 push @{$res->{pciid
}}, { id
=> $1, function
=> $2 };
1806 my $pcidevices = lspci
($1);
1807 $res->{pciid
} = $pcidevices->{$1};
1810 # should have been caught by parse_property_string already
1811 die "failed to parse PCI id: $id\n";
1817 # netX: e1000=XX:XX:XX:XX:XX:XX,bridge=vmbr0,rate=<mbps>
1821 my $res = eval { PVE
::JSONSchema
::parse_property_string
($net_fmt, $data) };
1826 if (!defined($res->{macaddr
})) {
1827 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
1828 $res->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
});
1836 return PVE
::JSONSchema
::print_property_string
($net, $net_fmt);
1839 sub add_random_macs
{
1840 my ($settings) = @_;
1842 foreach my $opt (keys %$settings) {
1843 next if $opt !~ m/^net(\d+)$/;
1844 my $net = parse_net
($settings->{$opt});
1846 $settings->{$opt} = print_net
($net);
1850 sub vm_is_volid_owner
{
1851 my ($storecfg, $vmid, $volid) = @_;
1853 if ($volid !~ m
|^/|) {
1855 eval { ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid); };
1856 if ($owner && ($owner == $vmid)) {
1864 sub split_flagged_list
{
1865 my $text = shift || '';
1866 $text =~ s/[,;]/ /g;
1868 return { map { /^(!?)(.*)$/ && ($2, $1) } ($text =~ /\S+/g) };
1871 sub join_flagged_list
{
1872 my ($how, $lst) = @_;
1873 join $how, map { $lst->{$_} . $_ } keys %$lst;
1876 sub vmconfig_delete_pending_option
{
1877 my ($conf, $key, $force) = @_;
1879 delete $conf->{pending
}->{$key};
1880 my $pending_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
1881 $pending_delete_hash->{$key} = $force ?
'!' : '';
1882 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
1885 sub vmconfig_undelete_pending_option
{
1886 my ($conf, $key) = @_;
1888 my $pending_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
1889 delete $pending_delete_hash->{$key};
1891 if (%$pending_delete_hash) {
1892 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
1894 delete $conf->{pending
}->{delete};
1898 sub vmconfig_register_unused_drive
{
1899 my ($storecfg, $vmid, $conf, $drive) = @_;
1901 if (!drive_is_cdrom
($drive)) {
1902 my $volid = $drive->{file
};
1903 if (vm_is_volid_owner
($storecfg, $vmid, $volid)) {
1904 PVE
::QemuConfig-
>add_unused_volume($conf, $volid, $vmid);
1909 sub vmconfig_cleanup_pending
{
1912 # remove pending changes when nothing changed
1914 foreach my $opt (keys %{$conf->{pending
}}) {
1915 if (defined($conf->{$opt}) && ($conf->{pending
}->{$opt} eq $conf->{$opt})) {
1917 delete $conf->{pending
}->{$opt};
1921 my $current_delete_hash = split_flagged_list
($conf->{pending
}->{delete});
1922 my $pending_delete_hash = {};
1923 while (my ($opt, $force) = each %$current_delete_hash) {
1924 if (defined($conf->{$opt})) {
1925 $pending_delete_hash->{$opt} = $force;
1931 if (%$pending_delete_hash) {
1932 $conf->{pending
}->{delete} = join_flagged_list
(',', $pending_delete_hash);
1934 delete $conf->{pending
}->{delete};
1940 # smbios: [manufacturer=str][,product=str][,version=str][,serial=str][,uuid=uuid][,sku=str][,family=str]
1944 pattern
=> '[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}',
1945 format_description
=> 'UUID',
1946 description
=> "Set SMBIOS1 UUID.",
1952 format_description
=> 'string',
1953 description
=> "Set SMBIOS1 version.",
1959 format_description
=> 'string',
1960 description
=> "Set SMBIOS1 serial number.",
1966 format_description
=> 'string',
1967 description
=> "Set SMBIOS1 manufacturer.",
1973 format_description
=> 'string',
1974 description
=> "Set SMBIOS1 product ID.",
1980 format_description
=> 'string',
1981 description
=> "Set SMBIOS1 SKU string.",
1987 format_description
=> 'string',
1988 description
=> "Set SMBIOS1 family string.",
1996 my $res = eval { PVE
::JSONSchema
::parse_property_string
($smbios1_fmt, $data) };
2003 return PVE
::JSONSchema
::print_property_string
($smbios1, $smbios1_fmt);
2006 PVE
::JSONSchema
::register_format
('pve-qm-smbios1', $smbios1_fmt);
2008 PVE
::JSONSchema
::register_format
('pve-qm-bootdisk', \
&verify_bootdisk
);
2009 sub verify_bootdisk
{
2010 my ($value, $noerr) = @_;
2012 return $value if is_valid_drivename
($value);
2014 return undef if $noerr;
2016 die "invalid boot disk '$value'\n";
2019 sub parse_watchdog
{
2022 return undef if !$value;
2024 my $res = eval { PVE
::JSONSchema
::parse_property_string
($watchdog_fmt, $value) };
2029 PVE
::JSONSchema
::register_format
('pve-qm-usb-device', \
&verify_usb_device
);
2030 sub verify_usb_device
{
2031 my ($value, $noerr) = @_;
2033 return $value if parse_usb_device
($value);
2035 return undef if $noerr;
2037 die "unable to parse usb device\n";
2040 # add JSON properties for create and set function
2041 sub json_config_properties
{
2044 foreach my $opt (keys %$confdesc) {
2045 next if $opt eq 'parent' || $opt eq 'snaptime' || $opt eq 'vmstate';
2046 $prop->{$opt} = $confdesc->{$opt};
2053 my ($key, $value) = @_;
2055 die "unknown setting '$key'\n" if !$confdesc->{$key};
2057 my $type = $confdesc->{$key}->{type
};
2059 if (!defined($value)) {
2060 die "got undefined value\n";
2063 if ($value =~ m/[\n\r]/) {
2064 die "property contains a line feed\n";
2067 if ($type eq 'boolean') {
2068 return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
2069 return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
2070 die "type check ('boolean') failed - got '$value'\n";
2071 } elsif ($type eq 'integer') {
2072 return int($1) if $value =~ m/^(\d+)$/;
2073 die "type check ('integer') failed - got '$value'\n";
2074 } elsif ($type eq 'number') {
2075 return $value if $value =~ m/^(\d+)(\.\d+)?$/;
2076 die "type check ('number') failed - got '$value'\n";
2077 } elsif ($type eq 'string') {
2078 if (my $fmt = $confdesc->{$key}->{format
}) {
2079 PVE
::JSONSchema
::check_format
($fmt, $value);
2082 $value =~ s/^\"(.*)\"$/$1/;
2085 die "internal error"
2089 sub check_iommu_support
{
2090 #fixme : need to check IOMMU support
2091 #http://www.linux-kvm.org/page/How_to_assign_devices_with_VT-d_in_KVM
2101 my $conf = PVE
::QemuConfig-
>config_file($vmid);
2102 utime undef, undef, $conf;
2106 my ($storecfg, $vmid, $keep_empty_config, $skiplock) = @_;
2108 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
2110 my $conf = PVE
::QemuConfig-
>load_config($vmid);
2112 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
2114 # only remove disks owned by this VM
2115 foreach_drive
($conf, sub {
2116 my ($ds, $drive) = @_;
2118 return if drive_is_cdrom
($drive);
2120 my $volid = $drive->{file
};
2122 return if !$volid || $volid =~ m
|^/|;
2124 my ($path, $owner) = PVE
::Storage
::path
($storecfg, $volid);
2125 return if !$path || !$owner || ($owner != $vmid);
2128 PVE
::Storage
::vdisk_free
($storecfg, $volid);
2130 warn "Could not remove disk '$volid', check manually: $@" if $@;
2134 if ($keep_empty_config) {
2135 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
2140 # also remove unused disk
2142 my $dl = PVE
::Storage
::vdisk_list
($storecfg, undef, $vmid);
2145 PVE
::Storage
::foreach_volid
($dl, sub {
2146 my ($volid, $sid, $volname, $d) = @_;
2147 PVE
::Storage
::vdisk_free
($storecfg, $volid);
2156 sub parse_vm_config
{
2157 my ($filename, $raw) = @_;
2159 return undef if !defined($raw);
2162 digest
=> Digest
::SHA
::sha1_hex
($raw),
2167 $filename =~ m
|/qemu-server/(\d
+)\
.conf
$|
2168 || die "got strange filename '$filename'";
2176 my @lines = split(/\n/, $raw);
2177 foreach my $line (@lines) {
2178 next if $line =~ m/^\s*$/;
2180 if ($line =~ m/^\[PENDING\]\s*$/i) {
2181 $section = 'pending';
2182 if (defined($descr)) {
2184 $conf->{description
} = $descr;
2187 $conf = $res->{$section} = {};
2190 } elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
2192 if (defined($descr)) {
2194 $conf->{description
} = $descr;
2197 $conf = $res->{snapshots
}->{$section} = {};
2201 if ($line =~ m/^\#(.*)\s*$/) {
2202 $descr = '' if !defined($descr);
2203 $descr .= PVE
::Tools
::decode_text
($1) . "\n";
2207 if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
2208 $descr = '' if !defined($descr);
2209 $descr .= PVE
::Tools
::decode_text
($2);
2210 } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
2211 $conf->{snapstate
} = $1;
2212 } elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
2215 $conf->{$key} = $value;
2216 } elsif ($line =~ m/^delete:\s*(.*\S)\s*$/) {
2218 if ($section eq 'pending') {
2219 $conf->{delete} = $value; # we parse this later
2221 warn "vm $vmid - propertry 'delete' is only allowed in [PENDING]\n";
2223 } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(\S+)\s*$/) {
2226 eval { $value = check_type
($key, $value); };
2228 warn "vm $vmid - unable to parse value of '$key' - $@";
2230 $key = 'ide2' if $key eq 'cdrom';
2231 my $fmt = $confdesc->{$key}->{format
};
2232 if ($fmt && $fmt =~ /^pve-qm-(?:ide|scsi|virtio|sata)$/) {
2233 my $v = parse_drive
($key, $value);
2234 if (my $volid = filename_to_volume_id
($vmid, $v->{file
}, $v->{media
})) {
2235 $v->{file
} = $volid;
2236 $value = print_drive
($vmid, $v);
2238 warn "vm $vmid - unable to parse value of '$key'\n";
2243 $conf->{$key} = $value;
2248 if (defined($descr)) {
2250 $conf->{description
} = $descr;
2252 delete $res->{snapstate
}; # just to be sure
2257 sub write_vm_config
{
2258 my ($filename, $conf) = @_;
2260 delete $conf->{snapstate
}; # just to be sure
2262 if ($conf->{cdrom
}) {
2263 die "option ide2 conflicts with cdrom\n" if $conf->{ide2
};
2264 $conf->{ide2
} = $conf->{cdrom
};
2265 delete $conf->{cdrom
};
2268 # we do not use 'smp' any longer
2269 if ($conf->{sockets
}) {
2270 delete $conf->{smp
};
2271 } elsif ($conf->{smp
}) {
2272 $conf->{sockets
} = $conf->{smp
};
2273 delete $conf->{cores
};
2274 delete $conf->{smp
};
2277 my $used_volids = {};
2279 my $cleanup_config = sub {
2280 my ($cref, $pending, $snapname) = @_;
2282 foreach my $key (keys %$cref) {
2283 next if $key eq 'digest' || $key eq 'description' || $key eq 'snapshots' ||
2284 $key eq 'snapstate' || $key eq 'pending';
2285 my $value = $cref->{$key};
2286 if ($key eq 'delete') {
2287 die "propertry 'delete' is only allowed in [PENDING]\n"
2289 # fixme: check syntax?
2292 eval { $value = check_type
($key, $value); };
2293 die "unable to parse value of '$key' - $@" if $@;
2295 $cref->{$key} = $value;
2297 if (!$snapname && is_valid_drivename
($key)) {
2298 my $drive = parse_drive
($key, $value);
2299 $used_volids->{$drive->{file
}} = 1 if $drive && $drive->{file
};
2304 &$cleanup_config($conf);
2306 &$cleanup_config($conf->{pending
}, 1);
2308 foreach my $snapname (keys %{$conf->{snapshots
}}) {
2309 die "internal error" if $snapname eq 'pending';
2310 &$cleanup_config($conf->{snapshots
}->{$snapname}, undef, $snapname);
2313 # remove 'unusedX' settings if we re-add a volume
2314 foreach my $key (keys %$conf) {
2315 my $value = $conf->{$key};
2316 if ($key =~ m/^unused/ && $used_volids->{$value}) {
2317 delete $conf->{$key};
2321 my $generate_raw_config = sub {
2322 my ($conf, $pending) = @_;
2326 # add description as comment to top of file
2327 if (defined(my $descr = $conf->{description
})) {
2329 foreach my $cl (split(/\n/, $descr)) {
2330 $raw .= '#' . PVE
::Tools
::encode_text
($cl) . "\n";
2333 $raw .= "#\n" if $pending;
2337 foreach my $key (sort keys %$conf) {
2338 next if $key eq 'digest' || $key eq 'description' || $key eq 'pending' || $key eq 'snapshots';
2339 $raw .= "$key: $conf->{$key}\n";
2344 my $raw = &$generate_raw_config($conf);
2346 if (scalar(keys %{$conf->{pending
}})){
2347 $raw .= "\n[PENDING]\n";
2348 $raw .= &$generate_raw_config($conf->{pending
}, 1);
2351 foreach my $snapname (sort keys %{$conf->{snapshots
}}) {
2352 $raw .= "\n[$snapname]\n";
2353 $raw .= &$generate_raw_config($conf->{snapshots
}->{$snapname});
2363 # we use static defaults from our JSON schema configuration
2364 foreach my $key (keys %$confdesc) {
2365 if (defined(my $default = $confdesc->{$key}->{default})) {
2366 $res->{$key} = $default;
2370 my $conf = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
2371 $res->{keyboard
} = $conf->{keyboard
} if $conf->{keyboard
};
2377 my $vmlist = PVE
::Cluster
::get_vmlist
();
2379 return $res if !$vmlist || !$vmlist->{ids
};
2380 my $ids = $vmlist->{ids
};
2382 foreach my $vmid (keys %$ids) {
2383 my $d = $ids->{$vmid};
2384 next if !$d->{node
} || $d->{node
} ne $nodename;
2385 next if !$d->{type
} || $d->{type
} ne 'qemu';
2386 $res->{$vmid}->{exists} = 1;
2391 # test if VM uses local resources (to prevent migration)
2392 sub check_local_resources
{
2393 my ($conf, $noerr) = @_;
2397 $loc_res = 1 if $conf->{hostusb
}; # old syntax
2398 $loc_res = 1 if $conf->{hostpci
}; # old syntax
2400 foreach my $k (keys %$conf) {
2401 next if $k =~ m/^usb/ && ($conf->{$k} eq 'spice');
2402 # sockets are safe: they will recreated be on the target side post-migrate
2403 next if $k =~ m/^serial/ && ($conf->{$k} eq 'socket');
2404 $loc_res = 1 if $k =~ m/^(usb|hostpci|serial|parallel)\d+$/;
2407 die "VM uses local resources\n" if $loc_res && !$noerr;
2412 # check if used storages are available on all nodes (use by migrate)
2413 sub check_storage_availability
{
2414 my ($storecfg, $conf, $node) = @_;
2416 foreach_drive
($conf, sub {
2417 my ($ds, $drive) = @_;
2419 my $volid = $drive->{file
};
2422 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2425 # check if storage is available on both nodes
2426 my $scfg = PVE
::Storage
::storage_check_node
($storecfg, $sid);
2427 PVE
::Storage
::storage_check_node
($storecfg, $sid, $node);
2431 # list nodes where all VM images are available (used by has_feature API)
2433 my ($conf, $storecfg) = @_;
2435 my $nodelist = PVE
::Cluster
::get_nodelist
();
2436 my $nodehash = { map { $_ => 1 } @$nodelist };
2437 my $nodename = PVE
::INotify
::nodename
();
2439 foreach_drive
($conf, sub {
2440 my ($ds, $drive) = @_;
2442 my $volid = $drive->{file
};
2445 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
2447 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
2448 if ($scfg->{disable
}) {
2450 } elsif (my $avail = $scfg->{nodes
}) {
2451 foreach my $node (keys %$nodehash) {
2452 delete $nodehash->{$node} if !$avail->{$node};
2454 } elsif (!$scfg->{shared
}) {
2455 foreach my $node (keys %$nodehash) {
2456 delete $nodehash->{$node} if $node ne $nodename
2466 my ($pidfile, $pid) = @_;
2468 my $fh = IO
::File-
>new("/proc/$pid/cmdline", "r");
2472 return undef if !$line;
2473 my @param = split(/\0/, $line);
2475 my $cmd = $param[0];
2476 return if !$cmd || ($cmd !~ m
|kvm
$| && $cmd !~ m
|qemu-system-x86_64
$|);
2478 for (my $i = 0; $i < scalar (@param); $i++) {
2481 if (($p eq '-pidfile') || ($p eq '--pidfile')) {
2482 my $p = $param[$i+1];
2483 return 1 if $p && ($p eq $pidfile);
2492 my ($vmid, $nocheck, $node) = @_;
2494 my $filename = PVE
::QemuConfig-
>config_file($vmid, $node);
2496 die "unable to find configuration file for VM $vmid - no such machine\n"
2497 if !$nocheck && ! -f
$filename;
2499 my $pidfile = pidfile_name
($vmid);
2501 if (my $fd = IO
::File-
>new("<$pidfile")) {
2506 my $mtime = $st->mtime;
2507 if ($mtime > time()) {
2508 warn "file '$filename' modified in future\n";
2511 if ($line =~ m/^(\d+)$/) {
2513 if (check_cmdline
($pidfile, $pid)) {
2514 if (my $pinfo = PVE
::ProcFSTools
::check_process_running
($pid)) {
2526 my $vzlist = config_list
();
2528 my $fd = IO
::Dir-
>new($var_run_tmpdir) || return $vzlist;
2530 while (defined(my $de = $fd->read)) {
2531 next if $de !~ m/^(\d+)\.pid$/;
2533 next if !defined($vzlist->{$vmid});
2534 if (my $pid = check_running
($vmid)) {
2535 $vzlist->{$vmid}->{pid
} = $pid;
2543 my ($storecfg, $conf) = @_;
2545 my $bootdisk = $conf->{bootdisk
};
2546 return undef if !$bootdisk;
2547 return undef if !is_valid_drivename
($bootdisk);
2549 return undef if !$conf->{$bootdisk};
2551 my $drive = parse_drive
($bootdisk, $conf->{$bootdisk});
2552 return undef if !defined($drive);
2554 return undef if drive_is_cdrom
($drive);
2556 my $volid = $drive->{file
};
2557 return undef if !$volid;
2559 return $drive->{size
};
2562 my $last_proc_pid_stat;
2564 # get VM status information
2565 # This must be fast and should not block ($full == false)
2566 # We only query KVM using QMP if $full == true (this can be slow)
2568 my ($opt_vmid, $full) = @_;
2572 my $storecfg = PVE
::Storage
::config
();
2574 my $list = vzlist
();
2575 my ($uptime) = PVE
::ProcFSTools
::read_proc_uptime
(1);
2577 my $cpucount = $cpuinfo->{cpus
} || 1;
2579 foreach my $vmid (keys %$list) {
2580 next if $opt_vmid && ($vmid ne $opt_vmid);
2582 my $cfspath = PVE
::QemuConfig-
>cfs_config_path($vmid);
2583 my $conf = PVE
::Cluster
::cfs_read_file
($cfspath) || {};
2586 $d->{pid
} = $list->{$vmid}->{pid
};
2588 # fixme: better status?
2589 $d->{status
} = $list->{$vmid}->{pid
} ?
'running' : 'stopped';
2591 my $size = disksize
($storecfg, $conf);
2592 if (defined($size)) {
2593 $d->{disk
} = 0; # no info available
2594 $d->{maxdisk
} = $size;
2600 $d->{cpus
} = ($conf->{sockets
} || 1) * ($conf->{cores
} || 1);
2601 $d->{cpus
} = $cpucount if $d->{cpus
} > $cpucount;
2602 $d->{cpus
} = $conf->{vcpus
} if $conf->{vcpus
};
2604 $d->{name
} = $conf->{name
} || "VM $vmid";
2605 $d->{maxmem
} = $conf->{memory
} ?
$conf->{memory
}*(1024*1024) : 0;
2607 if ($conf->{balloon
}) {
2608 $d->{balloon_min
} = $conf->{balloon
}*(1024*1024);
2609 $d->{shares
} = defined($conf->{shares
}) ?
$conf->{shares
} : 1000;
2620 $d->{diskwrite
} = 0;
2622 $d->{template
} = PVE
::QemuConfig-
>is_template($conf);
2627 my $netdev = PVE
::ProcFSTools
::read_proc_net_dev
();
2628 foreach my $dev (keys %$netdev) {
2629 next if $dev !~ m/^tap([1-9]\d*)i/;
2631 my $d = $res->{$vmid};
2634 $d->{netout
} += $netdev->{$dev}->{receive
};
2635 $d->{netin
} += $netdev->{$dev}->{transmit
};
2638 $d->{nics
}->{$dev}->{netout
} = $netdev->{$dev}->{receive
};
2639 $d->{nics
}->{$dev}->{netin
} = $netdev->{$dev}->{transmit
};
2644 my $ctime = gettimeofday
;
2646 foreach my $vmid (keys %$list) {
2648 my $d = $res->{$vmid};
2649 my $pid = $d->{pid
};
2652 my $pstat = PVE
::ProcFSTools
::read_proc_pid_stat
($pid);
2653 next if !$pstat; # not running
2655 my $used = $pstat->{utime} + $pstat->{stime
};
2657 $d->{uptime
} = int(($uptime - $pstat->{starttime
})/$cpuinfo->{user_hz
});
2659 if ($pstat->{vsize
}) {
2660 $d->{mem
} = int(($pstat->{rss
}/$pstat->{vsize
})*$d->{maxmem
});
2663 my $old = $last_proc_pid_stat->{$pid};
2665 $last_proc_pid_stat->{$pid} = {
2673 my $dtime = ($ctime - $old->{time}) * $cpucount * $cpuinfo->{user_hz
};
2675 if ($dtime > 1000) {
2676 my $dutime = $used - $old->{used
};
2678 $d->{cpu
} = (($dutime/$dtime)* $cpucount) / $d->{cpus
};
2679 $last_proc_pid_stat->{$pid} = {
2685 $d->{cpu
} = $old->{cpu
};
2689 return $res if !$full;
2691 my $qmpclient = PVE
::QMPClient-
>new();
2693 my $ballooncb = sub {
2694 my ($vmid, $resp) = @_;
2696 my $info = $resp->{'return'};
2697 return if !$info->{max_mem
};
2699 my $d = $res->{$vmid};
2701 # use memory assigned to VM
2702 $d->{maxmem
} = $info->{max_mem
};
2703 $d->{balloon
} = $info->{actual
};
2705 if (defined($info->{total_mem
}) && defined($info->{free_mem
})) {
2706 $d->{mem
} = $info->{total_mem
} - $info->{free_mem
};
2707 $d->{freemem
} = $info->{free_mem
};
2710 $d->{ballooninfo
} = $info;
2713 my $blockstatscb = sub {
2714 my ($vmid, $resp) = @_;
2715 my $data = $resp->{'return'} || [];
2716 my $totalrdbytes = 0;
2717 my $totalwrbytes = 0;
2719 for my $blockstat (@$data) {
2720 $totalrdbytes = $totalrdbytes + $blockstat->{stats
}->{rd_bytes
};
2721 $totalwrbytes = $totalwrbytes + $blockstat->{stats
}->{wr_bytes
};
2723 $blockstat->{device
} =~ s/drive-//;
2724 $res->{$vmid}->{blockstat
}->{$blockstat->{device
}} = $blockstat->{stats
};
2726 $res->{$vmid}->{diskread
} = $totalrdbytes;
2727 $res->{$vmid}->{diskwrite
} = $totalwrbytes;
2730 my $statuscb = sub {
2731 my ($vmid, $resp) = @_;
2733 $qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
2734 # this fails if ballon driver is not loaded, so this must be
2735 # the last commnand (following command are aborted if this fails).
2736 $qmpclient->queue_cmd($vmid, $ballooncb, 'query-balloon');
2738 my $status = 'unknown';
2739 if (!defined($status = $resp->{'return'}->{status
})) {
2740 warn "unable to get VM status\n";
2744 $res->{$vmid}->{qmpstatus
} = $resp->{'return'}->{status
};
2747 foreach my $vmid (keys %$list) {
2748 next if $opt_vmid && ($vmid ne $opt_vmid);
2749 next if !$res->{$vmid}->{pid
}; # not running
2750 $qmpclient->queue_cmd($vmid, $statuscb, 'query-status');
2753 $qmpclient->queue_execute(undef, 2);
2755 foreach my $vmid (keys %$list) {
2756 next if $opt_vmid && ($vmid ne $opt_vmid);
2757 $res->{$vmid}->{qmpstatus
} = $res->{$vmid}->{status
} if !$res->{$vmid}->{qmpstatus
};
2764 my ($conf, $func, @param) = @_;
2766 foreach my $ds (valid_drive_names
()) {
2767 next if !defined($conf->{$ds});
2769 my $drive = parse_drive
($ds, $conf->{$ds});
2772 &$func($ds, $drive, @param);
2777 my ($conf, $func, @param) = @_;
2781 my $test_volid = sub {
2782 my ($volid, $is_cdrom, $replicate, $snapname) = @_;
2786 $volhash->{$volid}->{cdrom
} //= 1;
2787 $volhash->{$volid}->{cdrom
} = 0 if !$is_cdrom;
2789 $volhash->{$volid}->{replicate
} //= 0;
2790 $volhash->{$volid}->{replicate
} = 1 if $replicate;
2792 $volhash->{$volid}->{referenced_in_config
} //= 0;
2793 $volhash->{$volid}->{referenced_in_config
} = 1 if !defined($snapname);
2795 $volhash->{$volid}->{referenced_in_snapshot
}->{$snapname} = 1
2796 if defined($snapname);
2799 foreach_drive
($conf, sub {
2800 my ($ds, $drive) = @_;
2801 $test_volid->($drive->{file
}, drive_is_cdrom
($drive), $drive->{replicate
} // 1, undef);
2804 foreach my $snapname (keys %{$conf->{snapshots
}}) {
2805 my $snap = $conf->{snapshots
}->{$snapname};
2806 $test_volid->($snap->{vmstate
}, 0, 1, $snapname);
2807 foreach_drive
($snap, sub {
2808 my ($ds, $drive) = @_;
2809 $test_volid->($drive->{file
}, drive_is_cdrom
($drive), $drive->{replicate
} // 1, $snapname);
2813 foreach my $volid (keys %$volhash) {
2814 &$func($volid, $volhash->{$volid}, @param);
2818 sub vga_conf_has_spice
{
2821 return 0 if !$vga || $vga !~ m/^qxl([234])?$/;
2826 sub config_to_command
{
2827 my ($storecfg, $vmid, $conf, $defaults, $forcemachine) = @_;
2830 my $globalFlags = [];
2831 my $machineFlags = [];
2837 my $kvmver = kvm_user_version
();
2838 my $vernum = 0; # unknown
2839 my $ostype = $conf->{ostype
};
2840 my $winversion = windows_version
($ostype);
2841 my $kvm = $conf->{kvm
} // 1;
2843 die "KVM virtualisation configured, but not available. Either disable in VM configuration or enable in BIOS.\n" if (!$cpuinfo->{hvm
} && $kvm);
2845 if ($kvmver =~ m/^(\d+)\.(\d+)$/) {
2846 $vernum = $1*1000000+$2*1000;
2847 } elsif ($kvmver =~ m/^(\d+)\.(\d+)\.(\d+)$/) {
2848 $vernum = $1*1000000+$2*1000+$3;
2851 die "detected old qemu-kvm binary ($kvmver)\n" if $vernum < 15000;
2853 my $have_ovz = -f
'/proc/vz/vestat';
2855 my $q35 = machine_type_is_q35
($conf);
2856 my $hotplug_features = parse_hotplug_features
(defined($conf->{hotplug
}) ?
$conf->{hotplug
} : '1');
2857 my $machine_type = $forcemachine || $conf->{machine
};
2858 my $use_old_bios_files = undef;
2859 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
2861 my $cpuunits = defined($conf->{cpuunits
}) ?
2862 $conf->{cpuunits
} : $defaults->{cpuunits
};
2864 push @$cmd, '/usr/bin/kvm';
2866 push @$cmd, '-id', $vmid;
2870 my $qmpsocket = qmp_socket
($vmid);
2871 push @$cmd, '-chardev', "socket,id=qmp,path=$qmpsocket,server,nowait";
2872 push @$cmd, '-mon', "chardev=qmp,mode=control";
2875 push @$cmd, '-pidfile' , pidfile_name
($vmid);
2877 push @$cmd, '-daemonize';
2879 if ($conf->{smbios1
}) {
2880 push @$cmd, '-smbios', "type=1,$conf->{smbios1}";
2883 if ($conf->{bios
} && $conf->{bios
} eq 'ovmf') {
2884 die "uefi base image not found\n" if ! -f
$OVMF_CODE;
2887 if (my $efidisk = $conf->{efidisk0
}) {
2888 my $d = PVE
::JSONSchema
::parse_property_string
($efidisk_fmt, $efidisk);
2889 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($d->{file
}, 1);
2891 $path = PVE
::Storage
::path
($storecfg, $d->{file
});
2896 warn "no efidisk configured! Using temporary efivars disk.\n";
2897 $path = "/tmp/$vmid-ovmf.fd";
2898 PVE
::Tools
::file_copy
($OVMF_VARS, $path, -s
$OVMF_VARS);
2901 push @$cmd, '-drive', "if=pflash,unit=0,format=raw,readonly,file=$OVMF_CODE";
2902 push @$cmd, '-drive', "if=pflash,unit=1,id=drive-efidisk0,file=$path";
2906 # add usb controllers
2907 my @usbcontrollers = PVE
::QemuServer
::USB
::get_usb_controllers
($conf, $bridges, $q35, $usbdesc->{format
}, $MAX_USB_DEVICES);
2908 push @$devices, @usbcontrollers if @usbcontrollers;
2909 my $vga = $conf->{vga
};
2911 my $qxlnum = vga_conf_has_spice
($vga);
2912 $vga = 'qxl' if $qxlnum;
2915 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 9)) {
2916 $vga = (!$winversion || $winversion >= 6) ?
'std' : 'cirrus';
2918 $vga = ($winversion >= 6) ?
'std' : 'cirrus';
2922 # enable absolute mouse coordinates (needed by vnc)
2924 if (defined($conf->{tablet
})) {
2925 $tablet = $conf->{tablet
};
2927 $tablet = $defaults->{tablet
};
2928 $tablet = 0 if $qxlnum; # disable for spice because it is not needed
2929 $tablet = 0 if $vga =~ m/^serial\d+$/; # disable if we use serial terminal (no vga card)
2932 push @$devices, '-device', print_tabletdevice_full
($conf) if $tablet;
2935 my $gpu_passthrough;
2938 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
2939 my $d = parse_hostpci
($conf->{"hostpci$i"});
2942 my $pcie = $d->{pcie
};
2944 die "q35 machine model is not enabled" if !$q35;
2945 $pciaddr = print_pcie_addr
("hostpci$i");
2947 $pciaddr = print_pci_addr
("hostpci$i", $bridges);
2950 my $rombar = defined($d->{rombar
}) && !$d->{rombar
} ?
',rombar=0' : '';
2951 my $romfile = $d->{romfile
};
2954 if ($d->{'x-vga'}) {
2955 $xvga = ',x-vga=on';
2958 $gpu_passthrough = 1;
2960 if ($conf->{bios
} && $conf->{bios
} eq 'ovmf') {
2964 my $pcidevices = $d->{pciid
};
2965 my $multifunction = 1 if @$pcidevices > 1;
2968 foreach my $pcidevice (@$pcidevices) {
2970 my $id = "hostpci$i";
2971 $id .= ".$j" if $multifunction;
2972 my $addr = $pciaddr;
2973 $addr .= ".$j" if $multifunction;
2974 my $devicestr = "vfio-pci,host=$pcidevice->{id}.$pcidevice->{function},id=$id$addr";
2977 $devicestr .= "$rombar$xvga";
2978 $devicestr .= ",multifunction=on" if $multifunction;
2979 $devicestr .= ",romfile=/usr/share/kvm/$romfile" if $romfile;
2982 push @$devices, '-device', $devicestr;
2988 my @usbdevices = PVE
::QemuServer
::USB
::get_usb_devices
($conf, $usbdesc->{format
}, $MAX_USB_DEVICES);
2989 push @$devices, @usbdevices if @usbdevices;
2991 for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
2992 if (my $path = $conf->{"serial$i"}) {
2993 if ($path eq 'socket') {
2994 my $socket = "/var/run/qemu-server/${vmid}.serial$i";
2995 push @$devices, '-chardev', "socket,id=serial$i,path=$socket,server,nowait";
2996 push @$devices, '-device', "isa-serial,chardev=serial$i";
2998 die "no such serial device\n" if ! -c
$path;
2999 push @$devices, '-chardev', "tty,id=serial$i,path=$path";
3000 push @$devices, '-device', "isa-serial,chardev=serial$i";
3006 for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
3007 if (my $path = $conf->{"parallel$i"}) {
3008 die "no such parallel device\n" if ! -c
$path;
3009 my $devtype = $path =~ m!^/dev/usb/lp! ?
'tty' : 'parport';
3010 push @$devices, '-chardev', "$devtype,id=parallel$i,path=$path";
3011 push @$devices, '-device', "isa-parallel,chardev=parallel$i";
3015 my $vmname = $conf->{name
} || "vm$vmid";
3017 push @$cmd, '-name', $vmname;
3020 $sockets = $conf->{smp
} if $conf->{smp
}; # old style - no longer iused
3021 $sockets = $conf->{sockets
} if $conf->{sockets
};
3023 my $cores = $conf->{cores
} || 1;
3025 my $maxcpus = $sockets * $cores;
3027 my $vcpus = $conf->{vcpus
} ?
$conf->{vcpus
} : $maxcpus;
3029 my $allowed_vcpus = $cpuinfo->{cpus
};
3031 die "MAX $allowed_vcpus vcpus allowed per VM on this node\n"
3032 if ($allowed_vcpus < $maxcpus);
3034 if($hotplug_features->{cpu
} && qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 7)) {
3036 push @$cmd, '-smp', "1,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3037 for (my $i = 2; $i <= $vcpus; $i++) {
3038 my $cpustr = print_cpu_device
($conf,$i);
3039 push @$cmd, '-device', $cpustr;
3044 push @$cmd, '-smp', "$vcpus,sockets=$sockets,cores=$cores,maxcpus=$maxcpus";
3046 push @$cmd, '-nodefaults';
3048 my $bootorder = $conf->{boot
} || $confdesc->{boot
}->{default};
3050 my $bootindex_hash = {};
3052 foreach my $o (split(//, $bootorder)) {
3053 $bootindex_hash->{$o} = $i*100;
3057 push @$cmd, '-boot', "menu=on,strict=on,reboot-timeout=1000,splash=/usr/share/qemu-server/bootsplash.jpg";
3059 push @$cmd, '-no-acpi' if defined($conf->{acpi
}) && $conf->{acpi
} == 0;
3061 push @$cmd, '-no-reboot' if defined($conf->{reboot
}) && $conf->{reboot
} == 0;
3063 push @$cmd, '-vga', $vga if $vga && $vga !~ m/^serial\d+$/; # for kvm 77 and later
3065 if ($vga && $vga !~ m/^serial\d+$/ && $vga ne 'none'){
3066 my $socket = vnc_socket
($vmid);
3067 push @$cmd, '-vnc', "unix:$socket,x509,password";
3069 push @$cmd, '-nographic';
3073 my $tdf = defined($conf->{tdf
}) ?
$conf->{tdf
} : $defaults->{tdf
};
3075 my $useLocaltime = $conf->{localtime};
3077 if ($winversion >= 5) { # windows
3078 $useLocaltime = 1 if !defined($conf->{localtime});
3080 # use time drift fix when acpi is enabled
3081 if (!(defined($conf->{acpi
}) && $conf->{acpi
} == 0)) {
3082 $tdf = 1 if !defined($conf->{tdf
});
3086 if ($winversion >= 6) {
3087 push @$globalFlags, 'kvm-pit.lost_tick_policy=discard';
3088 push @$cmd, '-no-hpet';
3091 push @$rtcFlags, 'driftfix=slew' if $tdf;
3094 push @$machineFlags, 'accel=tcg';
3097 if ($machine_type) {
3098 push @$machineFlags, "type=${machine_type}";
3101 if ($conf->{startdate
}) {
3102 push @$rtcFlags, "base=$conf->{startdate}";
3103 } elsif ($useLocaltime) {
3104 push @$rtcFlags, 'base=localtime';
3107 my $cpu = $kvm ?
"kvm64" : "qemu64";
3108 if (my $cputype = $conf->{cpu
}) {
3109 my $cpuconf = PVE
::JSONSchema
::parse_property_string
($cpu_fmt, $cputype)
3110 or die "Cannot parse cpu description: $cputype\n";
3111 $cpu = $cpuconf->{cputype
};
3112 $kvm_off = 1 if $cpuconf->{hidden
};
3115 push @$cpuFlags , '+lahf_lm' if $cpu eq 'kvm64';
3117 push @$cpuFlags , '-x2apic'
3118 if $conf->{ostype
} && $conf->{ostype
} eq 'solaris';
3120 push @$cpuFlags, '+sep' if $cpu eq 'kvm64' || $cpu eq 'kvm32';
3122 push @$cpuFlags, '-rdtscp' if $cpu =~ m/^Opteron/;
3124 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3)) {
3126 push @$cpuFlags , '+kvm_pv_unhalt' if $kvm;
3127 push @$cpuFlags , '+kvm_pv_eoi' if $kvm;
3130 add_hyperv_enlightenments
($cpuFlags, $winversion, $machine_type, $kvmver, $conf->{bios
}, $gpu_passthrough) if $kvm;
3132 push @$cpuFlags, 'enforce' if $cpu ne 'host' && $kvm;
3134 push @$cpuFlags, 'kvm=off' if $kvm_off;
3136 my $cpu_vendor = $cpu_vendor_list->{$cpu} ||
3137 die "internal error"; # should not happen
3139 push @$cpuFlags, "vendor=${cpu_vendor}"
3140 if $cpu_vendor ne 'default';
3142 $cpu .= "," . join(',', @$cpuFlags) if scalar(@$cpuFlags);
3144 push @$cmd, '-cpu', $cpu;
3146 PVE
::QemuServer
::Memory
::config
($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd);
3148 push @$cmd, '-S' if $conf->{freeze
};
3150 # set keyboard layout
3151 my $kb = $conf->{keyboard
} || $defaults->{keyboard
};
3152 push @$cmd, '-k', $kb if $kb;
3155 #my $soundhw = $conf->{soundhw} || $defaults->{soundhw};
3156 #push @$cmd, '-soundhw', 'es1370';
3157 #push @$cmd, '-soundhw', $soundhw if $soundhw;
3159 if($conf->{agent
}) {
3160 my $qgasocket = qmp_socket
($vmid, 1);
3161 my $pciaddr = print_pci_addr
("qga0", $bridges);
3162 push @$devices, '-chardev', "socket,path=$qgasocket,server,nowait,id=qga0";
3163 push @$devices, '-device', "virtio-serial,id=qga0$pciaddr";
3164 push @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
3172 for(my $i = 1; $i < $qxlnum; $i++){
3173 my $pciaddr = print_pci_addr
("vga$i", $bridges);
3174 push @$cmd, '-device', "qxl,id=vga$i,ram_size=67108864,vram_size=33554432$pciaddr";
3177 # assume other OS works like Linux
3178 push @$cmd, '-global', 'qxl-vga.ram_size=134217728';
3179 push @$cmd, '-global', 'qxl-vga.vram_size=67108864';
3183 my $pciaddr = print_pci_addr
("spice", $bridges);
3185 my $nodename = PVE
::INotify
::nodename
();
3186 my $pfamily = PVE
::Tools
::get_host_address_family
($nodename);
3187 my @nodeaddrs = PVE
::Tools
::getaddrinfo_all
('localhost', family
=> $pfamily);
3188 die "failed to get an ip address of type $pfamily for 'localhost'\n" if !@nodeaddrs;
3189 my $localhost = PVE
::Network
::addr_to_ip
($nodeaddrs[0]->{addr
});
3190 $spice_port = PVE
::Tools
::next_spice_port
($pfamily, $localhost);
3192 push @$devices, '-spice', "tls-port=${spice_port},addr=$localhost,tls-ciphers=HIGH,seamless-migration=on";
3194 push @$devices, '-device', "virtio-serial,id=spice$pciaddr";
3195 push @$devices, '-chardev', "spicevmc,id=vdagent,name=vdagent";
3196 push @$devices, '-device', "virtserialport,chardev=vdagent,name=com.redhat.spice.0";
3199 # enable balloon by default, unless explicitly disabled
3200 if (!defined($conf->{balloon
}) || $conf->{balloon
}) {
3201 $pciaddr = print_pci_addr
("balloon0", $bridges);
3202 push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr";
3205 if ($conf->{watchdog
}) {
3206 my $wdopts = parse_watchdog
($conf->{watchdog
});
3207 $pciaddr = print_pci_addr
("watchdog", $bridges);
3208 my $watchdog = $wdopts->{model
} || 'i6300esb';
3209 push @$devices, '-device', "$watchdog$pciaddr";
3210 push @$devices, '-watchdog-action', $wdopts->{action
} if $wdopts->{action
};
3214 my $scsicontroller = {};
3215 my $ahcicontroller = {};
3216 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : $defaults->{scsihw
};
3218 # Add iscsi initiator name if available
3219 if (my $initiator = get_initiator_name
()) {
3220 push @$devices, '-iscsi', "initiator-name=$initiator";
3223 foreach_drive
($conf, sub {
3224 my ($ds, $drive) = @_;
3226 if (PVE
::Storage
::parse_volume_id
($drive->{file
}, 1)) {
3227 push @$vollist, $drive->{file
};
3230 # ignore efidisk here, already added in bios/fw handling code above
3231 return if $drive->{interface
} eq 'efidisk';
3233 $use_virtio = 1 if $ds =~ m/^virtio/;
3235 if (drive_is_cdrom
($drive)) {
3236 if ($bootindex_hash->{d
}) {
3237 $drive->{bootindex
} = $bootindex_hash->{d
};
3238 $bootindex_hash->{d
} += 1;
3241 if ($bootindex_hash->{c
}) {
3242 $drive->{bootindex
} = $bootindex_hash->{c
} if $conf->{bootdisk
} && ($conf->{bootdisk
} eq $ds);
3243 $bootindex_hash->{c
} += 1;
3247 if($drive->{interface
} eq 'virtio'){
3248 push @$cmd, '-object', "iothread,id=iothread-$ds" if $drive->{iothread
};
3251 if ($drive->{interface
} eq 'scsi') {
3253 my ($maxdev, $controller, $controller_prefix) = scsihw_infos
($conf, $drive);
3255 $pciaddr = print_pci_addr
("$controller_prefix$controller", $bridges);
3256 my $scsihw_type = $scsihw =~ m/^virtio-scsi-single/ ?
"virtio-scsi-pci" : $scsihw;
3259 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{iothread
}){
3260 $iothread .= ",iothread=iothread-$controller_prefix$controller";
3261 push @$cmd, '-object', "iothread,id=iothread-$controller_prefix$controller";
3262 } elsif ($drive->{iothread
}) {
3263 warn "iothread is only valid with virtio disk or virtio-scsi-single controller, ignoring\n";
3267 if($conf->{scsihw
} && $conf->{scsihw
} eq "virtio-scsi-single" && $drive->{queues
}){
3268 $queues = ",num_queues=$drive->{queues}";
3271 push @$devices, '-device', "$scsihw_type,id=$controller_prefix$controller$pciaddr$iothread$queues" if !$scsicontroller->{$controller};
3272 $scsicontroller->{$controller}=1;
3275 if ($drive->{interface
} eq 'sata') {
3276 my $controller = int($drive->{index} / $MAX_SATA_DISKS);
3277 $pciaddr = print_pci_addr
("ahci$controller", $bridges);
3278 push @$devices, '-device', "ahci,id=ahci$controller,multifunction=on$pciaddr" if !$ahcicontroller->{$controller};
3279 $ahcicontroller->{$controller}=1;
3282 my $drive_cmd = print_drive_full
($storecfg, $vmid, $drive);
3283 push @$devices, '-drive',$drive_cmd;
3284 push @$devices, '-device', print_drivedevice_full
($storecfg, $conf, $vmid, $drive, $bridges);
3287 for (my $i = 0; $i < $MAX_NETS; $i++) {
3288 next if !$conf->{"net$i"};
3289 my $d = parse_net
($conf->{"net$i"});
3292 $use_virtio = 1 if $d->{model
} eq 'virtio';
3294 if ($bootindex_hash->{n
}) {
3295 $d->{bootindex
} = $bootindex_hash->{n
};
3296 $bootindex_hash->{n
} += 1;
3299 my $netdevfull = print_netdev_full
($vmid,$conf,$d,"net$i");
3300 push @$devices, '-netdev', $netdevfull;
3302 my $netdevicefull = print_netdevice_full
($vmid, $conf, $d, "net$i", $bridges, $use_old_bios_files);
3303 push @$devices, '-device', $netdevicefull;
3308 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3)) {
3313 $bridges->{3} = 1 if $scsihw =~ m/^virtio-scsi-single/;
3315 while (my ($k, $v) = each %$bridges) {
3316 $pciaddr = print_pci_addr
("pci.$k");
3317 unshift @$devices, '-device', "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr" if $k > 0;
3322 if ($conf->{args
}) {
3323 my $aa = PVE
::Tools
::split_args
($conf->{args
});
3327 push @$cmd, @$devices;
3328 push @$cmd, '-rtc', join(',', @$rtcFlags)
3329 if scalar(@$rtcFlags);
3330 push @$cmd, '-machine', join(',', @$machineFlags)
3331 if scalar(@$machineFlags);
3332 push @$cmd, '-global', join(',', @$globalFlags)
3333 if scalar(@$globalFlags);
3335 return wantarray ?
($cmd, $vollist, $spice_port) : $cmd;
3340 return "${var_run_tmpdir}/$vmid.vnc";
3346 my $res = vm_mon_cmd
($vmid, 'query-spice');
3348 return $res->{'tls-port'} || $res->{'port'} || die "no spice port\n";
3352 my ($vmid, $qga) = @_;
3353 my $sockettype = $qga ?
'qga' : 'qmp';
3354 return "${var_run_tmpdir}/$vmid.$sockettype";
3359 return "${var_run_tmpdir}/$vmid.pid";
3362 sub vm_devices_list
{
3365 my $res = vm_mon_cmd
($vmid, 'query-pci');
3367 foreach my $pcibus (@$res) {
3368 foreach my $device (@{$pcibus->{devices
}}) {
3369 next if !$device->{'qdev_id'};
3370 if ($device->{'pci_bridge'}) {
3371 $devices->{$device->{'qdev_id'}} = 1;
3372 foreach my $bridge_device (@{$device->{'pci_bridge'}->{devices
}}) {
3373 next if !$bridge_device->{'qdev_id'};
3374 $devices->{$bridge_device->{'qdev_id'}} = 1;
3375 $devices->{$device->{'qdev_id'}}++;
3378 $devices->{$device->{'qdev_id'}} = 1;
3383 my $resblock = vm_mon_cmd
($vmid, 'query-block');
3384 foreach my $block (@$resblock) {
3385 if($block->{device
} =~ m/^drive-(\S+)/){
3390 my $resmice = vm_mon_cmd
($vmid, 'query-mice');
3391 foreach my $mice (@$resmice) {
3392 if ($mice->{name
} eq 'QEMU HID Tablet') {
3393 $devices->{tablet
} = 1;
3398 # for usb devices there is no query-usb
3399 # but we can iterate over the entries in
3400 # qom-list path=/machine/peripheral
3401 my $resperipheral = vm_mon_cmd
($vmid, 'qom-list', path
=> '/machine/peripheral');
3402 foreach my $per (@$resperipheral) {
3403 if ($per->{name
} =~ m/^usb\d+$/) {
3404 $devices->{$per->{name
}} = 1;
3412 my ($storecfg, $conf, $vmid, $deviceid, $device) = @_;
3414 my $q35 = machine_type_is_q35
($conf);
3416 my $devices_list = vm_devices_list
($vmid);
3417 return 1 if defined($devices_list->{$deviceid});
3419 qemu_add_pci_bridge
($storecfg, $conf, $vmid, $deviceid); # add PCI bridge if we need it for the device
3421 if ($deviceid eq 'tablet') {
3423 qemu_deviceadd
($vmid, print_tabletdevice_full
($conf));
3425 } elsif ($deviceid =~ m/^usb(\d+)$/) {
3427 die "usb hotplug currently not reliable\n";
3428 # since we can't reliably hot unplug all added usb devices
3429 # and usb passthrough disables live migration
3430 # we disable usb hotplugging for now
3431 qemu_deviceadd
($vmid, PVE
::QemuServer
::USB
::print_usbdevice_full
($conf, $deviceid, $device));
3433 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3435 qemu_iothread_add
($vmid, $deviceid, $device);
3437 qemu_driveadd
($storecfg, $vmid, $device);
3438 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device);
3440 qemu_deviceadd
($vmid, $devicefull);
3441 eval { qemu_deviceaddverify
($vmid, $deviceid); };
3443 eval { qemu_drivedel
($vmid, $deviceid); };
3448 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3451 my $scsihw = defined($conf->{scsihw
}) ?
$conf->{scsihw
} : "lsi";
3452 my $pciaddr = print_pci_addr
($deviceid);
3453 my $scsihw_type = $scsihw eq 'virtio-scsi-single' ?
"virtio-scsi-pci" : $scsihw;
3455 my $devicefull = "$scsihw_type,id=$deviceid$pciaddr";
3457 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{iothread
}) {
3458 qemu_iothread_add
($vmid, $deviceid, $device);
3459 $devicefull .= ",iothread=iothread-$deviceid";
3462 if($deviceid =~ m/^virtioscsi(\d+)$/ && $device->{queues
}) {
3463 $devicefull .= ",num_queues=$device->{queues}";
3466 qemu_deviceadd
($vmid, $devicefull);
3467 qemu_deviceaddverify
($vmid, $deviceid);
3469 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3471 qemu_findorcreatescsihw
($storecfg,$conf, $vmid, $device);
3472 qemu_driveadd
($storecfg, $vmid, $device);
3474 my $devicefull = print_drivedevice_full
($storecfg, $conf, $vmid, $device);
3475 eval { qemu_deviceadd
($vmid, $devicefull); };
3477 eval { qemu_drivedel
($vmid, $deviceid); };
3482 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3484 return undef if !qemu_netdevadd
($vmid, $conf, $device, $deviceid);
3486 my $machine_type = PVE
::QemuServer
::qemu_machine_pxe
($vmid, $conf);
3487 my $use_old_bios_files = undef;
3488 ($use_old_bios_files, $machine_type) = qemu_use_old_bios_files
($machine_type);
3490 my $netdevicefull = print_netdevice_full
($vmid, $conf, $device, $deviceid, undef, $use_old_bios_files);
3491 qemu_deviceadd
($vmid, $netdevicefull);
3492 eval { qemu_deviceaddverify
($vmid, $deviceid); };
3494 eval { qemu_netdevdel
($vmid, $deviceid); };
3499 } elsif (!$q35 && $deviceid =~ m/^(pci\.)(\d+)$/) {
3502 my $pciaddr = print_pci_addr
($deviceid);
3503 my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
3505 qemu_deviceadd
($vmid, $devicefull);
3506 qemu_deviceaddverify
($vmid, $deviceid);
3509 die "can't hotplug device '$deviceid'\n";
3515 # fixme: this should raise exceptions on error!
3516 sub vm_deviceunplug
{
3517 my ($vmid, $conf, $deviceid) = @_;
3519 my $devices_list = vm_devices_list
($vmid);
3520 return 1 if !defined($devices_list->{$deviceid});
3522 die "can't unplug bootdisk" if $conf->{bootdisk
} && $conf->{bootdisk
} eq $deviceid;
3524 if ($deviceid eq 'tablet') {
3526 qemu_devicedel
($vmid, $deviceid);
3528 } elsif ($deviceid =~ m/^usb\d+$/) {
3530 die "usb hotplug currently not reliable\n";
3531 # when unplugging usb devices this way,
3532 # there may be remaining usb controllers/hubs
3533 # so we disable it for now
3534 qemu_devicedel
($vmid, $deviceid);
3535 qemu_devicedelverify
($vmid, $deviceid);
3537 } elsif ($deviceid =~ m/^(virtio)(\d+)$/) {
3539 qemu_devicedel
($vmid, $deviceid);
3540 qemu_devicedelverify
($vmid, $deviceid);
3541 qemu_drivedel
($vmid, $deviceid);
3542 qemu_iothread_del
($conf, $vmid, $deviceid);
3544 } elsif ($deviceid =~ m/^(virtioscsi|scsihw)(\d+)$/) {
3546 qemu_devicedel
($vmid, $deviceid);
3547 qemu_devicedelverify
($vmid, $deviceid);
3548 qemu_iothread_del
($conf, $vmid, $deviceid);
3550 } elsif ($deviceid =~ m/^(scsi)(\d+)$/) {
3552 #qemu 2.3 segfault on drive_del with virtioscsi + iothread
3553 my $device = parse_drive
($deviceid, $conf->{$deviceid});
3554 die "virtioscsi with iothread is not hot-unplugglable currently" if $device->{iothread
};
3556 qemu_devicedel
($vmid, $deviceid);
3557 qemu_drivedel
($vmid, $deviceid);
3558 qemu_deletescsihw
($conf, $vmid, $deviceid);
3560 } elsif ($deviceid =~ m/^(net)(\d+)$/) {
3562 qemu_devicedel
($vmid, $deviceid);
3563 qemu_devicedelverify
($vmid, $deviceid);
3564 qemu_netdevdel
($vmid, $deviceid);
3567 die "can't unplug device '$deviceid'\n";
3573 sub qemu_deviceadd
{
3574 my ($vmid, $devicefull) = @_;
3576 $devicefull = "driver=".$devicefull;
3577 my %options = split(/[=,]/, $devicefull);
3579 vm_mon_cmd
($vmid, "device_add" , %options);
3582 sub qemu_devicedel
{
3583 my ($vmid, $deviceid) = @_;
3585 my $ret = vm_mon_cmd
($vmid, "device_del", id
=> $deviceid);
3588 sub qemu_iothread_add
{
3589 my($vmid, $deviceid, $device) = @_;
3591 if ($device->{iothread
}) {
3592 my $iothreads = vm_iothreads_list
($vmid);
3593 qemu_objectadd
($vmid, "iothread-$deviceid", "iothread") if !$iothreads->{"iothread-$deviceid"};
3597 sub qemu_iothread_del
{
3598 my($conf, $vmid, $deviceid) = @_;
3600 my $device = parse_drive
($deviceid, $conf->{$deviceid});
3601 if ($device->{iothread
}) {
3602 my $iothreads = vm_iothreads_list
($vmid);
3603 qemu_objectdel
($vmid, "iothread-$deviceid") if $iothreads->{"iothread-$deviceid"};
3607 sub qemu_objectadd
{
3608 my($vmid, $objectid, $qomtype) = @_;
3610 vm_mon_cmd
($vmid, "object-add", id
=> $objectid, "qom-type" => $qomtype);
3615 sub qemu_objectdel
{
3616 my($vmid, $objectid) = @_;
3618 vm_mon_cmd
($vmid, "object-del", id
=> $objectid);
3624 my ($storecfg, $vmid, $device) = @_;
3626 my $drive = print_drive_full
($storecfg, $vmid, $device);
3627 $drive =~ s/\\/\\\\/g;
3628 my $ret = vm_human_monitor_command
($vmid, "drive_add auto \"$drive\"");
3630 # If the command succeeds qemu prints: "OK
"
3631 return 1 if $ret =~ m/OK/s;
3633 die "adding drive failed
: $ret\n";
3637 my($vmid, $deviceid) = @_;
3639 my $ret = vm_human_monitor_command($vmid, "drive_del drive-
$deviceid");
3642 return 1 if $ret eq "";
3644 # NB: device not found errors mean the drive was auto-deleted and we ignore the error
3645 return 1 if $ret =~ m/Device \'.*?\' not found/s;
3647 die "deleting drive
$deviceid failed
: $ret\n";
3650 sub qemu_deviceaddverify {
3651 my ($vmid, $deviceid) = @_;
3653 for (my $i = 0; $i <= 5; $i++) {
3654 my $devices_list = vm_devices_list($vmid);
3655 return 1 if defined($devices_list->{$deviceid});
3659 die "error on hotplug device
'$deviceid'\n";
3663 sub qemu_devicedelverify {
3664 my ($vmid, $deviceid) = @_;
3666 # need to verify that the device is correctly removed as device_del
3667 # is async and empty return is not reliable
3669 for (my $i = 0; $i <= 5; $i++) {
3670 my $devices_list = vm_devices_list($vmid);
3671 return 1 if !defined($devices_list->{$deviceid});
3675 die "error on hot-unplugging device
'$deviceid'\n";
3678 sub qemu_findorcreatescsihw {
3679 my ($storecfg, $conf, $vmid, $device) = @_;
3681 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
3683 my $scsihwid="$controller_prefix$controller";
3684 my $devices_list = vm_devices_list($vmid);
3686 if(!defined($devices_list->{$scsihwid})) {
3687 vm_deviceplug($storecfg, $conf, $vmid, $scsihwid, $device);
3693 sub qemu_deletescsihw {
3694 my ($conf, $vmid, $opt) = @_;
3696 my $device = parse_drive($opt, $conf->{$opt});
3698 if ($conf->{scsihw} && ($conf->{scsihw} eq 'virtio-scsi-single')) {
3699 vm_deviceunplug($vmid, $conf, "virtioscsi
$device->{index}");
3703 my ($maxdev, $controller, $controller_prefix) = scsihw_infos($conf, $device);
3705 my $devices_list = vm_devices_list($vmid);
3706 foreach my $opt (keys %{$devices_list}) {
3707 if (PVE::QemuServer::is_valid_drivename($opt)) {
3708 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
3709 if($drive->{interface} eq 'scsi' && $drive->{index} < (($maxdev-1)*($controller+1))) {
3715 my $scsihwid="scsihw
$controller";
3717 vm_deviceunplug($vmid, $conf, $scsihwid);
3722 sub qemu_add_pci_bridge {
3723 my ($storecfg, $conf, $vmid, $device) = @_;
3729 print_pci_addr($device, $bridges);
3731 while (my ($k, $v) = each %$bridges) {
3734 return 1 if !defined($bridgeid) || $bridgeid < 1;
3736 my $bridge = "pci
.$bridgeid";
3737 my $devices_list = vm_devices_list($vmid);
3739 if (!defined($devices_list->{$bridge})) {
3740 vm_deviceplug($storecfg, $conf, $vmid, $bridge);
3746 sub qemu_set_link_status {
3747 my ($vmid, $device, $up) = @_;
3749 vm_mon_cmd($vmid, "set_link
", name => $device,
3750 up => $up ? JSON::true : JSON::false);
3753 sub qemu_netdevadd {
3754 my ($vmid, $conf, $device, $deviceid) = @_;
3756 my $netdev = print_netdev_full($vmid, $conf, $device, $deviceid, 1);
3757 my %options = split(/[=,]/, $netdev);
3759 vm_mon_cmd($vmid, "netdev_add
", %options);
3763 sub qemu_netdevdel {
3764 my ($vmid, $deviceid) = @_;
3766 vm_mon_cmd($vmid, "netdev_del
", id => $deviceid);
3769 sub qemu_usb_hotplug {
3770 my ($storecfg, $conf, $vmid, $deviceid, $device) = @_;
3774 # remove the old one first
3775 vm_deviceunplug($vmid, $conf, $deviceid);
3777 # check if xhci controller is necessary and available
3778 if ($device->{usb3}) {
3780 my $devicelist = vm_devices_list($vmid);
3782 if (!$devicelist->{xhci}) {
3783 my $pciaddr = print_pci_addr("xhci
");
3784 qemu_deviceadd($vmid, "nec-usb-xhci
,id
=xhci
$pciaddr");
3787 my $d = parse_usb_device($device->{host});
3788 $d->{usb3} = $device->{usb3};
3791 vm_deviceplug($storecfg, $conf, $vmid, $deviceid, $d);
3794 sub qemu_cpu_hotplug {
3795 my ($vmid, $conf, $vcpus) = @_;
3797 my $machine_type = PVE::QemuServer::get_current_qemu_machine($vmid);
3800 $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
3801 $sockets = $conf->{sockets} if $conf->{sockets};
3802 my $cores = $conf->{cores} || 1;
3803 my $maxcpus = $sockets * $cores;
3805 $vcpus = $maxcpus if !$vcpus;
3807 die "you can
't add more vcpus than maxcpus\n"
3808 if $vcpus > $maxcpus;
3810 my $currentvcpus = $conf->{vcpus} || $maxcpus;
3812 if ($vcpus < $currentvcpus) {
3814 if (qemu_machine_feature_enabled ($machine_type, undef, 2, 7)) {
3816 for (my $i = $currentvcpus; $i > $vcpus; $i--) {
3817 qemu_devicedel($vmid, "cpu$i");
3819 my $currentrunningvcpus = undef;
3821 $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
3822 last if scalar(@{$currentrunningvcpus}) == $i-1;
3823 raise_param_exc({ vcpus => "error unplugging cpu$i" }) if $retry > 5;
3827 #update conf after each succesfull cpu unplug
3828 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
3829 PVE::QemuConfig->write_config($vmid, $conf);
3832 die "cpu hot-unplugging requires qemu version 2.7 or higher\n";
3838 my $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
3839 die "vcpus in running vm does not match its configuration\n"
3840 if scalar(@{$currentrunningvcpus}) != $currentvcpus;
3842 if (qemu_machine_feature_enabled ($machine_type, undef, 2, 7)) {
3844 for (my $i = $currentvcpus+1; $i <= $vcpus; $i++) {
3845 my $cpustr = print_cpu_device($conf, $i);
3846 qemu_deviceadd($vmid, $cpustr);
3849 my $currentrunningvcpus = undef;
3851 $currentrunningvcpus = vm_mon_cmd($vmid, "query-cpus");
3852 last if scalar(@{$currentrunningvcpus}) == $i;
3853 raise_param_exc({ vcpus => "error hotplugging cpu$i" }) if $retry > 10;
3857 #update conf after each succesfull cpu hotplug
3858 $conf->{vcpus} = scalar(@{$currentrunningvcpus});
3859 PVE::QemuConfig->write_config($vmid, $conf);
3863 for (my $i = $currentvcpus; $i < $vcpus; $i++) {
3864 vm_mon_cmd($vmid, "cpu-add", id => int($i));
3869 sub qemu_block_set_io_throttle {
3870 my ($vmid, $deviceid,
3871 $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr,
3872 $bps_max, $bps_rd_max, $bps_wr_max, $iops_max, $iops_rd_max, $iops_wr_max,
3873 $bps_max_length, $bps_rd_max_length, $bps_wr_max_length,
3874 $iops_max_length, $iops_rd_max_length, $iops_wr_max_length) = @_;
3876 return if !check_running($vmid) ;
3878 vm_mon_cmd($vmid, "block_set_io_throttle", device => $deviceid,
3880 bps_rd => int($bps_rd),
3881 bps_wr => int($bps_wr),
3883 iops_rd => int($iops_rd),
3884 iops_wr => int($iops_wr),
3885 bps_max => int($bps_max),
3886 bps_rd_max => int($bps_rd_max),
3887 bps_wr_max => int($bps_wr_max),
3888 iops_max => int($iops_max),
3889 iops_rd_max => int($iops_rd_max),
3890 iops_wr_max => int($iops_wr_max),
3891 bps_max_length => int($bps_max_length),
3892 bps_rd_max_length => int($bps_rd_max_length),
3893 bps_wr_max_length => int($bps_wr_max_length),
3894 iops_max_length => int($iops_max_length),
3895 iops_rd_max_length => int($iops_rd_max_length),
3896 iops_wr_max_length => int($iops_wr_max_length),
3901 # old code, only used to shutdown old VM after update
3903 my ($fh, $timeout) = @_;
3905 my $sel = new IO::Select;
3912 while (scalar (@ready = $sel->can_read($timeout))) {
3914 if ($count = $fh->sysread($buf, 8192)) {
3915 if ($buf =~ /^(.*)\(qemu\) $/s) {
3922 if (!defined($count)) {
3929 die "monitor read timeout\n" if !scalar(@ready);
3934 # old code, only used to shutdown old VM after update
3935 sub vm_monitor_command {
3936 my ($vmid, $cmdstr, $nocheck) = @_;
3941 die "VM $vmid not running\n" if !check_running($vmid, $nocheck);
3943 my $sname = "${var_run_tmpdir}/$vmid.mon";
3945 my $sock = IO::Socket::UNIX->new( Peer => $sname ) ||
3946 die "unable to connect to VM $vmid socket - $!\n";
3950 # hack: migrate sometime blocks the monitor (when migrate_downtime
3952 if ($cmdstr =~ m/^(info\s+migrate|migrate\s)/) {
3953 $timeout = 60*60; # 1 hour
3957 my $data = __read_avail($sock, $timeout);
3959 if ($data !~ m/^QEMU\s+(\S+)\s+monitor\s/) {
3960 die "got unexpected qemu monitor banner\n";
3963 my $sel = new IO::Select;
3966 if (!scalar(my @ready = $sel->can_write($timeout))) {
3967 die "monitor write error - timeout";
3970 my $fullcmd = "$cmdstr\r";
3972 # syslog('info
', "VM $vmid monitor command: $cmdstr");
3975 if (!($b = $sock->syswrite($fullcmd)) || ($b != length($fullcmd))) {
3976 die "monitor write error - $!";
3979 return if ($cmdstr eq 'q
') || ($cmdstr eq 'quit
');
3983 if ($cmdstr =~ m/^(info\s+migrate|migrate\s)/) {
3984 $timeout = 60*60; # 1 hour
3985 } elsif ($cmdstr =~ m/^(eject|change)/) {
3986 $timeout = 60; # note: cdrom mount command is slow
3988 if ($res = __read_avail($sock, $timeout)) {
3990 my @lines = split("\r?\n", $res);
3992 shift @lines if $lines[0] !~ m/^unknown command/; # skip echo
3994 $res = join("\n", @lines);
4002 syslog("err", "VM $vmid monitor command failed - $err");
4009 sub qemu_block_resize {
4010 my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
4012 my $running = check_running($vmid);
4014 $size = 0 if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
4016 return if !$running;
4018 vm_mon_cmd($vmid, "block_resize", device => $deviceid, size => int($size));
4022 sub qemu_volume_snapshot {
4023 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4025 my $running = check_running($vmid);
4027 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4028 vm_mon_cmd($vmid, "snapshot-drive", device => $deviceid, name => $snap);
4030 PVE::Storage::volume_snapshot($storecfg, $volid, $snap);
4034 sub qemu_volume_snapshot_delete {
4035 my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
4037 my $running = check_running($vmid);
4039 if ($running && do_snapshots_with_qemu($storecfg, $volid)){
4040 vm_mon_cmd($vmid, "delete-drive-snapshot", device => $deviceid, name => $snap);
4042 PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
4046 sub set_migration_caps {
4052 "auto-converge" => 1,
4054 "x-rdma-pin-all" => 0,
4059 my $supported_capabilities = vm_mon_cmd_nocheck($vmid, "query-migrate-capabilities");
4061 for my $supported_capability (@$supported_capabilities) {
4063 capability => $supported_capability->{capability},
4064 state => $enabled_cap->{$supported_capability->{capability}} ? JSON::true : JSON::false,
4068 vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => $cap_ref);
4071 my $fast_plug_option = {
4079 'vmstatestorage
' => 1,
4082 # hotplug changes in [PENDING]
4083 # $selection hash can be used to only apply specified options, for
4084 # example: { cores => 1 } (only apply changed 'cores
')
4085 # $errors ref is used to return error messages
4086 sub vmconfig_hotplug_pending {
4087 my ($vmid, $conf, $storecfg, $selection, $errors) = @_;
4089 my $defaults = load_defaults();
4091 # commit values which do not have any impact on running VM first
4092 # Note: those option cannot raise errors, we we do not care about
4093 # $selection and always apply them.
4095 my $add_error = sub {
4096 my ($opt, $msg) = @_;
4097 $errors->{$opt} = "hotplug problem - $msg";
4101 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4102 if ($fast_plug_option->{$opt}) {
4103 $conf->{$opt} = $conf->{pending}->{$opt};
4104 delete $conf->{pending}->{$opt};
4110 PVE::QemuConfig->write_config($vmid, $conf);
4111 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4114 my $hotplug_features = parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
4116 my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
4117 while (my ($opt, $force) = each %$pending_delete_hash) {
4118 next if $selection && !$selection->{$opt};
4120 if ($opt eq 'hotplug
') {
4121 die "skip\n" if ($conf->{hotplug} =~ /memory/);
4122 } elsif ($opt eq 'tablet
') {
4123 die "skip\n" if !$hotplug_features->{usb};
4124 if ($defaults->{tablet}) {
4125 vm_deviceplug($storecfg, $conf, $vmid, $opt);
4127 vm_deviceunplug($vmid, $conf, $opt);
4129 } elsif ($opt =~ m/^usb\d+/) {
4131 # since we cannot reliably hot unplug usb devices
4132 # we are disabling it
4133 die "skip\n" if !$hotplug_features->{usb} || $conf->{$opt} =~ m/spice/i;
4134 vm_deviceunplug($vmid, $conf, $opt);
4135 } elsif ($opt eq 'vcpus
') {
4136 die "skip\n" if !$hotplug_features->{cpu};
4137 qemu_cpu_hotplug($vmid, $conf, undef);
4138 } elsif ($opt eq 'balloon
') {
4139 # enable balloon device is not hotpluggable
4140 die "skip\n" if !defined($conf->{balloon}) || $conf->{balloon};
4141 } elsif ($fast_plug_option->{$opt}) {
4143 } elsif ($opt =~ m/^net(\d+)$/) {
4144 die "skip\n" if !$hotplug_features->{network};
4145 vm_deviceunplug($vmid, $conf, $opt);
4146 } elsif (is_valid_drivename($opt)) {
4147 die "skip\n" if !$hotplug_features->{disk} || $opt =~ m/(ide|sata)(\d+)/;
4148 vm_deviceunplug($vmid, $conf, $opt);
4149 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4150 } elsif ($opt =~ m/^memory$/) {
4151 die "skip\n" if !$hotplug_features->{memory};
4152 PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt);
4153 } elsif ($opt eq 'cpuunits
') {
4154 cgroups_write("cpu", $vmid, "cpu.shares", $defaults->{cpuunits});
4155 } elsif ($opt eq 'cpulimit
') {
4156 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", -1);
4162 &$add_error($opt, $err) if $err ne "skip\n";
4164 # save new config if hotplug was successful
4165 delete $conf->{$opt};
4166 vmconfig_undelete_pending_option($conf, $opt);
4167 PVE::QemuConfig->write_config($vmid, $conf);
4168 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4172 foreach my $opt (keys %{$conf->{pending}}) {
4173 next if $selection && !$selection->{$opt};
4174 my $value = $conf->{pending}->{$opt};
4176 if ($opt eq 'hotplug
') {
4177 die "skip\n" if ($value =~ /memory/) || ($value !~ /memory/ && $conf->{hotplug} =~ /memory/);
4178 } elsif ($opt eq 'tablet
') {
4179 die "skip\n" if !$hotplug_features->{usb};
4181 vm_deviceplug($storecfg, $conf, $vmid, $opt);
4182 } elsif ($value == 0) {
4183 vm_deviceunplug($vmid, $conf, $opt);
4185 } elsif ($opt =~ m/^usb\d+$/) {
4187 # since we cannot reliably hot unplug usb devices
4188 # we are disabling it
4189 die "skip\n" if !$hotplug_features->{usb} || $value =~ m/spice/i;
4190 my $d = eval { PVE::JSONSchema::parse_property_string($usbdesc->{format}, $value) };
4191 die "skip\n" if !$d;
4192 qemu_usb_hotplug($storecfg, $conf, $vmid, $opt, $d);
4193 } elsif ($opt eq 'vcpus
') {
4194 die "skip\n" if !$hotplug_features->{cpu};
4195 qemu_cpu_hotplug($vmid, $conf, $value);
4196 } elsif ($opt eq 'balloon
') {
4197 # enable/disable balloning device is not hotpluggable
4198 my $old_balloon_enabled = !!(!defined($conf->{balloon}) || $conf->{balloon});
4199 my $new_balloon_enabled = !!(!defined($conf->{pending}->{balloon}) || $conf->{pending}->{balloon});
4200 die "skip\n" if $old_balloon_enabled != $new_balloon_enabled;
4202 # allow manual ballooning if shares is set to zero
4203 if ((defined($conf->{shares}) && ($conf->{shares} == 0))) {
4204 my $balloon = $conf->{pending}->{balloon} || $conf->{memory} || $defaults->{memory};
4205 vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
4207 } elsif ($opt =~ m/^net(\d+)$/) {
4208 # some changes can be done without hotplug
4209 vmconfig_update_net($storecfg, $conf, $hotplug_features->{network},
4210 $vmid, $opt, $value);
4211 } elsif (is_valid_drivename($opt)) {
4212 # some changes can be done without hotplug
4213 vmconfig_update_disk($storecfg, $conf, $hotplug_features->{disk},
4214 $vmid, $opt, $value, 1);
4215 } elsif ($opt =~ m/^memory$/) { #dimms
4216 die "skip\n" if !$hotplug_features->{memory};
4217 $value = PVE::QemuServer::Memory::qemu_memory_hotplug($vmid, $conf, $defaults, $opt, $value);
4218 } elsif ($opt eq 'cpuunits
') {
4219 cgroups_write("cpu", $vmid, "cpu.shares", $conf->{pending}->{$opt});
4220 } elsif ($opt eq 'cpulimit
') {
4221 my $cpulimit = $conf->{pending}->{$opt} == 0 ? -1 : int($conf->{pending}->{$opt} * 100000);
4222 cgroups_write("cpu", $vmid, "cpu.cfs_quota_us", $cpulimit);
4224 die "skip\n"; # skip non-hot-pluggable options
4228 &$add_error($opt, $err) if $err ne "skip\n";
4230 # save new config if hotplug was successful
4231 $conf->{$opt} = $value;
4232 delete $conf->{pending}->{$opt};
4233 PVE::QemuConfig->write_config($vmid, $conf);
4234 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4239 sub try_deallocate_drive {
4240 my ($storecfg, $vmid, $conf, $key, $drive, $rpcenv, $authuser, $force) = @_;
4242 if (($force || $key =~ /^unused/) && !drive_is_cdrom($drive, 1)) {
4243 my $volid = $drive->{file};
4244 if (vm_is_volid_owner($storecfg, $vmid, $volid)) {
4245 my $sid = PVE::Storage::parse_volume_id($volid);
4246 $rpcenv->check($authuser, "/storage/$sid", ['Datastore
.AllocateSpace
']);
4248 # check if the disk is really unused
4249 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
4250 if is_volume_in_use($storecfg, $conf, $key, $volid);
4251 PVE::Storage::vdisk_free($storecfg, $volid);
4254 # If vm is not owner of this disk remove from config
4262 sub vmconfig_delete_or_detach_drive {
4263 my ($vmid, $storecfg, $conf, $opt, $force) = @_;
4265 my $drive = parse_drive($opt, $conf->{$opt});
4267 my $rpcenv = PVE::RPCEnvironment::get();
4268 my $authuser = $rpcenv->get_user();
4271 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM
.Config
.Disk
']);
4272 try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser, $force);
4274 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $drive);
4278 sub vmconfig_apply_pending {
4279 my ($vmid, $conf, $storecfg) = @_;
4283 my $pending_delete_hash = split_flagged_list($conf->{pending}->{delete});
4284 while (my ($opt, $force) = each %$pending_delete_hash) {
4285 die "internal error" if $opt =~ m/^unused/;
4286 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4287 if (!defined($conf->{$opt})) {
4288 vmconfig_undelete_pending_option($conf, $opt);
4289 PVE::QemuConfig->write_config($vmid, $conf);
4290 } elsif (is_valid_drivename($opt)) {
4291 vmconfig_delete_or_detach_drive($vmid, $storecfg, $conf, $opt, $force);
4292 vmconfig_undelete_pending_option($conf, $opt);
4293 delete $conf->{$opt};
4294 PVE::QemuConfig->write_config($vmid, $conf);
4296 vmconfig_undelete_pending_option($conf, $opt);
4297 delete $conf->{$opt};
4298 PVE::QemuConfig->write_config($vmid, $conf);
4302 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4304 foreach my $opt (keys %{$conf->{pending}}) { # add/change
4305 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4307 if (defined($conf->{$opt}) && ($conf->{$opt} eq $conf->{pending}->{$opt})) {
4308 # skip if nothing changed
4309 } elsif (is_valid_drivename($opt)) {
4310 vmconfig_register_unused_drive($storecfg, $vmid, $conf, parse_drive($opt, $conf->{$opt}))
4311 if defined($conf->{$opt});
4312 $conf->{$opt} = $conf->{pending}->{$opt};
4314 $conf->{$opt} = $conf->{pending}->{$opt};
4317 delete $conf->{pending}->{$opt};
4318 PVE::QemuConfig->write_config($vmid, $conf);
4322 my $safe_num_ne = sub {
4325 return 0 if !defined($a) && !defined($b);
4326 return 1 if !defined($a);
4327 return 1 if !defined($b);
4332 my $safe_string_ne = sub {
4335 return 0 if !defined($a) && !defined($b);
4336 return 1 if !defined($a);
4337 return 1 if !defined($b);
4342 sub vmconfig_update_net {
4343 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value) = @_;
4345 my $newnet = parse_net($value);
4347 if ($conf->{$opt}) {
4348 my $oldnet = parse_net($conf->{$opt});
4350 if (&$safe_string_ne($oldnet->{model}, $newnet->{model}) ||
4351 &$safe_string_ne($oldnet->{macaddr}, $newnet->{macaddr}) ||
4352 &$safe_num_ne($oldnet->{queues}, $newnet->{queues}) ||
4353 !($newnet->{bridge} && $oldnet->{bridge})) { # bridge/nat mode change
4355 # for non online change, we try to hot-unplug
4356 die "skip\n" if !$hotplug;
4357 vm_deviceunplug($vmid, $conf, $opt);
4360 die "internal error" if $opt !~ m/net(\d+)/;
4361 my $iface = "tap${vmid}i$1";
4363 if (&$safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
4364 &$safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
4365 &$safe_string_ne($oldnet->{trunks}, $newnet->{trunks}) ||
4366 &$safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
4367 PVE::Network::tap_unplug($iface);
4368 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
4369 } elsif (&$safe_num_ne($oldnet->{rate}, $newnet->{rate})) {
4370 # Rate can be applied on its own but any change above needs to
4371 # include the rate in tap_plug since OVS resets everything.
4372 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
4375 if (&$safe_string_ne($oldnet->{link_down}, $newnet->{link_down})) {
4376 qemu_set_link_status($vmid, $opt, !$newnet->{link_down});
4384 vm_deviceplug($storecfg, $conf, $vmid, $opt, $newnet);
4390 sub vmconfig_update_disk {
4391 my ($storecfg, $conf, $hotplug, $vmid, $opt, $value, $force) = @_;
4393 # fixme: do we need force?
4395 my $drive = parse_drive($opt, $value);
4397 if ($conf->{$opt}) {
4399 if (my $old_drive = parse_drive($opt, $conf->{$opt})) {
4401 my $media = $drive->{media} || 'disk
';
4402 my $oldmedia = $old_drive->{media} || 'disk
';
4403 die "unable to change media type\n" if $media ne $oldmedia;
4405 if (!drive_is_cdrom($old_drive)) {
4407 if ($drive->{file} ne $old_drive->{file}) {
4409 die "skip\n" if !$hotplug;
4411 # unplug and register as unused
4412 vm_deviceunplug($vmid, $conf, $opt);
4413 vmconfig_register_unused_drive($storecfg, $vmid, $conf, $old_drive)
4416 # update existing disk
4418 # skip non hotpluggable value
4419 if (&$safe_string_ne($drive->{discard}, $old_drive->{discard}) ||
4420 &$safe_string_ne($drive->{iothread}, $old_drive->{iothread}) ||
4421 &$safe_string_ne($drive->{queues}, $old_drive->{queues}) ||
4422 &$safe_string_ne($drive->{cache}, $old_drive->{cache})) {
4427 if (&$safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
4428 &$safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
4429 &$safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
4430 &$safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
4431 &$safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
4432 &$safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr}) ||
4433 &$safe_num_ne($drive->{mbps_max}, $old_drive->{mbps_max}) ||
4434 &$safe_num_ne($drive->{mbps_rd_max}, $old_drive->{mbps_rd_max}) ||
4435 &$safe_num_ne($drive->{mbps_wr_max}, $old_drive->{mbps_wr_max}) ||
4436 &$safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
4437 &$safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
4438 &$safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max}) ||
4439 &$safe_num_ne($drive->{bps_max_length}, $old_drive->{bps_max_length}) ||
4440 &$safe_num_ne($drive->{bps_rd_max_length}, $old_drive->{bps_rd_max_length}) ||
4441 &$safe_num_ne($drive->{bps_wr_max_length}, $old_drive->{bps_wr_max_length}) ||
4442 &$safe_num_ne($drive->{iops_max_length}, $old_drive->{iops_max_length}) ||
4443 &$safe_num_ne($drive->{iops_rd_max_length}, $old_drive->{iops_rd_max_length}) ||
4444 &$safe_num_ne($drive->{iops_wr_max_length}, $old_drive->{iops_wr_max_length})) {
4446 qemu_block_set_io_throttle($vmid,"drive-$opt",
4447 ($drive->{mbps} || 0)*1024*1024,
4448 ($drive->{mbps_rd} || 0)*1024*1024,
4449 ($drive->{mbps_wr} || 0)*1024*1024,
4450 $drive->{iops} || 0,
4451 $drive->{iops_rd} || 0,
4452 $drive->{iops_wr} || 0,
4453 ($drive->{mbps_max} || 0)*1024*1024,
4454 ($drive->{mbps_rd_max} || 0)*1024*1024,
4455 ($drive->{mbps_wr_max} || 0)*1024*1024,
4456 $drive->{iops_max} || 0,
4457 $drive->{iops_rd_max} || 0,
4458 $drive->{iops_wr_max} || 0,
4459 $drive->{bps_max_length} || 1,
4460 $drive->{bps_rd_max_length} || 1,
4461 $drive->{bps_wr_max_length} || 1,
4462 $drive->{iops_max_length} || 1,
4463 $drive->{iops_rd_max_length} || 1,
4464 $drive->{iops_wr_max_length} || 1);
4473 if ($drive->{file} eq 'none
') {
4474 vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
4476 my $path = get_iso_path($storecfg, $vmid, $drive->{file});
4477 vm_mon_cmd($vmid, "eject", force => JSON::true,device => "drive-$opt"); # force eject if locked
4478 vm_mon_cmd($vmid, "change", device => "drive-$opt",target => "$path") if $path;
4486 die "skip\n" if !$hotplug || $opt =~ m/(ide|sata)(\d+)/;
4488 PVE::Storage::activate_volumes($storecfg, [$drive->{file}]) if $drive->{file} !~ m|^/dev/.+|;
4489 vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
4493 my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused,
4494 $forcemachine, $spice_ticket, $migration_network, $migration_type, $targetstorage) = @_;
4496 PVE::QemuConfig->lock_config($vmid, sub {
4497 my $conf = PVE::QemuConfig->load_config($vmid, $migratedfrom);
4499 die "you can't start a vm
if it
's a template\n" if PVE::QemuConfig->is_template($conf);
4501 PVE::QemuConfig->check_lock($conf) if !$skiplock;
4503 die "VM $vmid already running\n" if check_running($vmid, undef, $migratedfrom);
4505 if (!$statefile && scalar(keys %{$conf->{pending}})) {
4506 vmconfig_apply_pending($vmid, $conf, $storecfg);
4507 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
4510 my $defaults = load_defaults();
4512 # set environment variable useful inside network script
4513 $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
4515 my $local_volumes = {};
4517 if ($targetstorage) {
4518 foreach_drive($conf, sub {
4519 my ($ds, $drive) = @_;
4521 return if drive_is_cdrom($drive);
4523 my $volid = $drive->{file};
4527 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
4529 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4530 return if $scfg->{shared};
4531 $local_volumes->{$ds} = [$volid, $storeid, $volname];
4536 foreach my $opt (sort keys %$local_volumes) {
4538 my ($volid, $storeid, $volname) = @{$local_volumes->{$opt}};
4539 my $drive = parse_drive($opt, $conf->{$opt});
4541 #if remote storage is specified, use default format
4542 if ($targetstorage && $targetstorage ne "1") {
4543 $storeid = $targetstorage;
4544 my ($defFormat, $validFormats) = PVE::Storage::storage_default_format($storecfg, $storeid);
4545 $format = $defFormat;
4547 #else we use same format than original
4548 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
4549 $format = qemu_img_format($scfg, $volid);
4552 my $newvolid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $format, undef, ($drive->{size}/1024));
4553 my $newdrive = $drive;
4554 $newdrive->{format} = $format;
4555 $newdrive->{file} = $newvolid;
4556 my $drivestr = PVE::QemuServer::print_drive($vmid, $newdrive);
4557 $local_volumes->{$opt} = $drivestr;
4558 #pass drive to conf for command line
4559 $conf->{$opt} = $drivestr;
4563 my ($cmd, $vollist, $spice_port) = config_to_command($storecfg, $vmid, $conf, $defaults, $forcemachine);
4565 my $migrate_port = 0;
4568 if ($statefile eq 'tcp
') {
4569 my $localip = "localhost";
4570 my $datacenterconf = PVE::Cluster::cfs_read_file('datacenter
.cfg
');
4571 my $nodename = PVE::INotify::nodename();
4573 if (!defined($migration_type)) {
4574 if (defined($datacenterconf->{migration}->{type})) {
4575 $migration_type = $datacenterconf->{migration}->{type};
4577 $migration_type = 'secure
';
4581 if ($migration_type eq 'insecure
') {
4582 my $migrate_network_addr = PVE::Cluster::get_local_migration_ip($migration_network);
4583 if ($migrate_network_addr) {
4584 $localip = $migrate_network_addr;
4586 $localip = PVE::Cluster::remote_node_ip($nodename, 1);
4589 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
4592 my $pfamily = PVE::Tools::get_host_address_family($nodename);
4593 $migrate_port = PVE::Tools::next_migrate_port($pfamily);
4594 $migrate_uri = "tcp:${localip}:${migrate_port}";
4595 push @$cmd, '-incoming
', $migrate_uri;
4598 } elsif ($statefile eq 'unix
') {
4599 # should be default for secure migrations as a ssh TCP forward
4600 # tunnel is not deterministic reliable ready and fails regurarly
4601 # to set up in time, so use UNIX socket forwards
4602 my $socket_addr = "/run/qemu-server/$vmid.migrate";
4603 unlink $socket_addr;
4605 $migrate_uri = "unix:$socket_addr";
4607 push @$cmd, '-incoming
', $migrate_uri;
4611 push @$cmd, '-loadstate
', $statefile;
4618 for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
4619 my $d = parse_hostpci($conf->{"hostpci$i"});
4621 my $pcidevices = $d->{pciid};
4622 foreach my $pcidevice (@$pcidevices) {
4623 my $pciid = $pcidevice->{id}.".".$pcidevice->{function};
4625 my $info = pci_device_info("0000:$pciid");
4626 die "IOMMU not present\n" if !check_iommu_support();
4627 die "no pci device info for device '$pciid'\n" if !$info;
4628 die "can't unbind
/bind pci group to vfio
'$pciid'\n" if !pci_dev_group_bind_to_vfio($pciid);
4629 die "can
't reset pci device '$pciid'\n" if $info->{has_fl_reset} and !pci_dev_reset($info);
4633 PVE::Storage::activate_volumes($storecfg, $vollist);
4635 if (!check_running($vmid, 1) && -d "/sys/fs/cgroup/systemd/qemu.slice/$vmid.scope") {
4637 push @$cmd, '/bin/systemctl
', 'stop
', "$vmid.scope";
4638 eval { run_command($cmd); };
4641 my $cpuunits = defined($conf->{cpuunits}) ? $conf->{cpuunits}
4642 : $defaults->{cpuunits};
4644 my %run_params = (timeout => $statefile ? undef : 30, umask => 0077);
4647 Slice => 'qemu
.slice
',
4649 CPUShares => $cpuunits
4652 if (my $cpulimit = $conf->{cpulimit}) {
4653 $properties{CPUQuota} = int($cpulimit * 100);
4655 $properties{timeout} = 10 if $statefile; # setting up the scope shoul be quick
4657 if ($conf->{hugepages}) {
4660 my $hugepages_topology = PVE::QemuServer::Memory::hugepages_topology($conf);
4661 my $hugepages_host_topology = PVE::QemuServer::Memory::hugepages_host_topology();
4663 PVE::QemuServer::Memory::hugepages_mount();
4664 PVE::QemuServer::Memory::hugepages_allocate($hugepages_topology, $hugepages_host_topology);
4667 PVE::Tools::enter_systemd_scope($vmid, "Proxmox VE VM $vmid", %properties);
4668 run_command($cmd, %run_params);
4672 PVE::QemuServer::Memory::hugepages_reset($hugepages_host_topology);
4676 PVE::QemuServer::Memory::hugepages_pre_deallocate($hugepages_topology);
4678 eval { PVE::QemuServer::Memory::hugepages_update_locked($code); };
4682 PVE::Tools::enter_systemd_scope($vmid, "Proxmox VE VM $vmid", %properties);
4683 run_command($cmd, %run_params);
4688 # deactivate volumes if start fails
4689 eval { PVE::Storage::deactivate_volumes($storecfg, $vollist); };
4690 die "start failed: $err";
4693 print "migration listens on $migrate_uri\n" if $migrate_uri;
4695 if ($statefile && $statefile ne 'tcp
' && $statefile ne 'unix
') {
4696 eval { vm_mon_cmd_nocheck($vmid, "cont"); };
4700 #start nbd server for storage migration
4701 if ($targetstorage) {
4702 my $nodename = PVE::INotify::nodename();
4703 my $migrate_network_addr = PVE::Cluster::get_local_migration_ip($migration_network);
4704 my $localip = $migrate_network_addr ? $migrate_network_addr : PVE::Cluster::remote_node_ip($nodename, 1);
4705 my $pfamily = PVE::Tools::get_host_address_family($nodename);
4706 $migrate_port = PVE::Tools::next_migrate_port($pfamily);
4708 vm_mon_cmd_nocheck($vmid, "nbd-server-start", addr => { type => 'inet
', data => { host => "${localip}", port => "${migrate_port}" } } );
4710 $localip = "[$localip]" if Net::IP::ip_is_ipv6($localip);
4712 foreach my $opt (sort keys %$local_volumes) {
4713 my $volid = $local_volumes->{$opt};
4714 vm_mon_cmd_nocheck($vmid, "nbd-server-add", device => "drive-$opt", writable => JSON::true );
4715 my $migrate_storage_uri = "nbd:${localip}:${migrate_port}:exportname=drive-$opt";
4716 print "storage migration listens on $migrate_storage_uri volume:$volid\n";
4720 if ($migratedfrom) {
4722 set_migration_caps($vmid);
4727 print "spice listens on port $spice_port\n";
4728 if ($spice_ticket) {
4729 vm_mon_cmd_nocheck($vmid, "set_password", protocol => 'spice
', password => $spice_ticket);
4730 vm_mon_cmd_nocheck($vmid, "expire_password", protocol => 'spice
', time => "+30");
4735 if (!$statefile && (!defined($conf->{balloon}) || $conf->{balloon})) {
4736 vm_mon_cmd_nocheck($vmid, "balloon", value => $conf->{balloon}*1024*1024)
4737 if $conf->{balloon};
4740 foreach my $opt (keys %$conf) {
4741 next if $opt !~ m/^net\d+$/;
4742 my $nicconf = parse_net($conf->{$opt});
4743 qemu_set_link_status($vmid, $opt, 0) if $nicconf->{link_down};
4747 vm_mon_cmd_nocheck($vmid, 'qom-set
',
4748 path => "machine/peripheral/balloon0",
4749 property => "guest-stats-polling-interval",
4750 value => 2) if (!defined($conf->{balloon}) || $conf->{balloon});
4756 my ($vmid, $execute, %params) = @_;
4758 my $cmd = { execute => $execute, arguments => \%params };
4759 vm_qmp_command($vmid, $cmd);
4762 sub vm_mon_cmd_nocheck {
4763 my ($vmid, $execute, %params) = @_;
4765 my $cmd = { execute => $execute, arguments => \%params };
4766 vm_qmp_command($vmid, $cmd, 1);
4769 sub vm_qmp_command {
4770 my ($vmid, $cmd, $nocheck) = @_;
4775 if ($cmd->{arguments} && $cmd->{arguments}->{timeout}) {
4776 $timeout = $cmd->{arguments}->{timeout};
4777 delete $cmd->{arguments}->{timeout};
4781 die "VM $vmid not running\n" if !check_running($vmid, $nocheck);
4782 my $sname = qmp_socket($vmid);
4783 if (-e $sname) { # test if VM is reasonambe new and supports qmp/qga
4784 my $qmpclient = PVE::QMPClient->new();
4786 $res = $qmpclient->cmd($vmid, $cmd, $timeout);
4787 } elsif (-e "${var_run_tmpdir}/$vmid.mon") {
4788 die "can't execute complex command on old monitor
- stop
/start your vm to fix the problem
\n"
4789 if scalar(%{$cmd->{arguments}});
4790 vm_monitor_command($vmid, $cmd->{execute}, $nocheck);
4792 die "unable to
open monitor
socket\n";
4796 syslog("err
", "VM
$vmid qmp command failed
- $err");
4803 sub vm_human_monitor_command {
4804 my ($vmid, $cmdline) = @_;
4809 execute => 'human-monitor-command',
4810 arguments => { 'command-line' => $cmdline},
4813 return vm_qmp_command($vmid, $cmd);
4816 sub vm_commandline {
4817 my ($storecfg, $vmid) = @_;
4819 my $conf = PVE::QemuConfig->load_config($vmid);
4821 my $defaults = load_defaults();
4823 my $cmd = config_to_command($storecfg, $vmid, $conf, $defaults);
4825 return PVE::Tools::cmd2string($cmd);
4829 my ($vmid, $skiplock) = @_;
4831 PVE::QemuConfig->lock_config($vmid, sub {
4833 my $conf = PVE::QemuConfig->load_config($vmid);
4835 PVE::QemuConfig->check_lock($conf) if !$skiplock;
4837 vm_mon_cmd($vmid, "system_reset
");
4841 sub get_vm_volumes {
4845 foreach_volid($conf, sub {
4846 my ($volid, $attr) = @_;
4848 return if $volid =~ m|^/|;
4850 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
4853 push @$vollist, $volid;
4859 sub vm_stop_cleanup {
4860 my ($storecfg, $vmid, $conf, $keepActive, $apply_pending_changes) = @_;
4865 my $vollist = get_vm_volumes($conf);
4866 PVE::Storage::deactivate_volumes($storecfg, $vollist);
4869 foreach my $ext (qw(mon qmp pid vnc qga)) {
4870 unlink "/var/run/qemu-server/${vmid}.$ext";
4873 vmconfig_apply_pending
($vmid, $conf, $storecfg) if $apply_pending_changes;
4875 warn $@ if $@; # avoid errors - just warn
4878 # Note: use $nockeck to skip tests if VM configuration file exists.
4879 # We need that when migration VMs to other nodes (files already moved)
4880 # Note: we set $keepActive in vzdump stop mode - volumes need to stay active
4882 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
4884 $force = 1 if !defined($force) && !$shutdown;
4887 my $pid = check_running
($vmid, $nocheck, $migratedfrom);
4888 kill 15, $pid if $pid;
4889 my $conf = PVE
::QemuConfig-
>load_config($vmid, $migratedfrom);
4890 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 0);
4894 PVE
::QemuConfig-
>lock_config($vmid, sub {
4896 my $pid = check_running
($vmid, $nocheck);
4901 $conf = PVE
::QemuConfig-
>load_config($vmid);
4902 PVE
::QemuConfig-
>check_lock($conf) if !$skiplock;
4903 if (!defined($timeout) && $shutdown && $conf->{startup
}) {
4904 my $opts = PVE
::JSONSchema
::pve_parse_startup_order
($conf->{startup
});
4905 $timeout = $opts->{down
} if $opts->{down
};
4909 $timeout = 60 if !defined($timeout);
4913 if (defined($conf) && $conf->{agent
}) {
4914 vm_qmp_command
($vmid, { execute
=> "guest-shutdown" }, $nocheck);
4916 vm_qmp_command
($vmid, { execute
=> "system_powerdown" }, $nocheck);
4919 vm_qmp_command
($vmid, { execute
=> "quit" }, $nocheck);
4926 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
4931 if ($count >= $timeout) {
4933 warn "VM still running - terminating now with SIGTERM\n";
4936 die "VM quit/powerdown failed - got timeout\n";
4939 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
4944 warn "VM quit/powerdown failed - terminating now with SIGTERM\n";
4947 die "VM quit/powerdown failed\n";
4955 while (($count < $timeout) && check_running
($vmid, $nocheck)) {
4960 if ($count >= $timeout) {
4961 warn "VM still running - terminating now with SIGKILL\n";
4966 vm_stop_cleanup
($storecfg, $vmid, $conf, $keepActive, 1) if $conf;
4971 my ($vmid, $skiplock) = @_;
4973 PVE
::QemuConfig-
>lock_config($vmid, sub {
4975 my $conf = PVE
::QemuConfig-
>load_config($vmid);
4977 PVE
::QemuConfig-
>check_lock($conf)
4978 if !($skiplock || PVE
::QemuConfig-
>has_lock($conf, 'backup'));
4980 vm_mon_cmd
($vmid, "stop");
4985 my ($vmid, $skiplock, $nocheck) = @_;
4987 PVE
::QemuConfig-
>lock_config($vmid, sub {
4991 my $conf = PVE
::QemuConfig-
>load_config($vmid);
4993 PVE
::QemuConfig-
>check_lock($conf)
4994 if !($skiplock || PVE
::QemuConfig-
>has_lock($conf, 'backup'));
4996 vm_mon_cmd
($vmid, "cont");
4999 vm_mon_cmd_nocheck
($vmid, "cont");
5005 my ($vmid, $skiplock, $key) = @_;
5007 PVE
::QemuConfig-
>lock_config($vmid, sub {
5009 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5011 # there is no qmp command, so we use the human monitor command
5012 vm_human_monitor_command
($vmid, "sendkey $key");
5017 my ($storecfg, $vmid, $skiplock) = @_;
5019 PVE
::QemuConfig-
>lock_config($vmid, sub {
5021 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5023 if (!check_running
($vmid)) {
5024 destroy_vm
($storecfg, $vmid, undef, $skiplock);
5026 die "VM $vmid is running - destroy failed\n";
5034 my ($filename, $buf) = @_;
5036 my $fh = IO
::File-
>new($filename, "w");
5037 return undef if !$fh;
5039 my $res = print $fh $buf;
5046 sub pci_device_info
{
5051 return undef if $name !~ m/^([a-f0-9]{4}):([a-f0-9]{2}):([a-f0-9]{2})\.([a-f0-9])$/;
5052 my ($domain, $bus, $slot, $func) = ($1, $2, $3, $4);
5054 my $irq = file_read_firstline
("$pcisysfs/devices/$name/irq");
5055 return undef if !defined($irq) || $irq !~ m/^\d+$/;
5057 my $vendor = file_read_firstline
("$pcisysfs/devices/$name/vendor");
5058 return undef if !defined($vendor) || $vendor !~ s/^0x//;
5060 my $product = file_read_firstline
("$pcisysfs/devices/$name/device");
5061 return undef if !defined($product) || $product !~ s/^0x//;
5066 product
=> $product,
5072 has_fl_reset
=> -f
"$pcisysfs/devices/$name/reset" || 0,
5081 my $name = $dev->{name
};
5083 my $fn = "$pcisysfs/devices/$name/reset";
5085 return file_write
($fn, "1");
5088 sub pci_dev_bind_to_vfio
{
5091 my $name = $dev->{name
};
5093 my $vfio_basedir = "$pcisysfs/drivers/vfio-pci";
5095 if (!-d
$vfio_basedir) {
5096 system("/sbin/modprobe vfio-pci >/dev/null 2>/dev/null");
5098 die "Cannot find vfio-pci module!\n" if !-d
$vfio_basedir;
5100 my $testdir = "$vfio_basedir/$name";
5101 return 1 if -d
$testdir;
5103 my $data = "$dev->{vendor} $dev->{product}";
5104 return undef if !file_write
("$vfio_basedir/new_id", $data);
5106 my $fn = "$pcisysfs/devices/$name/driver/unbind";
5107 if (!file_write
($fn, $name)) {
5108 return undef if -f
$fn;
5111 $fn = "$vfio_basedir/bind";
5112 if (! -d
$testdir) {
5113 return undef if !file_write
($fn, $name);
5119 sub pci_dev_group_bind_to_vfio
{
5122 my $vfio_basedir = "$pcisysfs/drivers/vfio-pci";
5124 if (!-d
$vfio_basedir) {
5125 system("/sbin/modprobe vfio-pci >/dev/null 2>/dev/null");
5127 die "Cannot find vfio-pci module!\n" if !-d
$vfio_basedir;
5129 # get IOMMU group devices
5130 opendir(my $D, "$pcisysfs/devices/0000:$pciid/iommu_group/devices/") || die "Cannot open iommu_group: $!\n";
5131 my @devs = grep /^0000:/, readdir($D);
5134 foreach my $pciid (@devs) {
5135 $pciid =~ m/^([:\.\da-f]+)$/ or die "PCI ID $pciid not valid!\n";
5137 # pci bridges, switches or root ports are not supported
5138 # they have a pci_bus subdirectory so skip them
5139 next if (-e
"$pcisysfs/devices/$pciid/pci_bus");
5141 my $info = pci_device_info
($1);
5142 pci_dev_bind_to_vfio
($info) || die "Cannot bind $pciid to vfio\n";
5148 # vzdump restore implementaion
5150 sub tar_archive_read_firstfile
{
5151 my $archive = shift;
5153 die "ERROR: file '$archive' does not exist\n" if ! -f
$archive;
5155 # try to detect archive type first
5156 my $pid = open (my $fh, '-|', 'tar', 'tf', $archive) ||
5157 die "unable to open file '$archive'\n";
5158 my $firstfile = <$fh>;
5162 die "ERROR: archive contaions no data\n" if !$firstfile;
5168 sub tar_restore_cleanup
{
5169 my ($storecfg, $statfile) = @_;
5171 print STDERR
"starting cleanup\n";
5173 if (my $fd = IO
::File-
>new($statfile, "r")) {
5174 while (defined(my $line = <$fd>)) {
5175 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
5178 if ($volid =~ m
|^/|) {
5179 unlink $volid || die 'unlink failed\n';
5181 PVE
::Storage
::vdisk_free
($storecfg, $volid);
5183 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
5185 print STDERR
"unable to cleanup '$volid' - $@" if $@;
5187 print STDERR
"unable to parse line in statfile - $line";
5194 sub restore_archive
{
5195 my ($archive, $vmid, $user, $opts) = @_;
5197 my $format = $opts->{format
};
5200 if ($archive =~ m/\.tgz$/ || $archive =~ m/\.tar\.gz$/) {
5201 $format = 'tar' if !$format;
5203 } elsif ($archive =~ m/\.tar$/) {
5204 $format = 'tar' if !$format;
5205 } elsif ($archive =~ m/.tar.lzo$/) {
5206 $format = 'tar' if !$format;
5208 } elsif ($archive =~ m/\.vma$/) {
5209 $format = 'vma' if !$format;
5210 } elsif ($archive =~ m/\.vma\.gz$/) {
5211 $format = 'vma' if !$format;
5213 } elsif ($archive =~ m/\.vma\.lzo$/) {
5214 $format = 'vma' if !$format;
5217 $format = 'vma' if !$format; # default
5220 # try to detect archive format
5221 if ($format eq 'tar') {
5222 return restore_tar_archive
($archive, $vmid, $user, $opts);
5224 return restore_vma_archive
($archive, $vmid, $user, $opts, $comp);
5228 sub restore_update_config_line
{
5229 my ($outfd, $cookie, $vmid, $map, $line, $unique) = @_;
5231 return if $line =~ m/^\#qmdump\#/;
5232 return if $line =~ m/^\#vzdump\#/;
5233 return if $line =~ m/^lock:/;
5234 return if $line =~ m/^unused\d+:/;
5235 return if $line =~ m/^parent:/;
5236 return if $line =~ m/^template:/; # restored VM is never a template
5238 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
5239 if (($line =~ m/^(vlan(\d+)):\s*(\S+)\s*$/)) {
5240 # try to convert old 1.X settings
5241 my ($id, $ind, $ethcfg) = ($1, $2, $3);
5242 foreach my $devconfig (PVE
::Tools
::split_list
($ethcfg)) {
5243 my ($model, $macaddr) = split(/\=/, $devconfig);
5244 $macaddr = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if !$macaddr || $unique;
5247 bridge
=> "vmbr$ind",
5248 macaddr
=> $macaddr,
5250 my $netstr = print_net
($net);
5252 print $outfd "net$cookie->{netcount}: $netstr\n";
5253 $cookie->{netcount
}++;
5255 } elsif (($line =~ m/^(net\d+):\s*(\S+)\s*$/) && $unique) {
5256 my ($id, $netstr) = ($1, $2);
5257 my $net = parse_net
($netstr);
5258 $net->{macaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
}) if $net->{macaddr
};
5259 $netstr = print_net
($net);
5260 print $outfd "$id: $netstr\n";
5261 } elsif ($line =~ m/^((ide|scsi|virtio|sata|efidisk)\d+):\s*(\S+)\s*$/) {
5264 my $di = parse_drive
($virtdev, $value);
5265 if (defined($di->{backup
}) && !$di->{backup
}) {
5266 print $outfd "#$line";
5267 } elsif ($map->{$virtdev}) {
5268 delete $di->{format
}; # format can change on restore
5269 $di->{file
} = $map->{$virtdev};
5270 $value = print_drive
($vmid, $di);
5271 print $outfd "$virtdev: $value\n";
5281 my ($cfg, $vmid) = @_;
5283 my $info = PVE
::Storage
::vdisk_list
($cfg, undef, $vmid);
5285 my $volid_hash = {};
5286 foreach my $storeid (keys %$info) {
5287 foreach my $item (@{$info->{$storeid}}) {
5288 next if !($item->{volid
} && $item->{size
});
5289 $item->{path
} = PVE
::Storage
::path
($cfg, $item->{volid
});
5290 $volid_hash->{$item->{volid
}} = $item;
5297 sub is_volume_in_use
{
5298 my ($storecfg, $conf, $skip_drive, $volid) = @_;
5300 my $path = PVE
::Storage
::path
($storecfg, $volid);
5302 my $scan_config = sub {
5303 my ($cref, $snapname) = @_;
5305 foreach my $key (keys %$cref) {
5306 my $value = $cref->{$key};
5307 if (is_valid_drivename
($key)) {
5308 next if $skip_drive && $key eq $skip_drive;
5309 my $drive = parse_drive
($key, $value);
5310 next if !$drive || !$drive->{file
} || drive_is_cdrom
($drive);
5311 return 1 if $volid eq $drive->{file
};
5312 if ($drive->{file
} =~ m!^/!) {
5313 return 1 if $drive->{file
} eq $path;
5315 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
}, 1);
5317 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid, 1);
5319 return 1 if $path eq PVE
::Storage
::path
($storecfg, $drive->{file
}, $snapname);
5327 return 1 if &$scan_config($conf);
5331 foreach my $snapname (keys %{$conf->{snapshots
}}) {
5332 return 1 if &$scan_config($conf->{snapshots
}->{$snapname}, $snapname);
5338 sub update_disksize
{
5339 my ($vmid, $conf, $volid_hash) = @_;
5345 # Note: it is allowed to define multiple storages with same path (alias), so
5346 # we need to check both 'volid' and real 'path' (two different volid can point
5347 # to the same path).
5352 foreach my $opt (keys %$conf) {
5353 if (is_valid_drivename
($opt)) {
5354 my $drive = parse_drive
($opt, $conf->{$opt});
5355 my $volid = $drive->{file
};
5358 $used->{$volid} = 1;
5359 if ($volid_hash->{$volid} &&
5360 (my $path = $volid_hash->{$volid}->{path
})) {
5361 $usedpath->{$path} = 1;
5364 next if drive_is_cdrom
($drive);
5365 next if !$volid_hash->{$volid};
5367 $drive->{size
} = $volid_hash->{$volid}->{size
};
5368 my $new = print_drive
($vmid, $drive);
5369 if ($new ne $conf->{$opt}) {
5371 $conf->{$opt} = $new;
5376 # remove 'unusedX' entry if volume is used
5377 foreach my $opt (keys %$conf) {
5378 next if $opt !~ m/^unused\d+$/;
5379 my $volid = $conf->{$opt};
5380 my $path = $volid_hash->{$volid}->{path
} if $volid_hash->{$volid};
5381 if ($used->{$volid} || ($path && $usedpath->{$path})) {
5383 delete $conf->{$opt};
5387 foreach my $volid (sort keys %$volid_hash) {
5388 next if $volid =~ m/vm-$vmid-state-/;
5389 next if $used->{$volid};
5390 my $path = $volid_hash->{$volid}->{path
};
5391 next if !$path; # just to be sure
5392 next if $usedpath->{$path};
5394 PVE
::QemuConfig-
>add_unused_volume($conf, $volid);
5395 $usedpath->{$path} = 1; # avoid to add more than once (aliases)
5402 my ($vmid, $nolock) = @_;
5404 my $cfg = PVE
::Storage
::config
();
5406 my $volid_hash = scan_volids
($cfg, $vmid);
5408 my $updatefn = sub {
5411 my $conf = PVE
::QemuConfig-
>load_config($vmid);
5413 PVE
::QemuConfig-
>check_lock($conf);
5416 foreach my $volid (keys %$volid_hash) {
5417 my $info = $volid_hash->{$volid};
5418 $vm_volids->{$volid} = $info if $info->{vmid
} && $info->{vmid
} == $vmid;
5421 my $changes = update_disksize
($vmid, $conf, $vm_volids);
5423 PVE
::QemuConfig-
>write_config($vmid, $conf) if $changes;
5426 if (defined($vmid)) {
5430 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
5433 my $vmlist = config_list
();
5434 foreach my $vmid (keys %$vmlist) {
5438 PVE
::QemuConfig-
>lock_config($vmid, $updatefn, $vmid);
5444 sub restore_vma_archive
{
5445 my ($archive, $vmid, $user, $opts, $comp) = @_;
5447 my $input = $archive eq '-' ?
"<&STDIN" : undef;
5448 my $readfrom = $archive;
5453 my $qarchive = PVE
::Tools
::shellquote
($archive);
5454 if ($comp eq 'gzip') {
5455 $uncomp = "zcat $qarchive|";
5456 } elsif ($comp eq 'lzop') {
5457 $uncomp = "lzop -d -c $qarchive|";
5459 die "unknown compression method '$comp'\n";
5464 my $tmpdir = "/var/tmp/vzdumptmp$$";
5467 # disable interrupts (always do cleanups)
5471 local $SIG{HUP
} = sub { warn "got interrupt - ignored\n"; };
5473 my $mapfifo = "/var/tmp/vzdumptmp$$.fifo";
5474 POSIX
::mkfifo
($mapfifo, 0600);
5477 my $openfifo = sub {
5478 open($fifofh, '>', $mapfifo) || die $!;
5481 my $cmd = "${uncomp}vma extract -v -r $mapfifo $readfrom $tmpdir";
5488 my $rpcenv = PVE
::RPCEnvironment
::get
();
5490 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
5491 my $tmpfn = "$conffile.$$.tmp";
5493 # Note: $oldconf is undef if VM does not exists
5494 my $cfs_path = PVE
::QemuConfig-
>cfs_config_path($vmid);
5495 my $oldconf = PVE
::Cluster
::cfs_read_file
($cfs_path);
5497 my $print_devmap = sub {
5498 my $virtdev_hash = {};
5500 my $cfgfn = "$tmpdir/qemu-server.conf";
5502 # we can read the config - that is already extracted
5503 my $fh = IO
::File-
>new($cfgfn, "r") ||
5504 "unable to read qemu-server.conf - $!\n";
5506 my $fwcfgfn = "$tmpdir/qemu-server.fw";
5508 my $pve_firewall_dir = '/etc/pve/firewall';
5509 mkdir $pve_firewall_dir; # make sure the dir exists
5510 PVE
::Tools
::file_copy
($fwcfgfn, "${pve_firewall_dir}/$vmid.fw");
5513 while (defined(my $line = <$fh>)) {
5514 if ($line =~ m/^\#qmdump\#map:(\S+):(\S+):(\S*):(\S*):$/) {
5515 my ($virtdev, $devname, $storeid, $format) = ($1, $2, $3, $4);
5516 die "archive does not contain data for drive '$virtdev'\n"
5517 if !$devinfo->{$devname};
5518 if (defined($opts->{storage
})) {
5519 $storeid = $opts->{storage
} || 'local';
5520 } elsif (!$storeid) {
5523 $format = 'raw' if !$format;
5524 $devinfo->{$devname}->{devname
} = $devname;
5525 $devinfo->{$devname}->{virtdev
} = $virtdev;
5526 $devinfo->{$devname}->{format
} = $format;
5527 $devinfo->{$devname}->{storeid
} = $storeid;
5529 # check permission on storage
5530 my $pool = $opts->{pool
}; # todo: do we need that?
5531 if ($user ne 'root@pam') {
5532 $rpcenv->check($user, "/storage/$storeid", ['Datastore.AllocateSpace']);
5535 $virtdev_hash->{$virtdev} = $devinfo->{$devname};
5539 foreach my $devname (keys %$devinfo) {
5540 die "found no device mapping information for device '$devname'\n"
5541 if !$devinfo->{$devname}->{virtdev
};
5544 my $cfg = PVE
::Storage
::config
();
5546 # create empty/temp config
5548 PVE
::Tools
::file_set_contents
($conffile, "memory: 128\n");
5549 foreach_drive
($oldconf, sub {
5550 my ($ds, $drive) = @_;
5552 return if drive_is_cdrom
($drive);
5554 my $volid = $drive->{file
};
5556 return if !$volid || $volid =~ m
|^/|;
5558 my ($path, $owner) = PVE
::Storage
::path
($cfg, $volid);
5559 return if !$path || !$owner || ($owner != $vmid);
5561 # Note: only delete disk we want to restore
5562 # other volumes will become unused
5563 if ($virtdev_hash->{$ds}) {
5564 eval { PVE
::Storage
::vdisk_free
($cfg, $volid); };
5571 # delete vmstate files
5572 # since after the restore we have no snapshots anymore
5573 foreach my $snapname (keys %{$oldconf->{snapshots
}}) {
5574 my $snap = $oldconf->{snapshots
}->{$snapname};
5575 if ($snap->{vmstate
}) {
5576 eval { PVE
::Storage
::vdisk_free
($cfg, $snap->{vmstate
}); };
5585 foreach my $virtdev (sort keys %$virtdev_hash) {
5586 my $d = $virtdev_hash->{$virtdev};
5587 my $alloc_size = int(($d->{size
} + 1024 - 1)/1024);
5588 my $scfg = PVE
::Storage
::storage_config
($cfg, $d->{storeid
});
5590 # test if requested format is supported
5591 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($cfg, $d->{storeid
});
5592 my $supported = grep { $_ eq $d->{format
} } @$validFormats;
5593 $d->{format
} = $defFormat if !$supported;
5595 my $volid = PVE
::Storage
::vdisk_alloc
($cfg, $d->{storeid
}, $vmid,
5596 $d->{format
}, undef, $alloc_size);
5597 print STDERR
"new volume ID is '$volid'\n";
5598 $d->{volid
} = $volid;
5599 my $path = PVE
::Storage
::path
($cfg, $volid);
5601 PVE
::Storage
::activate_volumes
($cfg,[$volid]);
5603 my $write_zeros = 1;
5604 if (PVE
::Storage
::volume_has_feature
($cfg, 'sparseinit', $volid)) {
5608 print $fifofh "format=$d->{format}:${write_zeros}:$d->{devname}=$path\n";
5610 print "map '$d->{devname}' to '$path' (write zeros = ${write_zeros})\n";
5611 $map->{$virtdev} = $volid;
5614 $fh->seek(0, 0) || die "seek failed - $!\n";
5616 my $outfd = new IO
::File
($tmpfn, "w") ||
5617 die "unable to write config for VM $vmid\n";
5619 my $cookie = { netcount
=> 0 };
5620 while (defined(my $line = <$fh>)) {
5621 restore_update_config_line
($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
5634 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
5635 local $SIG{ALRM
} = sub { die "got timeout\n"; };
5637 $oldtimeout = alarm($timeout);
5644 if ($line =~ m/^DEV:\sdev_id=(\d+)\ssize:\s(\d+)\sdevname:\s(\S+)$/) {
5645 my ($dev_id, $size, $devname) = ($1, $2, $3);
5646 $devinfo->{$devname} = { size
=> $size, dev_id
=> $dev_id };
5647 } elsif ($line =~ m/^CTIME: /) {
5648 # we correctly received the vma config, so we can disable
5649 # the timeout now for disk allocation (set to 10 minutes, so
5650 # that we always timeout if something goes wrong)
5653 print $fifofh "done\n";
5654 my $tmp = $oldtimeout || 0;
5655 $oldtimeout = undef;
5661 print "restore vma archive: $cmd\n";
5662 run_command
($cmd, input
=> $input, outfunc
=> $parser, afterfork
=> $openfifo);
5666 alarm($oldtimeout) if $oldtimeout;
5669 foreach my $devname (keys %$devinfo) {
5670 my $volid = $devinfo->{$devname}->{volid
};
5671 push @$vollist, $volid if $volid;
5674 my $cfg = PVE
::Storage
::config
();
5675 PVE
::Storage
::deactivate_volumes
($cfg, $vollist);
5683 foreach my $devname (keys %$devinfo) {
5684 my $volid = $devinfo->{$devname}->{volid
};
5687 if ($volid =~ m
|^/|) {
5688 unlink $volid || die 'unlink failed\n';
5690 PVE
::Storage
::vdisk_free
($cfg, $volid);
5692 print STDERR
"temporary volume '$volid' sucessfuly removed\n";
5694 print STDERR
"unable to cleanup '$volid' - $@" if $@;
5701 rename($tmpfn, $conffile) ||
5702 die "unable to commit configuration file '$conffile'\n";
5704 PVE
::Cluster
::cfs_update
(); # make sure we read new file
5706 eval { rescan
($vmid, 1); };
5710 sub restore_tar_archive
{
5711 my ($archive, $vmid, $user, $opts) = @_;
5713 if ($archive ne '-') {
5714 my $firstfile = tar_archive_read_firstfile
($archive);
5715 die "ERROR: file '$archive' dos not lock like a QemuServer vzdump backup\n"
5716 if $firstfile ne 'qemu-server.conf';
5719 my $storecfg = PVE
::Storage
::config
();
5721 # destroy existing data - keep empty config
5722 my $vmcfgfn = PVE
::QemuConfig-
>config_file($vmid);
5723 destroy_vm
($storecfg, $vmid, 1) if -f
$vmcfgfn;
5725 my $tocmd = "/usr/lib/qemu-server/qmextract";
5727 $tocmd .= " --storage " . PVE
::Tools
::shellquote
($opts->{storage
}) if $opts->{storage
};
5728 $tocmd .= " --pool " . PVE
::Tools
::shellquote
($opts->{pool
}) if $opts->{pool
};
5729 $tocmd .= ' --prealloc' if $opts->{prealloc
};
5730 $tocmd .= ' --info' if $opts->{info
};
5732 # tar option "xf" does not autodetect compression when read from STDIN,
5733 # so we pipe to zcat
5734 my $cmd = "zcat -f|tar xf " . PVE
::Tools
::shellquote
($archive) . " " .
5735 PVE
::Tools
::shellquote
("--to-command=$tocmd");
5737 my $tmpdir = "/var/tmp/vzdumptmp$$";
5740 local $ENV{VZDUMP_TMPDIR
} = $tmpdir;
5741 local $ENV{VZDUMP_VMID
} = $vmid;
5742 local $ENV{VZDUMP_USER
} = $user;
5744 my $conffile = PVE
::QemuConfig-
>config_file($vmid);
5745 my $tmpfn = "$conffile.$$.tmp";
5747 # disable interrupts (always do cleanups)
5751 local $SIG{HUP
} = sub { print STDERR
"got interrupt - ignored\n"; };
5759 local $SIG{PIPE
} = sub { die "interrupted by signal\n"; };
5761 if ($archive eq '-') {
5762 print "extracting archive from STDIN\n";
5763 run_command
($cmd, input
=> "<&STDIN");
5765 print "extracting archive '$archive'\n";
5769 return if $opts->{info
};
5773 my $statfile = "$tmpdir/qmrestore.stat";
5774 if (my $fd = IO
::File-
>new($statfile, "r")) {
5775 while (defined (my $line = <$fd>)) {
5776 if ($line =~ m/vzdump:([^\s:]*):(\S+)$/) {
5777 $map->{$1} = $2 if $1;
5779 print STDERR
"unable to parse line in statfile - $line\n";
5785 my $confsrc = "$tmpdir/qemu-server.conf";
5787 my $srcfd = new IO
::File
($confsrc, "r") ||
5788 die "unable to open file '$confsrc'\n";
5790 my $outfd = new IO
::File
($tmpfn, "w") ||
5791 die "unable to write config for VM $vmid\n";
5793 my $cookie = { netcount
=> 0 };
5794 while (defined (my $line = <$srcfd>)) {
5795 restore_update_config_line
($outfd, $cookie, $vmid, $map, $line, $opts->{unique
});
5807 tar_restore_cleanup
($storecfg, "$tmpdir/qmrestore.stat") if !$opts->{info
};
5814 rename $tmpfn, $conffile ||
5815 die "unable to commit configuration file '$conffile'\n";
5817 PVE
::Cluster
::cfs_update
(); # make sure we read new file
5819 eval { rescan
($vmid, 1); };
5823 sub foreach_storage_used_by_vm
{
5824 my ($conf, $func) = @_;
5828 foreach_drive
($conf, sub {
5829 my ($ds, $drive) = @_;
5830 return if drive_is_cdrom
($drive);
5832 my $volid = $drive->{file
};
5834 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
5835 $sidhash->{$sid} = $sid if $sid;
5838 foreach my $sid (sort keys %$sidhash) {
5843 sub do_snapshots_with_qemu
{
5844 my ($storecfg, $volid) = @_;
5846 my $storage_name = PVE
::Storage
::parse_volume_id
($volid);
5848 if ($qemu_snap_storage->{$storecfg->{ids
}->{$storage_name}->{type
}}
5849 && !$storecfg->{ids
}->{$storage_name}->{krbd
}){
5853 if ($volid =~ m/\.(qcow2|qed)$/){
5860 sub qga_check_running
{
5863 eval { vm_mon_cmd
($vmid, "guest-ping", timeout
=> 3); };
5865 warn "Qemu Guest Agent are not running - $@";
5871 sub template_create
{
5872 my ($vmid, $conf, $disk) = @_;
5874 my $storecfg = PVE
::Storage
::config
();
5876 foreach_drive
($conf, sub {
5877 my ($ds, $drive) = @_;
5879 return if drive_is_cdrom
($drive);
5880 return if $disk && $ds ne $disk;
5882 my $volid = $drive->{file
};
5883 return if !PVE
::Storage
::volume_has_feature
($storecfg, 'template', $volid);
5885 my $voliddst = PVE
::Storage
::vdisk_create_base
($storecfg, $volid);
5886 $drive->{file
} = $voliddst;
5887 $conf->{$ds} = print_drive
($vmid, $drive);
5888 PVE
::QemuConfig-
>write_config($vmid, $conf);
5892 sub qemu_img_convert
{
5893 my ($src_volid, $dst_volid, $size, $snapname, $is_zero_initialized) = @_;
5895 my $storecfg = PVE
::Storage
::config
();
5896 my ($src_storeid, $src_volname) = PVE
::Storage
::parse_volume_id
($src_volid, 1);
5897 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid, 1);
5899 if ($src_storeid && $dst_storeid) {
5901 PVE
::Storage
::activate_volumes
($storecfg, [$src_volid], $snapname);
5903 my $src_scfg = PVE
::Storage
::storage_config
($storecfg, $src_storeid);
5904 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
5906 my $src_format = qemu_img_format
($src_scfg, $src_volname);
5907 my $dst_format = qemu_img_format
($dst_scfg, $dst_volname);
5909 my $src_path = PVE
::Storage
::path
($storecfg, $src_volid, $snapname);
5910 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
5913 push @$cmd, '/usr/bin/qemu-img', 'convert', '-p', '-n';
5914 push @$cmd, '-s', $snapname if($snapname && $src_format eq "qcow2");
5915 push @$cmd, '-f', $src_format, '-O', $dst_format, $src_path;
5916 if ($is_zero_initialized) {
5917 push @$cmd, "zeroinit:$dst_path";
5919 push @$cmd, $dst_path;
5924 if($line =~ m/\((\S+)\/100\
%\)/){
5926 my $transferred = int($size * $percent / 100);
5927 my $remaining = $size - $transferred;
5929 print "transferred: $transferred bytes remaining: $remaining bytes total: $size bytes progression: $percent %\n";
5934 eval { run_command
($cmd, timeout
=> undef, outfunc
=> $parser); };
5936 die "copy failed: $err" if $err;
5940 sub qemu_img_format
{
5941 my ($scfg, $volname) = @_;
5943 if ($scfg->{path
} && $volname =~ m/\.(raw|cow|qcow|qcow2|qed|vmdk|cloop)$/) {
5950 sub qemu_drive_mirror
{
5951 my ($vmid, $drive, $dst_volid, $vmiddst, $is_zero_initialized, $jobs, $skipcomplete, $qga) = @_;
5953 $jobs = {} if !$jobs;
5957 $jobs->{"drive-$drive"} = {};
5959 if ($dst_volid =~ /^nbd:(localhost|[\d\.]+|\[[\d\.:a-fA-F]+\]):(\d+):exportname=(\S+)/) {
5962 my $exportname = $3;
5965 my $unixsocket = "/run/qemu-server/$vmid.mirror-drive-$drive";
5966 $qemu_target = "nbd+unix:///$exportname?socket=$unixsocket";
5967 my $cmd = ['socat', '-T30', "UNIX-LISTEN:$unixsocket,fork", "TCP:$server:$2,connect-timeout=5"];
5970 if (!defined($pid)) {
5971 die "forking socat tunnel failed\n";
5972 } elsif ($pid == 0) {
5974 warn "exec failed: $!\n";
5977 $jobs->{"drive-$drive"}->{pid
} = $pid;
5980 while (!-S
$unixsocket) {
5981 die "nbd connection helper timed out\n"
5986 my $storecfg = PVE
::Storage
::config
();
5987 my ($dst_storeid, $dst_volname) = PVE
::Storage
::parse_volume_id
($dst_volid);
5989 my $dst_scfg = PVE
::Storage
::storage_config
($storecfg, $dst_storeid);
5991 $format = qemu_img_format
($dst_scfg, $dst_volname);
5993 my $dst_path = PVE
::Storage
::path
($storecfg, $dst_volid);
5995 $qemu_target = $is_zero_initialized ?
"zeroinit:$dst_path" : $dst_path;
5998 my $opts = { timeout
=> 10, device
=> "drive-$drive", mode
=> "existing", sync
=> "full", target
=> $qemu_target };
5999 $opts->{format
} = $format if $format;
6001 print "drive mirror is starting for drive-$drive\n";
6003 eval { vm_mon_cmd
($vmid, "drive-mirror", %$opts); }; #if a job already run for this device,it's throw an error
6006 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
6007 die "mirroring error: $err";
6010 qemu_drive_mirror_monitor
($vmid, $vmiddst, $jobs, $skipcomplete, $qga);
6013 sub qemu_drive_mirror_monitor
{
6014 my ($vmid, $vmiddst, $jobs, $skipcomplete, $qga) = @_;
6017 my $err_complete = 0;
6020 die "storage migration timed out\n" if $err_complete > 300;
6022 my $stats = vm_mon_cmd
($vmid, "query-block-jobs");
6024 my $running_mirror_jobs = {};
6025 foreach my $stat (@$stats) {
6026 next if $stat->{type
} ne 'mirror';
6027 $running_mirror_jobs->{$stat->{device
}} = $stat;
6030 my $readycounter = 0;
6032 foreach my $job (keys %$jobs) {
6034 if(defined($jobs->{$job}->{complete
}) && !defined($running_mirror_jobs->{$job})) {
6035 print "$job : finished\n";
6036 delete $jobs->{$job};
6040 die "$job: mirroring has been cancelled\n" if !defined($running_mirror_jobs->{$job});
6042 my $busy = $running_mirror_jobs->{$job}->{busy
};
6043 my $ready = $running_mirror_jobs->{$job}->{ready
};
6044 if (my $total = $running_mirror_jobs->{$job}->{len
}) {
6045 my $transferred = $running_mirror_jobs->{$job}->{offset
} || 0;
6046 my $remaining = $total - $transferred;
6047 my $percent = sprintf "%.2f", ($transferred * 100 / $total);
6049 print "$job: transferred: $transferred bytes remaining: $remaining bytes total: $total bytes progression: $percent % busy: $busy ready: $ready \n";
6052 $readycounter++ if $running_mirror_jobs->{$job}->{ready
};
6055 last if scalar(keys %$jobs) == 0;
6057 if ($readycounter == scalar(keys %$jobs)) {
6058 print "all mirroring jobs are ready \n";
6059 last if $skipcomplete; #do the complete later
6061 if ($vmiddst && $vmiddst != $vmid) {
6063 print "freeze filesystem\n";
6064 eval { PVE
::QemuServer
::vm_mon_cmd
($vmid, "guest-fsfreeze-freeze"); };
6066 print "suspend vm\n";
6067 eval { PVE
::QemuServer
::vm_suspend
($vmid, 1); };
6070 # if we clone a disk for a new target vm, we don't switch the disk
6071 PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs);
6074 print "unfreeze filesystem\n";
6075 eval { PVE
::QemuServer
::vm_mon_cmd
($vmid, "guest-fsfreeze-thaw"); };
6077 print "resume vm\n";
6078 eval { PVE
::QemuServer
::vm_resume
($vmid, 1, 1); };
6084 foreach my $job (keys %$jobs) {
6085 # try to switch the disk if source and destination are on the same guest
6086 print "$job: Completing block job...\n";
6088 eval { vm_mon_cmd
($vmid, "block-job-complete", device
=> $job) };
6089 if ($@ =~ m/cannot be completed/) {
6090 print "$job: Block job cannot be completed, try again.\n";
6093 print "$job: Completed successfully.\n";
6094 $jobs->{$job}->{complete
} = 1;
6095 eval { qemu_blockjobs_finish_tunnel
($vmid, $job, $jobs->{$job}->{pid
}) } ;
6106 eval { PVE
::QemuServer
::qemu_blockjobs_cancel
($vmid, $jobs) };
6107 die "mirroring error: $err";
6112 sub qemu_blockjobs_cancel
{
6113 my ($vmid, $jobs) = @_;
6115 foreach my $job (keys %$jobs) {
6116 print "$job: Cancelling block job\n";
6117 eval { vm_mon_cmd
($vmid, "block-job-cancel", device
=> $job); };
6118 $jobs->{$job}->{cancel
} = 1;
6122 my $stats = vm_mon_cmd
($vmid, "query-block-jobs");
6124 my $running_jobs = {};
6125 foreach my $stat (@$stats) {
6126 $running_jobs->{$stat->{device
}} = $stat;
6129 foreach my $job (keys %$jobs) {
6131 if (defined($jobs->{$job}->{cancel
}) && !defined($running_jobs->{$job})) {
6132 print "$job: Done.\n";
6133 eval { qemu_blockjobs_finish_tunnel
($vmid, $job, $jobs->{$job}->{pid
}) } ;
6134 delete $jobs->{$job};
6138 last if scalar(keys %$jobs) == 0;
6144 sub qemu_blockjobs_finish_tunnel
{
6145 my ($vmid, $job, $cpid) = @_;
6149 for (my $i = 1; $i < 20; $i++) {
6150 my $waitpid = waitpid($cpid, WNOHANG
);
6151 last if (defined($waitpid) && ($waitpid == $cpid));
6155 } elsif ($i >= 15) {
6160 unlink "/run/qemu-server/$vmid.mirror-$job";
6164 my ($storecfg, $vmid, $running, $drivename, $drive, $snapname,
6165 $newvmid, $storage, $format, $full, $newvollist, $jobs, $skipcomplete, $qga) = @_;
6170 print "create linked clone of drive $drivename ($drive->{file})\n";
6171 $newvolid = PVE
::Storage
::vdisk_clone
($storecfg, $drive->{file
}, $newvmid, $snapname);
6172 push @$newvollist, $newvolid;
6175 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($drive->{file
});
6176 $storeid = $storage if $storage;
6178 my $dst_format = resolve_dst_disk_format
($storecfg, $storeid, $volname, $format);
6179 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $drive->{file
}, 3);
6181 print "create full clone of drive $drivename ($drive->{file})\n";
6182 $newvolid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $newvmid, $dst_format, undef, ($size/1024));
6183 push @$newvollist, $newvolid;
6185 PVE
::Storage
::activate_volumes
($storecfg, [$newvolid]);
6187 my $sparseinit = PVE
::Storage
::volume_has_feature
($storecfg, 'sparseinit', $newvolid);
6188 if (!$running || $snapname) {
6189 qemu_img_convert
($drive->{file
}, $newvolid, $size, $snapname, $sparseinit);
6192 my $kvmver = get_running_qemu_version
($vmid);
6193 if (!qemu_machine_feature_enabled
(undef, $kvmver, 2, 7)) {
6194 die "drive-mirror with iothread requires qemu version 2.7 or higher\n"
6195 if $drive->{iothread
};
6198 qemu_drive_mirror
($vmid, $drivename, $newvolid, $newvmid, $sparseinit, $jobs, $skipcomplete, $qga);
6202 my ($size) = PVE
::Storage
::volume_size_info
($storecfg, $newvolid, 3);
6205 $disk->{format
} = undef;
6206 $disk->{file
} = $newvolid;
6207 $disk->{size
} = $size;
6212 # this only works if VM is running
6213 sub get_current_qemu_machine
{
6216 my $cmd = { execute
=> 'query-machines', arguments
=> {} };
6217 my $res = vm_qmp_command
($vmid, $cmd);
6219 my ($current, $default);
6220 foreach my $e (@$res) {
6221 $default = $e->{name
} if $e->{'is-default'};
6222 $current = $e->{name
} if $e->{'is-current'};
6225 # fallback to the default machine if current is not supported by qemu
6226 return $current || $default || 'pc';
6229 sub get_running_qemu_version
{
6231 my $cmd = { execute
=> 'query-version', arguments
=> {} };
6232 my $res = vm_qmp_command
($vmid, $cmd);
6233 return "$res->{qemu}->{major}.$res->{qemu}->{minor}";
6236 sub qemu_machine_feature_enabled
{
6237 my ($machine, $kvmver, $version_major, $version_minor) = @_;
6242 if ($machine && $machine =~ m/^(pc(-i440fx|-q35)?-(\d+)\.(\d+))/) {
6244 $current_major = $3;
6245 $current_minor = $4;
6247 } elsif ($kvmver =~ m/^(\d+)\.(\d+)/) {
6249 $current_major = $1;
6250 $current_minor = $2;
6253 return 1 if $current_major >= $version_major && $current_minor >= $version_minor;
6258 sub qemu_machine_pxe
{
6259 my ($vmid, $conf, $machine) = @_;
6261 $machine = PVE
::QemuServer
::get_current_qemu_machine
($vmid) if !$machine;
6263 foreach my $opt (keys %$conf) {
6264 next if $opt !~ m/^net(\d+)$/;
6265 my $net = PVE
::QemuServer
::parse_net
($conf->{$opt});
6267 my $romfile = PVE
::QemuServer
::vm_mon_cmd_nocheck
($vmid, 'qom-get', path
=> $opt, property
=> 'romfile');
6268 return $machine.".pxe" if $romfile =~ m/pxe/;
6275 sub qemu_use_old_bios_files
{
6276 my ($machine_type) = @_;
6278 return if !$machine_type;
6280 my $use_old_bios_files = undef;
6282 if ($machine_type =~ m/^(\S+)\.pxe$/) {
6284 $use_old_bios_files = 1;
6286 my $kvmver = kvm_user_version
();
6287 # Note: kvm version < 2.4 use non-efi pxe files, and have problems when we
6288 # load new efi bios files on migration. So this hack is required to allow
6289 # live migration from qemu-2.2 to qemu-2.4, which is sometimes used when
6290 # updrading from proxmox-ve-3.X to proxmox-ve 4.0
6291 $use_old_bios_files = !qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 4);
6294 return ($use_old_bios_files, $machine_type);
6297 sub create_efidisk
{
6298 my ($storecfg, $storeid, $vmid, $fmt) = @_;
6300 die "EFI vars default image not found\n" if ! -f
$OVMF_VARS;
6302 my $vars_size = PVE
::Tools
::convert_size
(-s
$OVMF_VARS, 'b' => 'kb');
6303 my $volid = PVE
::Storage
::vdisk_alloc
($storecfg, $storeid, $vmid, $fmt, undef, $vars_size);
6304 PVE
::Storage
::activate_volumes
($storecfg, [$volid]);
6306 my $path = PVE
::Storage
::path
($storecfg, $volid);
6308 run_command
(['/usr/bin/qemu-img', 'convert', '-n', '-f', 'raw', '-O', $fmt, $OVMF_VARS, $path]);
6310 die "Copying EFI vars image failed: $@" if $@;
6312 return ($volid, $vars_size);
6319 dir_glob_foreach
("$pcisysfs/devices", '[a-f0-9]{4}:([a-f0-9]{2}:[a-f0-9]{2})\.([0-9])', sub {
6320 my (undef, $id, $function) = @_;
6321 my $res = { id
=> $id, function
=> $function};
6322 push @{$devices->{$id}}, $res;
6325 # Entries should be sorted by functions.
6326 foreach my $id (keys %$devices) {
6327 my $dev = $devices->{$id};
6328 $devices->{$id} = [ sort { $a->{function
} <=> $b->{function
} } @$dev ];
6334 sub vm_iothreads_list
{
6337 my $res = vm_mon_cmd
($vmid, 'query-iothreads');
6340 foreach my $iothread (@$res) {
6341 $iothreads->{ $iothread->{id
} } = $iothread->{"thread-id"};
6348 my ($conf, $drive) = @_;
6352 if (!$conf->{scsihw
} || ($conf->{scsihw
} =~ m/^lsi/)) {
6354 } elsif ($conf->{scsihw
} && ($conf->{scsihw
} eq 'virtio-scsi-single')) {
6360 my $controller = int($drive->{index} / $maxdev);
6361 my $controller_prefix = ($conf->{scsihw
} && $conf->{scsihw
} eq 'virtio-scsi-single') ?
"virtioscsi" : "scsihw";
6363 return ($maxdev, $controller, $controller_prefix);
6366 sub add_hyperv_enlightenments
{
6367 my ($cpuFlags, $winversion, $machine_type, $kvmver, $bios, $gpu_passthrough) = @_;
6369 return if $winversion < 6;
6370 return if $bios && $bios eq 'ovmf' && $winversion < 8;
6372 push @$cpuFlags , 'hv_vendor_id=proxmox' if $gpu_passthrough;
6374 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 3)) {
6375 push @$cpuFlags , 'hv_spinlocks=0x1fff';
6376 push @$cpuFlags , 'hv_vapic';
6377 push @$cpuFlags , 'hv_time';
6379 push @$cpuFlags , 'hv_spinlocks=0xffff';
6382 if (qemu_machine_feature_enabled
($machine_type, $kvmver, 2, 6)) {
6383 push @$cpuFlags , 'hv_reset';
6384 push @$cpuFlags , 'hv_vpindex';
6385 push @$cpuFlags , 'hv_runtime';
6388 if ($winversion >= 7) {
6389 push @$cpuFlags , 'hv_relaxed';
6393 sub windows_version
{
6396 return 0 if !$ostype;
6400 if($ostype eq 'wxp' || $ostype eq 'w2k3' || $ostype eq 'w2k') {
6402 } elsif($ostype eq 'w2k8' || $ostype eq 'wvista') {
6404 } elsif ($ostype =~ m/^win(\d+)$/) {
6411 sub resolve_dst_disk_format
{
6412 my ($storecfg, $storeid, $src_volname, $format) = @_;
6413 my ($defFormat, $validFormats) = PVE
::Storage
::storage_default_format
($storecfg, $storeid);
6416 # if no target format is specified, use the source disk format as hint
6418 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
6419 $format = qemu_img_format
($scfg, $src_volname);
6425 # test if requested format is supported - else use default
6426 my $supported = grep { $_ eq $format } @$validFormats;
6427 $format = $defFormat if !$supported;
6431 sub resolve_first_disk
{
6433 my @disks = PVE
::QemuServer
::valid_drive_names
();
6435 foreach my $ds (reverse @disks) {
6436 next if !$conf->{$ds};
6437 my $disk = PVE
::QemuServer
::parse_drive
($ds, $conf->{$ds});
6438 next if PVE
::QemuServer
::drive_is_cdrom
($disk);
6444 sub generate_smbios1_uuid
{
6445 my ($uuid, $uuid_str);
6446 UUID
::generate
($uuid);
6447 UUID
::unparse
($uuid, $uuid_str);
6448 return "uuid=$uuid_str";
6451 # bash completion helper
6453 sub complete_backup_archives
{
6454 my ($cmdname, $pname, $cvalue) = @_;
6456 my $cfg = PVE
::Storage
::config
();
6460 if ($cvalue =~ m/^([^:]+):/) {
6464 my $data = PVE
::Storage
::template_list
($cfg, $storeid, 'backup');
6467 foreach my $id (keys %$data) {
6468 foreach my $item (@{$data->{$id}}) {
6469 next if $item->{format
} !~ m/^vma\.(gz|lzo)$/;
6470 push @$res, $item->{volid
} if defined($item->{volid
});
6477 my $complete_vmid_full = sub {
6480 my $idlist = vmstatus
();
6484 foreach my $id (keys %$idlist) {
6485 my $d = $idlist->{$id};
6486 if (defined($running)) {
6487 next if $d->{template
};
6488 next if $running && $d->{status
} ne 'running';
6489 next if !$running && $d->{status
} eq 'running';
6498 return &$complete_vmid_full();
6501 sub complete_vmid_stopped
{
6502 return &$complete_vmid_full(0);
6505 sub complete_vmid_running
{
6506 return &$complete_vmid_full(1);
6509 sub complete_storage
{
6511 my $cfg = PVE
::Storage
::config
();
6512 my $ids = $cfg->{ids
};
6515 foreach my $sid (keys %$ids) {
6516 next if !PVE
::Storage
::storage_check_enabled
($cfg, $sid, undef, 1);
6517 next if !$ids->{$sid}->{content
}->{images
};
6527 vm_mon_cmd
($vmid, 'nbd-server-stop');