use File::Path;
use File::stat;
use Getopt::Long;
-use Digest::SHA1;
+use Digest::SHA;
use Fcntl ':flock';
use Cwd 'abs_path';
use IPC::Open3;
+use JSON;
use Fcntl;
use PVE::SafeSyslog;
use Storable qw(dclone);
use PVE::Cluster qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
use PVE::INotify;
use PVE::ProcFSTools;
+use PVE::QMPClient;
use Time::HiRes qw(gettimeofday);
my $cpuinfo = PVE::ProcFSTools::read_cpuinfo();
# allowed when such lock is set. But you can ignore this kind of
# lock with the --skiplock flag.
-cfs_register_file('/qemu-server/', \&parse_vm_config);
+cfs_register_file('/qemu-server/',
+ \&parse_vm_config,
+ \&write_vm_config);
PVE::JSONSchema::register_standard_option('skiplock', {
description => "Ignore locks - only root is allowed to use this option.",
- type => 'boolean',
+ type => 'boolean',
optional => 1,
});
},
name => {
optional => 1,
- type => 'string',
+ type => 'string', format => 'dns-name',
description => "Set a name for the VM. Only used on the configuration web interface.",
},
+ scsihw => {
+ optional => 1,
+ type => 'string',
+ description => "scsi controller model",
+ enum => [qw(lsi virtio-scsi-pci megasas)],
+ default => 'lsi',
+ },
description => {
optional => 1,
type => 'string',
- description => "Description for the VM. Only used on the configuration web interface.",
+ description => "Description for the VM. Only used on the configuration web interface. This is saved as comment inside the configuration file.",
},
ostype => {
optional => 1,
optional => 1,
type => 'string', format => 'pve-qm-bootdisk',
description => "Enable booting from specified disk.",
- pattern => '(ide|scsi|virtio)\d+',
+ pattern => '(ide|sata|scsi|virtio)\d+',
},
smp => {
optional => 1,
description => "Enable/disable ACPI.",
default => 1,
},
+ agent => {
+ optional => 1,
+ type => 'boolean',
+ description => "Enable/disable Qemu GuestAgent.",
+ default => 0,
+ },
kvm => {
optional => 1,
type => 'boolean',
tdf => {
optional => 1,
type => 'boolean',
- description => "Enable/disable time drift fix.",
+ description => "Enable/disable time drift fix. This is ignored for kvm versions newer that 1.0 (not needed anymore).",
default => 1,
},
localtime => {
pattern => '(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)',
default => 'now',
},
+ startup => {
+ optional => 1,
+ type => 'string', format => 'pve-qm-startup',
+ typetext => '[[order=]\d+] [,up=\d+] [,down=\d+] ',
+ description => "Startup and shutdown behavior. Order is a non-negative number defining the general startup order. Shutdown in done with reverse ordering. Additionally you can set the 'up' or 'down' delay in seconds, which specifies a delay to wait before the next VM is started or stopped.",
+ },
args => {
optional => 1,
type => 'string',
optional => 1,
description => "Emulated CPU type.",
type => 'string',
- enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom host) ],
+ enum => [ qw(486 athlon pentium pentium2 pentium3 coreduo core2duo kvm32 kvm64 qemu32 qemu64 phenom cpu64-rhel6 cpu64-rhel5 Conroe Penryn Nehalem Westmere Opteron_G1 Opteron_G2 Opteron_G3 host) ],
default => 'qemu64',
},
};
my $MAX_IDE_DISKS = 4;
my $MAX_SCSI_DISKS = 14;
-my $MAX_VIRTIO_DISKS = 6;
+my $MAX_VIRTIO_DISKS = 16;
+my $MAX_SATA_DISKS = 6;
my $MAX_USB_DEVICES = 5;
-my $MAX_NETS = 6;
+my $MAX_NETS = 32;
my $MAX_UNUSED_DISKS = 8;
my $MAX_HOSTPCI_DEVICES = 2;
my $MAX_SERIAL_PORTS = 4;
my $netdesc = {
optional => 1,
type => 'string', format => 'pve-qm-net',
- typetext => "MODEL=XX:XX:XX:XX:XX:XX [,bridge=<dev>][,rate=<mbps>]",
+ typetext => "MODEL=XX:XX:XX:XX:XX:XX [,bridge=<dev>][,rate=<mbps>][,tag=<vlanid>]",
description => <<EODESCR,
Specify network devices.
my $idedesc = {
optional => 1,
type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe] [,format=f] [,backup=yes|no] [,aio=native|threads]',
- description => "Use volume as IDE hard disk or CD-ROM (n is 0 to 3).",
+ typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads]',
+ description => "Use volume as IDE hard disk or CD-ROM (n is 0 to " .($MAX_IDE_DISKS -1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-ide", $idedesc);
my $scsidesc = {
optional => 1,
type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe] [,format=f] [,backup=yes|no] [,aio=native|threads]',
- description => "Use volume as SCSI hard disk or CD-ROM (n is 0 to 13).",
+ typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads]',
+ description => "Use volume as SCSI hard disk or CD-ROM (n is 0 to " . ($MAX_SCSI_DISKS - 1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-scsi", $scsidesc);
+my $satadesc = {
+ optional => 1,
+ type => 'string', format => 'pve-qm-drive',
+ typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads]',
+ description => "Use volume as SATA hard disk or CD-ROM (n is 0 to " . ($MAX_SATA_DISKS - 1). ").",
+};
+PVE::JSONSchema::register_standard_option("pve-qm-sata", $satadesc);
+
my $virtiodesc = {
optional => 1,
type => 'string', format => 'pve-qm-drive',
- typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe] [,format=f] [,backup=yes|no] [,aio=native|threads]',
- description => "Use volume as VIRTIO hard disk (n is 0 to 5).",
+ typetext => '[volume=]volume,] [,media=cdrom|disk] [,cyls=c,heads=h,secs=s[,trans=t]] [,snapshot=on|off] [,cache=none|writethrough|writeback|unsafe|directsync] [,format=f] [,backup=yes|no] [,rerror=ignore|report|stop] [,werror=enospc|ignore|report|stop] [,aio=native|threads]',
+ description => "Use volume as VIRTIO hard disk (n is 0 to " . ($MAX_VIRTIO_DISKS - 1) . ").",
};
PVE::JSONSchema::register_standard_option("pve-qm-virtio", $virtiodesc);
$confdesc->{"ide$i"} = $idedesc;
}
+for (my $i = 0; $i < $MAX_SATA_DISKS; $i++) {
+ $drivename_hash->{"sata$i"} = 1;
+ $confdesc->{"sata$i"} = $satadesc;
+}
+
for (my $i = 0; $i < $MAX_SCSI_DISKS; $i++) {
$drivename_hash->{"scsi$i"} = 1;
$confdesc->{"scsi$i"} = $scsidesc ;
# order is important - used to autoselect boot disk
return ((map { "ide$_" } (0 .. ($MAX_IDE_DISKS - 1))),
(map { "scsi$_" } (0 .. ($MAX_SCSI_DISKS - 1))),
- (map { "virtio$_" } (0 .. ($MAX_VIRTIO_DISKS - 1))));
+ (map { "virtio$_" } (0 .. ($MAX_VIRTIO_DISKS - 1))),
+ (map { "sata$_" } (0 .. ($MAX_SATA_DISKS - 1))));
}
sub valid_drivename {
};
}
-sub disk_devive_info {
- my $dev = shift;
-
- die "unknown disk device format '$dev'" if $dev !~ m/^(ide|scsi|virtio)(\d+)$/;
-
- my $bus = $1;
- my $index = $2;
- my $maxdev = 1024;
-
- if ($bus eq 'ide') {
- $maxdev = 2;
- } elsif ($bus eq 'scsi') {
- $maxdev = 7;
- }
-
- my $controller = int($index / $maxdev);
- my $unit = $index % $maxdev;
-
-
- return { bus => $bus, desc => uc($bus) . " $controller:$unit",
- controller => $controller, unit => $unit, index => $index };
-
-}
-
-sub qemu_drive_name {
- my ($dev, $media) = @_;
-
- my $info = disk_devive_info($dev);
- my $mediastr = '';
-
- if (($info->{bus} eq 'ide') || ($info->{bus} eq 'scsi')) {
- $mediastr = ($media eq 'cdrom') ? "-cd" : "-hd";
- return sprintf("%s%i%s%i", $info->{bus}, $info->{controller},
- $mediastr, $info->{unit});
- } else {
- return sprintf("%s%i", $info->{bus}, $info->{index});
- }
-}
-
my $cdrom_path;
sub get_cdrom_path {
my $etype;
if ($media eq 'disk') {
- $etype = 'image';
+ $etype = 'images';
} elsif ($media eq 'cdrom') {
$etype = 'iso';
} else {
PVE::Tools::file_set_contents($filename, $data);
}
+my $parse_size = sub {
+ my ($value) = @_;
+
+ return undef if $value !~ m/^(\d+(\.\d+)?)([KMG])?$/;
+ my ($size, $unit) = ($1, $3);
+ if ($unit) {
+ if ($unit eq 'K') {
+ $size = $size * 1024;
+ } elsif ($unit eq 'M') {
+ $size = $size * 1024 * 1024;
+ } elsif ($unit eq 'G') {
+ $size = $size * 1024 * 1024 * 1024;
+ }
+ }
+ return int($size);
+};
+
+my $format_size = sub {
+ my ($size) = @_;
+
+ $size = int($size);
+
+ my $kb = int($size/1024);
+ return $size if $kb*1024 != $size;
+
+ my $mb = int($kb/1024);
+ return "${kb}K" if $mb*1024 != $kb;
+
+ my $gb = int($mb/1024);
+ return "${mb}M" if $gb*1024 != $mb;
+
+ return "${gb}G";
+};
+
# ideX = [volume=]volume-id[,media=d][,cyls=c,heads=h,secs=s[,trans=t]]
# [,snapshot=on|off][,cache=on|off][,format=f][,backup=yes|no]
+# [,rerror=ignore|report|stop][,werror=enospc|ignore|report|stop]
# [,aio=native|threads]
sub parse_drive {
foreach my $p (split (/,/, $data)) {
next if $p =~ m/^\s*$/;
- if ($p =~ m/^(file|volume|cyls|heads|secs|trans|media|snapshot|cache|format|rerror|werror|backup|aio)=(.+)$/) {
+ if ($p =~ m/^(file|volume|cyls|heads|secs|trans|media|snapshot|cache|format|rerror|werror|backup|aio|bps|mbps|bps_rd|mbps_rd|bps_wr|mbps_wr|iops|iops_rd|iops_wr|size)=(.+)$/) {
my ($k, $v) = ($1, $2);
$k = 'file' if $k eq 'volume';
return undef if defined $res->{$k};
+ if ($k eq 'bps' || $k eq 'bps_rd' || $k eq 'bps_wr') {
+ return undef if !$v || $v !~ m/^\d+/;
+ $k = "m$k";
+ $v = sprintf("%.3f", $v / (1024*1024));
+ }
$res->{$k} = $v;
} else {
if (!$res->{file} && $p !~ m/=/) {
return undef if !$res->{file};
return undef if $res->{cache} &&
- $res->{cache} !~ m/^(off|none|writethrough|writeback|unsafe)$/;
+ $res->{cache} !~ m/^(off|none|writethrough|writeback|unsafe|directsync)$/;
return undef if $res->{snapshot} && $res->{snapshot} !~ m/^(on|off)$/;
return undef if $res->{cyls} && $res->{cyls} !~ m/^\d+$/;
return undef if $res->{heads} && $res->{heads} !~ m/^\d+$/;
return undef if $res->{backup} && $res->{backup} !~ m/^(yes|no)$/;
return undef if $res->{aio} && $res->{aio} !~ m/^(native|threads)$/;
+
+ return undef if $res->{mbps_rd} && $res->{mbps};
+ return undef if $res->{mbps_wr} && $res->{mbps};
+
+ return undef if $res->{mbps} && $res->{mbps} !~ m/^\d+(\.\d+)?$/;
+ return undef if $res->{mbps_rd} && $res->{mbps_rd} !~ m/^\d+(\.\d+)?$/;
+ return undef if $res->{mbps_wr} && $res->{mbps_wr} !~ m/^\d+(\.\d+)?$/;
+
+ return undef if $res->{iops_rd} && $res->{iops};
+ return undef if $res->{iops_wr} && $res->{iops};
+ return undef if $res->{iops} && $res->{iops} !~ m/^\d+$/;
+ return undef if $res->{iops_rd} && $res->{iops_rd} !~ m/^\d+$/;
+ return undef if $res->{iops_wr} && $res->{iops_wr} !~ m/^\d+$/;
+
+
+ if ($res->{size}) {
+ return undef if !defined($res->{size} = &$parse_size($res->{size}));
+ }
+
if ($res->{media} && ($res->{media} eq 'cdrom')) {
return undef if $res->{snapshot} || $res->{trans} || $res->{format};
return undef if $res->{heads} || $res->{secs} || $res->{cyls};
return $res;
}
-my @qemu_drive_options = qw(heads secs cyls trans media format cache snapshot rerror werror aio);
+my @qemu_drive_options = qw(heads secs cyls trans media format cache snapshot rerror werror aio iops iops_rd iops_wr);
sub print_drive {
my ($vmid, $drive) = @_;
my $opts = '';
- foreach my $o (@qemu_drive_options, 'backup') {
+ foreach my $o (@qemu_drive_options, 'mbps', 'mbps_rd', 'mbps_wr', 'backup') {
$opts .= ",$o=$drive->{$o}" if $drive->{$o};
}
+ if ($drive->{size}) {
+ $opts .= ",size=" . &$format_size($drive->{size});
+ }
+
return "$drive->{file}$opts";
}
+sub scsi_inquiry {
+ my($fh, $noerr) = @_;
+
+ my $SG_IO = 0x2285;
+ my $SG_GET_VERSION_NUM = 0x2282;
+
+ my $versionbuf = "\x00" x 8;
+ my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
+ if (!$ret) {
+ die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
+ return undef;
+ }
+ my $version = unpack("I", $versionbuf);
+ if ($version < 30000) {
+ die "scsi generic interface too old\n" if !$noerr;
+ return undef;
+ }
+
+ my $buf = "\x00" x 36;
+ my $sensebuf = "\x00" x 8;
+ my $cmd = pack("C x3 C x11", 0x12, 36);
+
+ # see /usr/include/scsi/sg.h
+ 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";
+
+ my $packet = pack($sg_io_hdr_t, ord('S'), -3, length($cmd),
+ length($sensebuf), 0, length($buf), $buf,
+ $cmd, $sensebuf, 6000);
+
+ $ret = ioctl($fh, $SG_IO, $packet);
+ if (!$ret) {
+ die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
+ return undef;
+ }
+
+ my @res = unpack($sg_io_hdr_t, $packet);
+ if ($res[17] || $res[18]) {
+ die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
+ return undef;
+ }
+
+ my $res = {};
+ ($res->{device}, $res->{removable}, $res->{venodor},
+ $res->{product}, $res->{revision}) = unpack("C C x6 A8 A16 A4", $buf);
+
+ return $res;
+}
+
+sub path_is_scsi {
+ my ($path) = @_;
+
+ my $fh = IO::File->new("+<$path") || return undef;
+ my $res = scsi_inquiry($fh, 1);
+ close($fh);
+
+ return $res;
+}
+
sub print_drivedevice_full {
- my ($storecfg, $vmid, $drive) = @_;
+ my ($storecfg, $conf, $vmid, $drive, $bridges) = @_;
my $device = '';
my $maxdev = 0;
if ($drive->{interface} eq 'virtio') {
- my $pciaddr = print_pci_addr("$drive->{interface}$drive->{index}");
+ my $pciaddr = print_pci_addr("$drive->{interface}$drive->{index}", $bridges);
$device = "virtio-blk-pci,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}$pciaddr";
} elsif ($drive->{interface} eq 'scsi') {
- $maxdev = 7;
+ $maxdev = ($conf->{scsihw} && $conf->{scsihw} ne 'lsi') ? 256 : 7;
my $controller = int($drive->{index} / $maxdev);
my $unit = $drive->{index} % $maxdev;
my $devicetype = 'hd';
} else {
$path = PVE::Storage::path($storecfg, $drive->{file});
}
- if ($path =~ m|^/dev/| ) {
- $devicetype = 'block';
- }
+
+ if($path =~ m/^iscsi\:\/\//){
+ $devicetype = 'generic';
+ }
+ else {
+ $devicetype = 'block' if path_is_scsi($path);
+ }
}
- $device = "scsi-$devicetype,bus=lsi$controller.0,scsi-id=$unit,drive=drive-$drive->{interface}$drive->{index},id=device-$drive->{interface}$drive->{index}";
+ if (!$conf->{scsihw} || $conf->{scsihw} eq 'lsi'){
+ $device = "scsi-$devicetype,bus=scsihw$controller.0,scsi-id=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}" if !$conf->{scsihw} || $conf->{scsihw} eq 'lsi';
+ } else {
+ $device = "scsi-$devicetype,bus=scsihw$controller.0,channel=0,scsi-id=0,lun=$drive->{index},drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
+ }
+
} elsif ($drive->{interface} eq 'ide'){
$maxdev = 2;
my $controller = int($drive->{index} / $maxdev);
my $unit = $drive->{index} % $maxdev;
my $devicetype = ($drive->{media} && $drive->{media} eq 'cdrom') ? "cd" : "hd";
- $device = "ide-$devicetype,bus=ide.$controller,unit=$unit,drive=drive-$drive->{interface}$drive->{index},id=device-$drive->{interface}$drive->{index}";
+ $device = "ide-$devicetype,bus=ide.$controller,unit=$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
+ } elsif ($drive->{interface} eq 'sata'){
+ my $controller = int($drive->{index} / $MAX_SATA_DISKS);
+ my $unit = $drive->{index} % $MAX_SATA_DISKS;
+ $device = "ide-drive,bus=ahci$controller.$unit,drive=drive-$drive->{interface}$drive->{index},id=$drive->{interface}$drive->{index}";
} elsif ($drive->{interface} eq 'usb') {
die "implement me";
# -device ide-drive,bus=ide.1,unit=0,drive=drive-ide0-1-0,id=ide0-1-0
$opts .= ",$o=$drive->{$o}" if $drive->{$o};
}
+ foreach my $o (qw(bps bps_rd bps_wr)) {
+ my $v = $drive->{"m$o"};
+ $opts .= ",$o=" . int($v*1024*1024) if $v;
+ }
+
# use linux-aio by default (qemu default is threads)
$opts .= ",aio=native" if !$drive->{aio};
return "${pathinfo}if=none,id=drive-$drive->{interface}$drive->{index}$opts";
}
+sub print_netdevice_full {
+ my ($vmid, $conf, $net, $netid, $bridges) = @_;
+
+ my $bootorder = $conf->{boot} || $confdesc->{boot}->{default};
+
+ my $device = $net->{model};
+ if ($net->{model} eq 'virtio') {
+ $device = 'virtio-net-pci';
+ };
+
+ # qemu > 0.15 always try to boot from network - we disable that by
+ # not loading the pxe rom file
+ my $extra = ($bootorder !~ m/n/) ? "romfile=," : '';
+ my $pciaddr = print_pci_addr("$netid", $bridges);
+ my $tmpstr = "$device,${extra}mac=$net->{macaddr},netdev=$netid$pciaddr,id=$netid";
+ $tmpstr .= ",bootindex=$net->{bootindex}" if $net->{bootindex} ;
+ return $tmpstr;
+}
+
+sub print_netdev_full {
+ my ($vmid, $conf, $net, $netid) = @_;
+
+ my $i = '';
+ if ($netid =~ m/^net(\d+)$/) {
+ $i = int($1);
+ }
+
+ die "got strange net id '$i'\n" if $i >= ${MAX_NETS};
+
+ my $ifname = "tap${vmid}i$i";
+
+ # kvm uses TUNSETIFF ioctl, and that limits ifname length
+ die "interface name '$ifname' is too long (max 15 character)\n"
+ if length($ifname) >= 16;
+
+ my $vhostparam = '';
+ $vhostparam = ',vhost=on' if $kernel_has_vhost_net && $net->{model} eq 'virtio';
+
+ my $vmname = $conf->{name} || "vm$vmid";
+
+ if ($net->{bridge}) {
+ return "type=tap,id=$netid,ifname=${ifname},script=/var/lib/qemu-server/pve-bridge$vhostparam";
+ } else {
+ return "type=user,id=$netid,hostname=$vmname";
+ }
+}
sub drive_is_cdrom {
my ($drive) = @_;
$res->{bridge} = $1;
} elsif ($kvp =~ m/^rate=(\d+(\.\d+)?)$/) {
$res->{rate} = $1;
+ } elsif ($kvp =~ m/^tag=(\d+)$/) {
+ $res->{tag} = $1;
} else {
return undef;
}
$res .= "=$net->{macaddr}" if $net->{macaddr};
$res .= ",bridge=$net->{bridge}" if $net->{bridge};
$res .= ",rate=$net->{rate}" if $net->{rate};
+ $res .= ",tag=$net->{tag}" if $net->{tag};
return $res;
}
}
sub add_unused_volume {
- my ($config, $res, $volid) = @_;
+ my ($config, $volid) = @_;
my $key;
for (my $ind = $MAX_UNUSED_DISKS - 1; $ind >= 0; $ind--) {
die "To many unused volume - please delete them first.\n" if !$key;
- $res->{$key} = $volid;
+ $config->{$key} = $volid;
+
+ return $key;
}
# fixme: remove all thos $noerr parameters?
return $res;
}
+PVE::JSONSchema::register_format('pve-qm-startup', \&verify_startup);
+sub verify_startup {
+ my ($value, $noerr) = @_;
+
+ return $value if parse_startup($value);
+
+ return undef if $noerr;
+
+ die "unable to parse startup options\n";
+}
+
+sub parse_startup {
+ my ($value) = @_;
+
+ return undef if !$value;
+
+ my $res = {};
+
+ foreach my $p (split(/,/, $value)) {
+ next if $p =~ m/^\s*$/;
+
+ if ($p =~ m/^(order=)?(\d+)$/) {
+ $res->{order} = $2;
+ } elsif ($p =~ m/^up=(\d+)$/) {
+ $res->{up} = $1;
+ } elsif ($p =~ m/^down=(\d+)$/) {
+ $res->{down} = $1;
+ } else {
+ return undef;
+ }
+ }
+
+ return $res;
+}
+
sub parse_usb_device {
my ($value) = @_;
my $res = {};
foreach my $v (@dl) {
- if ($v =~ m/^host=([0-9A-Fa-f]{4}):([0-9A-Fa-f]{4})$/) {
+ if ($v =~ m/^host=(0x)?([0-9A-Fa-f]{4}):(0x)?([0-9A-Fa-f]{4})$/) {
$found = 1;
- $res->{vendorid} = $1;
- $res->{productid} = $2;
+ $res->{vendorid} = $2;
+ $res->{productid} = $4;
} elsif ($v =~ m/^host=(\d+)\-(\d+(\.\d+)*)$/) {
$found = 1;
$res->{hostbus} = $1;
}
}
-sub lock_config {
- my ($vmid, $code, @param) = @_;
+sub lock_config_full {
+ my ($vmid, $timeout, $code, @param) = @_;
my $filename = config_file_lock($vmid);
- my $res = lock_file($filename, 10, $code, @param);
+ my $res = lock_file($filename, $timeout, $code, @param);
die $@ if $@;
return $res;
}
+sub lock_config {
+ my ($vmid, $code, @param) = @_;
+
+ return lock_config_full($vmid, 10, $code, @param);
+}
+
sub cfs_config_path {
my ($vmid, $node) = @_;
utime undef, undef, $conf;
}
-sub create_disks {
- my ($storecfg, $vmid, $settings, $conf, $default_storage) = @_;
-
- my $vollist = [];
-
- eval {
- foreach_drive($settings, sub {
- my ($ds, $disk) = @_;
-
- return if drive_is_cdrom($disk);
-
- my $file = $disk->{file};
-
- if ($file =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/) {
- my $storeid = $2 || $default_storage;
- my $size = $3;
- my $defformat = PVE::Storage::storage_default_format($storecfg, $storeid);
- my $fmt = $disk->{format} || $defformat;
- syslog('info', "VM $vmid creating new disk - size is $size GB");
-
- my $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
- $fmt, undef, $size*1024*1024);
-
- $disk->{file} = $volid;
- delete $disk->{format}; # no longer needed
- push @$vollist, $volid;
- $settings->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
- } else {
- my $path;
- if ($disk->{file} =~ m|^/dev/.+|) {
- $path = $disk->{file};
- } else {
- $path = PVE::Storage::path($storecfg, $disk->{file});
- }
- if (!(-f $path || -b $path)) {
- die "image '$path' does not exists\n";
- }
- }
- PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $ds, $disk) if defined($conf);
- });
- };
-
- my $err = $@;
-
- if ($err) {
- syslog('err', "VM $vmid creating disks failed");
- foreach my $volid (@$vollist) {
- eval { PVE::Storage::vdisk_free($storecfg, $volid); };
- warn $@ if $@;
- }
- die $err;
- }
-
- return $vollist;
-}
-
sub destroy_vm {
my ($storecfg, $vmid, $keep_empty_config) = @_;
warn $@ if $@;
}
-# fixme: remove?
-sub load_diskinfo_old {
- my ($storecfg, $vmid, $conf) = @_;
-
- my $info = {};
- my $res = {};
- my $vollist;
-
- foreach_drive($conf, sub {
- my ($ds, $di) = @_;
-
- $res->{$ds} = $di;
-
- return if drive_is_cdrom($di);
-
- if ($di->{file} =~ m|^/dev/.+|) {
- $info->{$di->{file}}->{size} = PVE::Storage::file_size_info($di->{file});
- } else {
- push @$vollist, $di->{file};
- }
- });
-
- eval {
- my $dl = PVE::Storage::vdisk_list($storecfg, undef, $vmid, $vollist);
-
- PVE::Storage::foreach_volid($dl, sub {
- my ($volid, $sid, $volname, $d) = @_;
- $info->{$volid} = $d;
- });
- };
- warn $@ if $@;
-
- foreach my $ds (keys %$res) {
- my $di = $res->{$ds};
-
- $res->{$ds}->{disksize} = $info->{$di->{file}} ?
- $info->{$di->{file}}->{size} / (1024*1024) : 0;
- }
-
- return $res;
-}
-
sub load_config {
- my ($vmid) = @_;
+ my ($vmid, $node) = @_;
- my $cfspath = cfs_config_path($vmid);
+ my $cfspath = cfs_config_path($vmid, $node);
my $conf = PVE::Cluster::cfs_read_file($cfspath);
return undef if !defined($raw);
my $res = {
- digest => Digest::SHA1::sha1_hex($raw),
+ digest => Digest::SHA::sha1_hex($raw),
};
$filename =~ m|/qemu-server/(\d+)\.conf$|
my $vmid = $1;
+ my $descr = '';
+
while ($raw && $raw =~ s/^(.*?)(\n|$)//) {
my $line = $1;
- next if $line =~ m/^\#/;
-
next if $line =~ m/^\s*$/;
+ if ($line =~ m/^\#(.*)\s*$/) {
+ $descr .= PVE::Tools::decode_text($1) . "\n";
+ next;
+ }
+
if ($line =~ m/^(description):\s*(.*\S)\s*$/) {
- my $key = $1;
- my $value = PVE::Tools::decode_text($2);
- $res->{$key} = $value;
+ $descr .= PVE::Tools::decode_text($2);
} elsif ($line =~ m/^(args):\s*(.*\S)\s*$/) {
my $key = $1;
my $value = $2;
}
}
+ $res->{description} = $descr if $descr;
+
# convert old smp to sockets
if ($res->{smp} && !$res->{sockets}) {
$res->{sockets} = $res->{smp};
return $res;
}
-sub change_config {
- my ($vmid, $settings, $unset, $skiplock) = @_;
+sub write_vm_config {
+ my ($filename, $conf) = @_;
- lock_config($vmid, &change_config_nolock, $settings, $unset, $skiplock);
-}
-
-sub change_config_nolock {
- my ($vmid, $settings, $unset, $skiplock) = @_;
-
- my $res = {};
-
- $unset->{ide2} = $unset->{cdrom} if $unset->{cdrom};
-
- check_lock($settings) if !$skiplock;
+ if ($conf->{cdrom}) {
+ die "option ide2 conflicts with cdrom\n" if $conf->{ide2};
+ $conf->{ide2} = $conf->{cdrom};
+ delete $conf->{cdrom};
+ }
# we do not use 'smp' any longer
- if ($settings->{sockets}) {
- $unset->{smp} = 1;
- } elsif ($settings->{smp}) {
- $settings->{sockets} = $settings->{smp};
- $unset->{smp} = 1;
+ if ($conf->{sockets}) {
+ delete $conf->{smp};
+ } elsif ($conf->{smp}) {
+ $conf->{sockets} = $conf->{smp};
+ delete $conf->{cores};
+ delete $conf->{smp};
}
my $new_volids = {};
-
- foreach my $key (keys %$settings) {
- next if $key eq 'digest';
- my $value = $settings->{$key};
- if ($key eq 'description') {
- $value = PVE::Tools::encode_text($value);
- }
+ foreach my $key (keys %$conf) {
+ next if $key eq 'digest' || $key eq 'description';
+ my $value = $conf->{$key};
eval { $value = check_type($key, $value); };
die "unable to parse value of '$key' - $@" if $@;
- if ($key eq 'cdrom') {
- $res->{ide2} = $value;
- } else {
- $res->{$key} = $value;
- }
+
+ $conf->{$key} = $value;
+
if (valid_drivename($key)) {
my $drive = PVE::QemuServer::parse_drive($key, $value);
$new_volids->{$drive->{file}} = 1 if $drive && $drive->{file};
}
}
- my $filename = config_file($vmid);
- my $tmpfn = "$filename.$$.tmp";
-
- my $fh = new IO::File($filename, "r") ||
- die "unable to read config for VM $vmid\n";
-
- my $werror = "unable to write config for VM $vmid\n";
-
- my $out = new IO::File($tmpfn, "w") || die $werror;
-
- eval {
-
- my $done;
-
- while (my $line = <$fh>) {
-
- if (($line =~ m/^\#/) || ($line =~ m/^\s*$/)) {
- die $werror unless print $out $line;
- next;
- }
-
- if ($line =~ m/^([a-z][a-z_]*\d*):\s*(.*\S)\s*$/) {
- my $key = $1;
- my $value = $2;
-
- # remove 'unusedX' settings if we re-add a volume
- next if $key =~ m/^unused/ && $new_volids->{$value};
-
- # convert 'smp' to 'sockets'
- $key = 'sockets' if $key eq 'smp';
-
- next if $done->{$key};
- $done->{$key} = 1;
+ # remove 'unusedX' settings if we re-add a volume
+ foreach my $key (keys %$conf) {
+ my $value = $conf->{$key};
+ if ($key =~ m/^unused/ && $new_volids->{$value}) {
+ delete $conf->{$key};
+ }
+ }
- if (defined($res->{$key})) {
- $value = $res->{$key};
- delete $res->{$key};
- }
- if (!defined($unset->{$key})) {
- die $werror unless print $out "$key: $value\n";
- }
+ # gererate RAW data
+ my $raw = '';
- next;
- }
+ # add description as comment to top of file
+ my $descr = $conf->{description} || '';
+ foreach my $cl (split(/\n/, $descr)) {
+ $raw .= '#' . PVE::Tools::encode_text($cl) . "\n";
+ }
- die "unable to parse config file: $line\n";
- }
+ foreach my $key (sort keys %$conf) {
+ next if $key eq 'digest' || $key eq 'description';
+ $raw .= "$key: $conf->{$key}\n";
+ }
- foreach my $key (keys %$res) {
+ return $raw;
+}
- if (!defined($unset->{$key})) {
- die $werror unless print $out "$key: $res->{$key}\n";
- }
- }
- };
+sub update_config_nolock {
+ my ($vmid, $conf, $skiplock) = @_;
- my $err = $@;
+ check_lock($conf) if !$skiplock;
- $fh->close();
+ my $cfspath = cfs_config_path($vmid);
- if ($err) {
- $out->close();
- unlink $tmpfn;
- die $err;
- }
+ PVE::Cluster::cfs_write_file($cfspath, $conf);
+}
- if (!$out->close()) {
- $err = "close failed - $!\n";
- unlink $tmpfn;
- die $err;
- }
+sub update_config {
+ my ($vmid, $conf, $skiplock) = @_;
- if (!rename($tmpfn, $filename)) {
- $err = "rename failed - $!\n";
- unlink $tmpfn;
- die $err;
- }
+ lock_config($vmid, &update_config_nolock, $conf, $skiplock);
}
sub load_defaults {
return $loc_res;
}
-sub check_lock {
+# check is used storages are available on all nodes (use by migrate)
+sub check_storage_availability {
+ my ($storecfg, $conf, $node) = @_;
+
+ foreach_drive($conf, sub {
+ my ($ds, $drive) = @_;
+
+ my $volid = $drive->{file};
+ return if !$volid;
+
+ my ($sid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
+ return if !$sid;
+
+ # check if storage is available on both nodes
+ my $scfg = PVE::Storage::storage_check_node($storecfg, $sid);
+ PVE::Storage::storage_check_node($storecfg, $sid, $node);
+ });
+}
+
+sub check_lock {
my ($conf) = @_;
die "VM is locked ($conf->{lock})\n" if $conf->{lock};
}
sub check_running {
- my ($vmid, $nocheck) = @_;
+ my ($vmid, $nocheck, $node) = @_;
- my $filename = config_file($vmid);
+ my $filename = config_file($vmid, $node);
die "unable to find configuration file for VM $vmid - no such machine\n"
if !$nocheck && ! -f $filename;
return $vzlist;
}
-my $storage_timeout_hash = {};
-
sub disksize {
my ($storecfg, $conf) = @_;
my $volid = $drive->{file};
return undef if !$volid;
- my $path;
- my $storeid;
- my $timeoutid;
-
- if ($volid =~ m|^/|) {
- $path = $timeoutid = $volid;
- } else {
- eval {
- $storeid = $timeoutid = PVE::Storage::parse_volume_id($volid);
- $path = PVE::Storage::path($storecfg, $volid);
- };
- if (my $err = $@) {
- warn $err;
- return undef;
- }
- }
-
- my $last_timeout = $storage_timeout_hash->{$timeoutid};
- if ($last_timeout) {
- if ((time() - $last_timeout) < 30) {
- # skip storage with errors
- return undef ;
- }
- delete $storage_timeout_hash->{$timeoutid};
- }
-
- my ($size, $format, $used);
-
- ($size, $format, $used) = PVE::Storage::file_size_info($path, 1);
-
- if (!defined($format)) {
- # got timeout
- $storage_timeout_hash->{$timeoutid} = time();
- return undef;
- }
-
- return wantarray ? ($size, $used) : $size;
+ return $drive->{size};
}
my $last_proc_pid_stat;
+# get VM status information
+# This must be fast and should not block ($full == false)
+# We only query KVM using QMP if $full == true (this can be slow)
sub vmstatus {
- my ($opt_vmid) = @_;
+ my ($opt_vmid, $full) = @_;
my $res = {};
# fixme: better status?
$d->{status} = $list->{$vmid}->{pid} ? 'running' : 'stopped';
- my ($size, $used) = disksize($storecfg, $conf);
- if (defined($size) && defined($used)) {
- $d->{disk} = $used;
+ my $size = disksize($storecfg, $conf);
+ if (defined($size)) {
+ $d->{disk} = 0; # no info available
$d->{maxdisk} = $size;
} else {
$d->{disk} = 0;
my $pid = $d->{pid};
next if !$pid;
- if (my $fh = IO::File->new("/proc/$pid/io", "r")) {
- my $data = {};
- while (defined(my $line = <$fh>)) {
- if ($line =~ m/^([rw]char):\s+(\d+)$/) {
- $data->{$1} = $2;
- }
- }
- close($fh);
- $d->{diskread} = $data->{rchar} || 0;
- $d->{diskwrite} = $data->{wchar} || 0;
- }
-
my $pstat = PVE::ProcFSTools::read_proc_pid_stat($pid);
next if !$pstat; # not running
}
}
+ return $res if !$full;
+
+ my $qmpclient = PVE::QMPClient->new();
+
+ my $blockstatscb = sub {
+ my ($vmid, $resp) = @_;
+ my $data = $resp->{'return'} || [];
+ my $totalrdbytes = 0;
+ my $totalwrbytes = 0;
+ for my $blockstat (@$data) {
+ $totalrdbytes = $totalrdbytes + $blockstat->{stats}->{rd_bytes};
+ $totalwrbytes = $totalwrbytes + $blockstat->{stats}->{wr_bytes};
+ }
+ $res->{$vmid}->{diskread} = $totalrdbytes;
+ $res->{$vmid}->{diskwrite} = $totalwrbytes;
+ };
+
+ my $statuscb = sub {
+ my ($vmid, $resp) = @_;
+ $qmpclient->queue_cmd($vmid, $blockstatscb, 'query-blockstats');
+
+ my $status = 'unknown';
+ if (!defined($status = $resp->{'return'}->{status})) {
+ warn "unable to get VM status\n";
+ return;
+ }
+
+ $res->{$vmid}->{qmpstatus} = $resp->{'return'}->{status};
+ };
+
+ foreach my $vmid (keys %$list) {
+ next if $opt_vmid && ($vmid ne $opt_vmid);
+ next if !$res->{$vmid}->{pid}; # not running
+ $qmpclient->queue_cmd($vmid, $statuscb, 'query-status');
+ }
+
+ $qmpclient->queue_execute();
+
+ foreach my $vmid (keys %$list) {
+ next if $opt_vmid && ($vmid ne $opt_vmid);
+ $res->{$vmid}->{qmpstatus} = $res->{$vmid}->{status} if !$res->{$vmid}->{qmpstatus};
+ }
+
return $res;
}
my ($storecfg, $vmid, $conf, $defaults, $migrate_uri) = @_;
my $cmd = [];
+ my $devices = [];
my $pciaddr = '';
+ my $bridges = {};
my $kvmver = kvm_user_version();
my $vernum = 0; # unknown
if ($kvmver =~ m/^(\d+)\.(\d+)$/) {
my $use_virtio = 0;
- my $socket = monitor_socket($vmid);
- push @$cmd, '-chardev', "socket,id=monitor,path=$socket,server,nowait";
- push @$cmd, '-mon', "chardev=monitor,mode=readline";
+ my $qmpsocket = qmp_socket($vmid);
+ push @$cmd, '-chardev', "socket,id=qmp,path=$qmpsocket,server,nowait";
+ push @$cmd, '-mon', "chardev=qmp,mode=control";
- $socket = vnc_socket($vmid);
+ my $socket = vnc_socket($vmid);
push @$cmd, '-vnc', "unix:$socket,x509,password";
push @$cmd, '-pidfile' , pidfile_name($vmid);
push @$cmd, '-incoming', $migrate_uri if $migrate_uri;
+ push @$cmd, '-S' if $migrate_uri;
+
my $use_usb2 = 0;
for (my $i = 0; $i < $MAX_USB_DEVICES; $i++) {
next if !$conf->{"usb$i"};
$use_usb2 = 1;
}
# include usb device config
- push @$cmd, '-readconfig', '/usr/share/qemu-server/pve-usb.cfg' if $use_usb2;
+ push @$devices, '-readconfig', '/usr/share/qemu-server/pve-usb.cfg' if $use_usb2;
# enable absolute mouse coordinates (needed by vnc)
my $tablet = defined($conf->{tablet}) ? $conf->{tablet} : $defaults->{tablet};
if ($tablet) {
if ($use_usb2) {
- push @$cmd, '-device', 'usb-tablet,bus=ehci.0,port=6';
+ push @$devices, '-device', 'usb-tablet,bus=ehci.0,port=6';
} else {
- push @$cmd, '-usbdevice', 'tablet';
+ push @$devices, '-usbdevice', 'tablet';
}
}
for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
my $d = parse_hostpci($conf->{"hostpci$i"});
next if !$d;
- $pciaddr = print_pci_addr("hostpci$i");
- push @$cmd, '-device', "pci-assign,host=$d->{pciid},id=hostpci$i$pciaddr";
+ $pciaddr = print_pci_addr("hostpci$i", $bridges);
+ push @$devices, '-device', "pci-assign,host=$d->{pciid},id=hostpci$i$pciaddr";
}
# usb devices
my $d = parse_usb_device($conf->{"usb$i"});
next if !$d;
if ($d->{vendorid} && $d->{productid}) {
- push @$cmd, '-device', "usb-host,vendorid=$d->{vendorid},productid=$d->{productid}";
+ push @$devices, '-device', "usb-host,vendorid=0x$d->{vendorid},productid=0x$d->{productid}";
} elsif (defined($d->{hostbus}) && defined($d->{hostport})) {
- push @$cmd, '-device', "usb-host,hostbus=$d->{hostbus},hostport=$d->{hostport}";
+ push @$devices, '-device', "usb-host,hostbus=$d->{hostbus},hostport=$d->{hostport}";
}
}
for (my $i = 0; $i < $MAX_SERIAL_PORTS; $i++) {
if (my $path = $conf->{"serial$i"}) {
die "no such serial device\n" if ! -c $path;
- push @$cmd, '-chardev', "tty,id=serial$i,path=$path";
- push @$cmd, '-device', "isa-serial,chardev=serial$i";
+ push @$devices, '-chardev', "tty,id=serial$i,path=$path";
+ push @$devices, '-device', "isa-serial,chardev=serial$i";
}
}
for (my $i = 0; $i < $MAX_PARALLEL_PORTS; $i++) {
if (my $path = $conf->{"parallel$i"}) {
die "no such parallel device\n" if ! -c $path;
- push @$cmd, '-chardev', "parport,id=parallel$i,path=$path";
- push @$cmd, '-device', "isa-parallel,chardev=parallel$i";
+ push @$devices, '-chardev', "parport,id=parallel$i,path=$path";
+ push @$devices, '-device', "isa-parallel,chardev=parallel$i";
}
}
foreach my $o (split(//, $bootorder)) {
$bootindex_hash->{$o} = $i*100;
$i++;
- }
+ }
push @$cmd, '-boot', "menu=on";
# time drift fix
my $tdf = defined($conf->{tdf}) ? $conf->{tdf} : $defaults->{tdf};
- push @$cmd, '-tdf' if $tdf;
+ # ignore - no longer supported by newer kvm
+ # push @$cmd, '-tdf' if $tdf;
my $nokvm = defined($conf->{kvm}) && $conf->{kvm} == 0 ? 1 : 0;
}
}
+ if ($ost eq 'win7' || $ost eq 'w2k8' || $ost eq 'wvista') {
+ push @$cmd, '-no-kvm-pit-reinjection';
+ push @$cmd, '-no-hpet';
+ }
+
# -tdf ?
# -no-acpi
# -no-kvm
#my $soundhw = $conf->{soundhw} || $defaults->{soundhw};
#push @$cmd, '-soundhw', 'es1370';
#push @$cmd, '-soundhw', $soundhw if $soundhw;
- $pciaddr = print_pci_addr("balloon0");
- push @$cmd, '-device', "virtio-balloon-pci,id=balloon0$pciaddr" if $conf->{balloon};
+
+ if($conf->{agent}) {
+ my $qgasocket = qga_socket($vmid);
+ my $pciaddr = print_pci_addr("qga0", $bridges);
+ push @$devices, '-chardev', "socket,path=$qgasocket,server,nowait,id=qga0";
+ push @$devices, '-device', "virtio-serial,id=qga0$pciaddr";
+ push @$devices, '-device', 'virtserialport,chardev=qga0,name=org.qemu.guest_agent.0';
+ }
+
+ $pciaddr = print_pci_addr("balloon0", $bridges);
+ push @$devices, '-device', "virtio-balloon-pci,id=balloon0$pciaddr" if $conf->{balloon};
if ($conf->{watchdog}) {
my $wdopts = parse_watchdog($conf->{watchdog});
- $pciaddr = print_pci_addr("watchdog");
+ $pciaddr = print_pci_addr("watchdog", $bridges);
my $watchdog = $wdopts->{model} || 'i6300esb';
- push @$cmd, '-device', "$watchdog$pciaddr";
- push @$cmd, '-watchdog-action', $wdopts->{action} if $wdopts->{action};
+ push @$devices, '-device', "$watchdog$pciaddr";
+ push @$devices, '-watchdog-action', $wdopts->{action} if $wdopts->{action};
}
my $vollist = [];
my $scsicontroller = {};
+ my $ahcicontroller = {};
+ my $scsihw = defined($conf->{scsihw}) ? $conf->{scsihw} : $defaults->{scsihw};
foreach_drive($conf, sub {
my ($ds, $drive) = @_;
if (PVE::Storage::parse_volume_id($drive->{file}, 1)) {
push @$vollist, $drive->{file};
}
-
+
$use_virtio = 1 if $ds =~ m/^virtio/;
if (drive_is_cdrom ($drive)) {
}
if ($drive->{interface} eq 'scsi') {
- my $maxdev = 7;
- my $controller = int($drive->{index} / $maxdev);
- $pciaddr = print_pci_addr("lsi$controller");
- push @$cmd, '-device', "lsi,id=lsi$controller$pciaddr" if !$scsicontroller->{$controller};
- $scsicontroller->{$controller}=1;
+
+ my $maxdev = ($scsihw ne 'lsi') ? 256 : 7;
+ my $controller = int($drive->{index} / $maxdev);
+ $pciaddr = print_pci_addr("scsihw$controller", $bridges);
+ push @$devices, '-device', "$scsihw,id=scsihw$controller$pciaddr" if !$scsicontroller->{$controller};
+ $scsicontroller->{$controller}=1;
+ }
+
+ if ($drive->{interface} eq 'sata') {
+ my $controller = int($drive->{index} / $MAX_SATA_DISKS);
+ $pciaddr = print_pci_addr("ahci$controller", $bridges);
+ push @$devices, '-device', "ahci,id=ahci$controller,multifunction=on$pciaddr" if !$ahcicontroller->{$controller};
+ $ahcicontroller->{$controller}=1;
}
- push @$cmd, '-drive', print_drive_full($storecfg, $vmid, $drive);
- push @$cmd, '-device',print_drivedevice_full($storecfg,$vmid, $drive);
+ push @$devices, '-drive',print_drive_full($storecfg, $vmid, $drive);
+ push @$devices, '-device',print_drivedevice_full($storecfg, $conf, $vmid, $drive, $bridges);
});
push @$cmd, '-m', $conf->{memory} || $defaults->{memory};
- my $foundnet = 0;
+ for (my $i = 0; $i < $MAX_NETS; $i++) {
+ next if !$conf->{"net$i"};
+ my $d = parse_net($conf->{"net$i"});
+ next if !$d;
- foreach my $k (sort keys %$conf) {
- next if $k !~ m/^net(\d+)$/;
- my $i = int($1);
+ $use_virtio = 1 if $d->{model} eq 'virtio';
- die "got strange net id '$i'\n" if $i >= ${MAX_NETS};
-
- if ($conf->{"net$i"} && (my $net = parse_net($conf->{"net$i"}))) {
-
- $foundnet = 1;
-
- my $ifname = "tap${vmid}i$i";
-
- # kvm uses TUNSETIFF ioctl, and that limits ifname length
- die "interface name '$ifname' is too long (max 15 character)\n"
- if length($ifname) >= 16;
+ if ($bootindex_hash->{n}) {
+ $d->{bootindex} = $bootindex_hash->{n};
+ $bootindex_hash->{n} += 1;
+ }
- my $device = $net->{model};
- my $vhostparam = '';
- if ($net->{model} eq 'virtio') {
- $use_virtio = 1;
- $device = 'virtio-net-pci';
- $vhostparam = ',vhost=on' if $kernel_has_vhost_net;
- };
+ my $netdevfull = print_netdev_full($vmid,$conf,$d,"net$i");
+ push @$devices, '-netdev', $netdevfull;
- if ($net->{bridge}) {
- push @$cmd, '-netdev', "type=tap,id=${k},ifname=${ifname},script=/var/lib/qemu-server/pve-bridge$vhostparam";
- } else {
- push @$cmd, '-netdev', "type=user,id=${k},hostname=$vmname";
- }
+ my $netdevicefull = print_netdevice_full($vmid,$conf,$d,"net$i",$bridges);
+ push @$devices, '-device', $netdevicefull;
+ }
- # qemu > 0.15 always try to boot from network - we disable that by
- # not loading the pxe rom file
- my $extra = ($bootorder !~ m/n/) ? "romfile=," : '';
- $pciaddr = print_pci_addr("${k}");
- my $tmpstr = "$device,${extra}mac=$net->{macaddr},netdev=${k}$pciaddr";
- if (my $bootindex = $bootindex_hash->{n}) {
- $tmpstr .= ",bootindex=$bootindex";
- $bootindex_hash->{n} += 1;
- }
- push @$cmd, '-device', $tmpstr;
- }
+ #bridges
+ while (my ($k, $v) = each %$bridges) {
+ $pciaddr = print_pci_addr("pci.$k");
+ unshift @$devices, '-device', "pci-bridge,id=pci.$k,chassis_nr=$k$pciaddr" if $k > 0;
}
- push @$cmd, '-net', 'none' if !$foundnet;
# hack: virtio with fairsched is unreliable, so we do not use fairsched
# when the VM uses virtio devices.
push @$cmd, @$aa;
}
+ push @$cmd, @$devices;
return wantarray ? ($cmd, $vollist) : $cmd;
}
return "${var_run_tmpdir}/$vmid.vnc";
}
-sub monitor_socket {
+sub qmp_socket {
+ my ($vmid) = @_;
+ return "${var_run_tmpdir}/$vmid.qmp";
+}
+
+sub qga_socket {
my ($vmid) = @_;
- return "${var_run_tmpdir}/$vmid.mon";
+ return "${var_run_tmpdir}/$vmid.qga";
}
sub pidfile_name {
sub vm_devices_list {
my ($vmid) = @_;
- my $res = vm_monitor_command ($vmid, "info pci");
+ my $res = vm_mon_cmd($vmid, 'query-pci');
- my @lines = split ("\n", $res);
- my $devices;
- my $bus;
- my $addr;
- my $id;
-
- foreach my $line (@lines) {
- $line =~ s/^\s+//;
- if ($line =~ m/^Bus (\d+), device (\d+), function (\d+):$/) {
- $bus=$1;
- $addr=$2;
- }
- if ($line =~ m/^id "([a-z][a-z_\-]*\d*)"$/) {
- $id=$1;
- $devices->{$id}->{bus}=$bus;
- $devices->{$id}->{addr}=$addr;
+ my $devices = {};
+ foreach my $pcibus (@$res) {
+ foreach my $device (@{$pcibus->{devices}}) {
+ next if !$device->{'qdev_id'};
+ $devices->{$device->{'qdev_id'}} = $device;
}
}
sub vm_deviceplug {
my ($storecfg, $conf, $vmid, $deviceid, $device) = @_;
- return if !check_running($vmid) || !$conf->{hotplug} || $conf->{$deviceid};
-
- if($deviceid =~ m/^(virtio)(\d+)$/) {
- my $drive = print_drive_full($storecfg, $vmid, $device);
- my $ret = vm_monitor_command($vmid, "drive_add auto $drive");
- # If the command succeeds qemu prints: "OK"
- if ($ret !~ m/OK/s) {
- die "adding drive failed: $ret";
+ return 1 if !check_running($vmid) || !$conf->{hotplug};
+
+ my $devices_list = vm_devices_list($vmid);
+ return 1 if defined($devices_list->{$deviceid});
+
+ qemu_bridgeadd($storecfg, $conf, $vmid, $deviceid); #add bridge if we need it for the device
+
+ if ($deviceid =~ m/^(virtio)(\d+)$/) {
+ return undef if !qemu_driveadd($storecfg, $vmid, $device);
+ my $devicefull = print_drivedevice_full($storecfg, $conf, $vmid, $device);
+ qemu_deviceadd($vmid, $devicefull);
+ if(!qemu_deviceaddverify($vmid, $deviceid)) {
+ qemu_drivedel($vmid, $deviceid);
+ return undef;
}
-
- my $devicefull = print_drivedevice_full($storecfg, $vmid, $device);
- $ret = vm_monitor_command($vmid, "device_add $devicefull");
- $ret =~ s/^\s+//;
- # Otherwise, if the command succeeds, no output is sent. So any non-empty string shows an error
- die 'error on hotplug device : $ret' if $ret ne "";
}
- for (my $i = 0; $i <= 5; $i++) {
- my $devices_list = vm_devices_list($vmid);
- return if defined($devices_list->{$deviceid});
- sleep 1;
+ if ($deviceid =~ m/^(scsihw)(\d+)$/) {
+ my $scsihw = defined($conf->{scsihw}) ? $conf->{scsihw} : "lsi";
+ my $pciaddr = print_pci_addr($deviceid);
+ my $devicefull = "$scsihw,id=$deviceid$pciaddr";
+ qemu_deviceadd($vmid, $devicefull);
+ return undef if(!qemu_deviceaddverify($vmid, $deviceid));
+ }
+
+ if ($deviceid =~ m/^(scsi)(\d+)$/) {
+ return 1 if ($conf->{scsihw} && $conf->{scsihw} ne 'lsi'); #virtio-scsi not yet support hotplug
+ return undef if !qemu_findorcreatescsihw($storecfg,$conf, $vmid, $device);
+ return undef if !qemu_driveadd($storecfg, $vmid, $device);
+ my $devicefull = print_drivedevice_full($storecfg, $conf, $vmid, $device);
+ if(!qemu_deviceadd($vmid, $devicefull)) {
+ qemu_drivedel($vmid, $deviceid);
+ return undef;
+ }
}
-
- die "error on hotplug device $deviceid";
+
+ if ($deviceid =~ m/^(net)(\d+)$/) {
+ return undef if !qemu_netdevadd($vmid, $conf, $device, $deviceid);
+ my $netdevicefull = print_netdevice_full($vmid, $conf, $device, $deviceid);
+ qemu_deviceadd($vmid, $netdevicefull);
+ if(!qemu_deviceaddverify($vmid, $deviceid)) {
+ qemu_netdevdel($vmid, $deviceid);
+ return undef;
+ }
+ }
+
+ if ($deviceid =~ m/^(pci\.)(\d+)$/) {
+ my $bridgeid = $2;
+ my $pciaddr = print_pci_addr($deviceid);
+ my $devicefull = "pci-bridge,id=pci.$bridgeid,chassis_nr=$bridgeid$pciaddr";
+ qemu_deviceadd($vmid, $devicefull);
+ return undef if !qemu_deviceaddverify($vmid, $deviceid);
+ }
+
+ return 1;
}
sub vm_deviceunplug {
my ($vmid, $conf, $deviceid) = @_;
- return if !check_running ($vmid) || !$conf->{hotplug};
+ return 1 if !check_running ($vmid) || !$conf->{hotplug};
- die "can't unplug bootdisk" if $conf->{bootdisk} eq $deviceid;
+ my $devices_list = vm_devices_list($vmid);
+ return 1 if !defined($devices_list->{$deviceid});
- if($deviceid =~ m/^(virtio)(\d+)$/){
+ die "can't unplug bootdisk" if $conf->{bootdisk} && $conf->{bootdisk} eq $deviceid;
- my $ret = vm_monitor_command($vmid, "drive_del drive-$deviceid");
- $ret =~ s/^\s+//;
- if ($ret =~ m/Device \'.*?\' not found/s) {
- # NB: device not found errors mean the drive was auto-deleted and we ignore the error
- }
- elsif ($ret ne "") {
- die "deleting drive $deviceid failed : $ret";
- }
+ if ($deviceid =~ m/^(virtio)(\d+)$/) {
+ return undef if !qemu_drivedel($vmid, $deviceid);
+ qemu_devicedel($vmid, $deviceid);
+ return undef if !qemu_devicedelverify($vmid, $deviceid);
+ }
+
+ if ($deviceid =~ m/^(lsi)(\d+)$/) {
+ return undef if !qemu_devicedel($vmid, $deviceid);
+ }
+
+ if ($deviceid =~ m/^(scsi)(\d+)$/) {
+ return undef if !qemu_devicedel($vmid, $deviceid);
+ return undef if !qemu_drivedel($vmid, $deviceid);
+ }
+
+ if ($deviceid =~ m/^(net)(\d+)$/) {
+ return undef if !qemu_netdevdel($vmid, $deviceid);
+ qemu_devicedel($vmid, $deviceid);
+ return undef if !qemu_devicedelverify($vmid, $deviceid);
+ }
+
+ return 1;
+}
+
+sub qemu_deviceadd {
+ my ($vmid, $devicefull) = @_;
+
+ my $ret = vm_human_monitor_command($vmid, "device_add $devicefull");
+ $ret =~ s/^\s+//;
+ # Otherwise, if the command succeeds, no output is sent. So any non-empty string shows an error
+ return 1 if $ret eq "";
+ syslog("err", "error on hotplug device : $ret");
+ return undef;
+
+}
+
+sub qemu_devicedel {
+ my($vmid, $deviceid) = @_;
+
+ my $ret = vm_human_monitor_command($vmid, "device_del $deviceid");
+ $ret =~ s/^\s+//;
+ return 1 if $ret eq "";
+ syslog("err", "detaching device $deviceid failed : $ret");
+ return undef;
+}
+
+sub qemu_driveadd {
+ my($storecfg, $vmid, $device) = @_;
+
+ my $drive = print_drive_full($storecfg, $vmid, $device);
+ my $ret = vm_human_monitor_command($vmid, "drive_add auto $drive");
+ # If the command succeeds qemu prints: "OK"
+ if ($ret !~ m/OK/s) {
+ syslog("err", "adding drive failed: $ret");
+ return undef;
+ }
+ return 1;
+}
- $ret = vm_monitor_command($vmid, "device_del $deviceid");
- $ret =~ s/^\s+//;
- die 'detaching device $deviceid failed : $ret' if $ret ne "";
+sub qemu_drivedel {
+ my($vmid, $deviceid) = @_;
+ my $ret = vm_human_monitor_command($vmid, "drive_del drive-$deviceid");
+ $ret =~ s/^\s+//;
+ if ($ret =~ m/Device \'.*?\' not found/s) {
+ # NB: device not found errors mean the drive was auto-deleted and we ignore the error
}
+ elsif ($ret ne "") {
+ syslog("err", "deleting drive $deviceid failed : $ret");
+ return undef;
+ }
+ return 1;
+}
+
+sub qemu_deviceaddverify {
+ my ($vmid,$deviceid) = @_;
+
+ for (my $i = 0; $i <= 5; $i++) {
+ my $devices_list = vm_devices_list($vmid);
+ return 1 if defined($devices_list->{$deviceid});
+ sleep 1;
+ }
+ syslog("err", "error on hotplug device $deviceid");
+ return undef;
+}
+
+
+sub qemu_devicedelverify {
+ my ($vmid,$deviceid) = @_;
#need to verify the device is correctly remove as device_del is async and empty return is not reliable
for (my $i = 0; $i <= 5; $i++) {
- my $devices_list = vm_devices_list($vmid);
- return if !defined($devices_list->{$deviceid});
- sleep 1;
+ my $devices_list = vm_devices_list($vmid);
+ return 1 if !defined($devices_list->{$deviceid});
+ sleep 1;
}
- die "error on hot-plugging device $deviceid";
+ syslog("err", "error on hot-unplugging device $deviceid");
+ return undef;
+}
+sub qemu_findorcreatescsihw {
+ my ($storecfg, $conf, $vmid, $device) = @_;
+ my $maxdev = ($conf->{scsihw} && $conf->{scsihw} ne 'lsi') ? 256 : 7;
+ my $controller = int($device->{index} / $maxdev);
+ my $scsihwid="scsihw$controller";
+ my $devices_list = vm_devices_list($vmid);
+
+ if(!defined($devices_list->{$scsihwid})) {
+ return undef if !vm_deviceplug($storecfg, $conf, $vmid, $scsihwid);
+ }
+ return 1;
}
-sub vm_start {
- my ($storecfg, $vmid, $statefile, $skiplock) = @_;
+sub qemu_bridgeadd {
+ my ($storecfg, $conf, $vmid, $device) = @_;
- lock_config($vmid, sub {
- my $conf = load_config($vmid);
+ my $bridges = {};
+ my $bridgeid = undef;
+ print_pci_addr($device, $bridges);
- check_lock($conf) if !$skiplock;
+ while (my ($k, $v) = each %$bridges) {
+ $bridgeid = $k;
+ }
+ return if $bridgeid < 1;
+ my $bridge = "pci.$bridgeid";
+ my $devices_list = vm_devices_list($vmid);
- die "VM $vmid already running\n" if check_running($vmid);
+ if(!defined($devices_list->{$bridge})) {
+ return undef if !vm_deviceplug($storecfg, $conf, $vmid, $bridge);
+ }
+ return 1;
+}
- my $migrate_uri;
- my $migrate_port = 0;
+sub qemu_netdevadd {
+ my ($vmid, $conf, $device, $deviceid) = @_;
- if ($statefile) {
- if ($statefile eq 'tcp') {
- $migrate_port = next_migrate_port();
- $migrate_uri = "tcp:localhost:${migrate_port}";
- } else {
- if (-f $statefile) {
- $migrate_uri = "exec:cat $statefile";
- } else {
- warn "state file '$statefile' does not exist - doing normal startup\n";
- }
- }
- }
+ my $netdev = print_netdev_full($vmid, $conf, $device, $deviceid);
+ my $ret = vm_human_monitor_command($vmid, "netdev_add $netdev");
+ $ret =~ s/^\s+//;
- my $defaults = load_defaults();
+ #if the command succeeds, no output is sent. So any non-empty string shows an error
+ return 1 if $ret eq "";
+ syslog("err", "adding netdev failed: $ret");
+ return undef;
+}
- my ($cmd, $vollist) = config_to_command($storecfg, $vmid, $conf, $defaults, $migrate_uri);
- # host pci devices
- for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
- my $d = parse_hostpci($conf->{"hostpci$i"});
- next if !$d;
- my $info = pci_device_info("0000:$d->{pciid}");
- die "IOMMU not present\n" if !check_iommu_support();
- die "no pci device info for device '$d->{pciid}'\n" if !$info;
- die "can't unbind pci device '$d->{pciid}'\n" if !pci_dev_bind_to_stub($info);
- die "can't reset pci device '$d->{pciid}'\n" if !pci_dev_reset($info);
- }
+sub qemu_netdevdel {
+ my ($vmid, $deviceid) = @_;
- PVE::Storage::activate_volumes($storecfg, $vollist);
+ my $ret = vm_human_monitor_command($vmid, "netdev_del $deviceid");
+ $ret =~ s/^\s+//;
+ #if the command succeeds, no output is sent. So any non-empty string shows an error
+ return 1 if $ret eq "";
+ syslog("err", "deleting netdev failed: $ret");
+ return undef;
+}
- eval { run_command($cmd, timeout => $migrate_uri ? undef : 30); };
- my $err = $@;
- die "start failed: $err" if $err;
+sub qemu_block_set_io_throttle {
+ my ($vmid, $deviceid, $bps, $bps_rd, $bps_wr, $iops, $iops_rd, $iops_wr) = @_;
- if ($statefile) {
+ return if !check_running($vmid) ;
- if ($statefile eq 'tcp') {
- print "migration listens on port $migrate_port\n";
- } else {
- unlink $statefile;
- # fixme: send resume - is that necessary ?
- eval { vm_monitor_command($vmid, "cont"); };
- }
- }
-
- # always set migrate speed (overwrite kvm default of 32m)
- # we set a very hight default of 8192m which is basically unlimited
- my $migrate_speed = $defaults->{migrate_speed} || 8192;
- $migrate_speed = $conf->{migrate_speed} || $migrate_speed;
- eval {
- my $cmd = "migrate_set_speed ${migrate_speed}m";
- vm_monitor_command($vmid, $cmd);
- };
+ $bps = 0 if !$bps;
+ $bps_rd = 0 if !$bps_rd;
+ $bps_wr = 0 if !$bps_wr;
+ $iops = 0 if !$iops;
+ $iops_rd = 0 if !$iops_rd;
+ $iops_wr = 0 if !$iops_wr;
- if (my $migrate_downtime =
- $conf->{migrate_downtime} || $defaults->{migrate_downtime}) {
- my $cmd = "migrate_set_downtime ${migrate_downtime}";
- eval { vm_monitor_command($vmid, $cmd); };
- }
+ vm_mon_cmd($vmid, "block_set_io_throttle", device => $deviceid, bps => int($bps), bps_rd => int($bps_rd), bps_wr => int($bps_wr), iops => int($iops), iops_rd => int($iops_rd), iops_wr => int($iops_wr));
- vm_balloonset($vmid, $conf->{balloon}) if $conf->{balloon};
- });
}
+# old code, only used to shutdown old VM after update
sub __read_avail {
my ($fh, $timeout) = @_;
return $res;
}
+# old code, only used to shutdown old VM after update
sub vm_monitor_command {
my ($vmid, $cmdstr, $nocheck) = @_;
eval {
die "VM $vmid not running\n" if !check_running($vmid, $nocheck);
- my $sname = monitor_socket($vmid);
+ my $sname = "${var_run_tmpdir}/$vmid.mon";
my $sock = IO::Socket::UNIX->new( Peer => $sname ) ||
die "unable to connect to VM $vmid socket - $!\n";
my $fullcmd = "$cmdstr\r";
+ # syslog('info', "VM $vmid monitor command: $cmdstr");
+
my $b;
if (!($b = $sock->syswrite($fullcmd)) || ($b != length($fullcmd))) {
die "monitor write error - $!";
return $res;
}
+sub qemu_block_resize {
+ my ($vmid, $deviceid, $storecfg, $volid, $size) = @_;
+
+ my $running = PVE::QemuServer::check_running($vmid);
+
+ return if !PVE::Storage::volume_resize($storecfg, $volid, $size, $running);
+
+ return if !$running;
+
+ vm_mon_cmd($vmid, "block_resize", device => $deviceid, size => int($size));
+
+}
+
+sub qemu_volume_snapshot {
+ my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
+
+ my $running = PVE::QemuServer::check_running($vmid);
+
+ return if !PVE::Storage::volume_snapshot($storecfg, $volid, $snap, $running);
+
+ return if !$running;
+
+ vm_mon_cmd($vmid, "snapshot-drive", device => $deviceid, name => $snap);
+
+}
+
+sub qemu_volume_snapshot_delete {
+ my ($vmid, $deviceid, $storecfg, $volid, $snap) = @_;
+
+ #need to implement statefile location
+ my $statefile="/tmp/$vmid-$snap";
+
+ unlink $statefile if -e $statefile;
+
+ my $running = PVE::QemuServer::check_running($vmid);
+
+ return if !PVE::Storage::volume_snapshot_delete($storecfg, $volid, $snap, $running);
+
+ return if !$running;
+
+ #need to split delvm monitor command like savevm
+
+}
+
+sub qemu_snapshot_start {
+ my ($vmid, $snap) = @_;
+
+ #need to implement statefile location
+ my $statefile="/tmp/$vmid-$snap";
+
+ vm_mon_cmd($vmid, "snapshot-start", statefile => $statefile);
+
+}
+
+sub qemu_snapshot_end {
+ my ($vmid) = @_;
+
+ vm_mon_cmd($vmid, "snapshot-end");
+
+}
+
+sub qga_freezefs {
+ my ($vmid) = @_;
+
+ #need to impplement call to qemu-ga
+}
+
+sub qga_unfreezefs {
+ my ($vmid) = @_;
+
+ #need to impplement call to qemu-ga
+}
+
+sub vm_start {
+ my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom) = @_;
+
+ lock_config($vmid, sub {
+ my $conf = load_config($vmid, $migratedfrom);
+
+ check_lock($conf) if !$skiplock;
+
+ die "VM $vmid already running\n" if check_running($vmid, undef, $migratedfrom);
+
+ my $migrate_uri;
+ my $migrate_port = 0;
+
+ if ($statefile) {
+ if ($statefile eq 'tcp') {
+ $migrate_port = next_migrate_port();
+ $migrate_uri = "tcp:localhost:${migrate_port}";
+ } else {
+ if (-f $statefile) {
+ $migrate_uri = "exec:cat $statefile";
+ } else {
+ warn "state file '$statefile' does not exist - doing normal startup\n";
+ }
+ }
+ }
+
+ my $defaults = load_defaults();
+
+ # set environment variable useful inside network script
+ $ENV{PVE_MIGRATED_FROM} = $migratedfrom if $migratedfrom;
+
+ my ($cmd, $vollist) = config_to_command($storecfg, $vmid, $conf, $defaults, $migrate_uri);
+ # host pci devices
+ for (my $i = 0; $i < $MAX_HOSTPCI_DEVICES; $i++) {
+ my $d = parse_hostpci($conf->{"hostpci$i"});
+ next if !$d;
+ my $info = pci_device_info("0000:$d->{pciid}");
+ die "IOMMU not present\n" if !check_iommu_support();
+ die "no pci device info for device '$d->{pciid}'\n" if !$info;
+ die "can't unbind pci device '$d->{pciid}'\n" if !pci_dev_bind_to_stub($info);
+ die "can't reset pci device '$d->{pciid}'\n" if !pci_dev_reset($info);
+ }
+
+ PVE::Storage::activate_volumes($storecfg, $vollist);
+
+ eval { run_command($cmd, timeout => $migrate_uri ? undef : 30); };
+ my $err = $@;
+ die "start failed: $err" if $err;
+
+ if ($statefile) {
+
+ if ($statefile eq 'tcp') {
+ print "migration listens on port $migrate_port\n";
+ } else {
+ unlink $statefile;
+ # fixme: send resume - is that necessary ?
+ eval { vm_mon_cmd($vmid, "cont"); };
+ }
+ }
+
+ # always set migrate speed (overwrite kvm default of 32m)
+ # we set a very hight default of 8192m which is basically unlimited
+ my $migrate_speed = $defaults->{migrate_speed} || 8192;
+ $migrate_speed = $conf->{migrate_speed} || $migrate_speed;
+ $migrate_speed = $migrate_speed * 1048576;
+ eval {
+ vm_mon_cmd($vmid, "migrate_set_speed", value => $migrate_speed);
+ };
+
+ my $migrate_downtime = $defaults->{migrate_downtime};
+ $migrate_downtime = $conf->{migrate_downtime} if defined($conf->{migrate_downtime});
+ if (defined($migrate_downtime)) {
+ eval { vm_mon_cmd($vmid, "migrate_set_downtime", value => $migrate_downtime); };
+ }
+
+ if($migratedfrom) {
+ my $capabilities = {};
+ $capabilities->{capability} = "xbzrle";
+ $capabilities->{state} = JSON::true;
+ eval { PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "migrate-set-capabilities", capabilities => [$capabilities]); };
+ }
+
+ vm_balloonset($vmid, $conf->{balloon}) if $conf->{balloon};
+
+ });
+}
+
+sub vm_mon_cmd {
+ my ($vmid, $execute, %params) = @_;
+
+ my $cmd = { execute => $execute, arguments => \%params };
+ vm_qmp_command($vmid, $cmd);
+}
+
+sub vm_mon_cmd_nocheck {
+ my ($vmid, $execute, %params) = @_;
+
+ my $cmd = { execute => $execute, arguments => \%params };
+ vm_qmp_command($vmid, $cmd, 1);
+}
+
+sub vm_qmp_command {
+ my ($vmid, $cmd, $nocheck) = @_;
+
+ my $res;
+
+ my $timeout;
+ if ($cmd->{arguments} && $cmd->{arguments}->{timeout}) {
+ $timeout = $cmd->{arguments}->{timeout};
+ delete $cmd->{arguments}->{timeout};
+ }
+
+ eval {
+ die "VM $vmid not running\n" if !check_running($vmid, $nocheck);
+ my $sname = PVE::QemuServer::qmp_socket($vmid);
+ if (-e $sname) {
+ my $qmpclient = PVE::QMPClient->new();
+
+ $res = $qmpclient->cmd($vmid, $cmd, $timeout);
+ } elsif (-e "${var_run_tmpdir}/$vmid.mon") {
+ die "can't execute complex command on old monitor - stop/start your vm to fix the problem\n"
+ if scalar(%{$cmd->{arguments}});
+ vm_monitor_command($vmid, $cmd->{execute}, $nocheck);
+ } else {
+ die "unable to open monitor socket\n";
+ }
+ };
+ if (my $err = $@) {
+ syslog("err", "VM $vmid qmp command failed - $err");
+ die $err;
+ }
+
+ return $res;
+}
+
+sub vm_human_monitor_command {
+ my ($vmid, $cmdline) = @_;
+
+ my $res;
+
+ my $cmd = {
+ execute => 'human-monitor-command',
+ arguments => { 'command-line' => $cmdline},
+ };
+
+ return vm_qmp_command($vmid, $cmd);
+}
+
sub vm_commandline {
my ($storecfg, $vmid) = @_;
check_lock($conf) if !$skiplock;
- vm_monitor_command($vmid, "system_reset");
+ vm_mon_cmd($vmid, "system_reset");
});
}
my $vollist = get_vm_volumes($conf);
PVE::Storage::deactivate_volumes($storecfg, $vollist);
}
+
+ foreach my $ext (qw(mon qmp pid vnc qga)) {
+ unlink "/var/run/qemu-server/${vmid}.$ext";
+ }
};
warn $@ if $@; # avoid errors - just warn
}
# We need that when migration VMs to other nodes (files already moved)
# Note: we set $keepActive in vzdump stop mode - volumes need to stay active
sub vm_stop {
- my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive) = @_;
-
- $timeout = 60 if !defined($timeout);
+ my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
$force = 1 if !defined($force) && !$shutdown;
+ if ($migratedfrom){
+ my $pid = check_running($vmid, $nocheck, $migratedfrom);
+ kill 15, $pid if $pid;
+ my $conf = load_config($vmid, $migratedfrom);
+ vm_stop_cleanup($storecfg, $vmid, $conf, $keepActive);
+ return;
+ }
+
lock_config($vmid, sub {
my $pid = check_running($vmid, $nocheck);
if (!$nocheck) {
$conf = load_config($vmid);
check_lock($conf) if !$skiplock;
+ if (!defined($timeout) && $shutdown && $conf->{startup}) {
+ my $opts = parse_startup($conf->{startup});
+ $timeout = $opts->{down} if $opts->{down};
+ }
}
+ $timeout = 60 if !defined($timeout);
+
eval {
if ($shutdown) {
- vm_monitor_command($vmid, "system_powerdown", $nocheck);
+ $nocheck ? vm_mon_cmd_nocheck($vmid, "system_powerdown") : vm_mon_cmd($vmid, "system_powerdown");
+
} else {
- vm_monitor_command($vmid, "quit", $nocheck);
- }
+ $nocheck ? vm_mon_cmd_nocheck($vmid, "quit") : vm_mon_cmd($vmid, "quit");
+ }
};
my $err = $@;
warn "VM quit/powerdown failed - terminating now with SIGTERM\n";
kill 15, $pid;
} else {
- die "VM quit/powerdown failed\n";
+ die "VM quit/powerdown failed\n";
}
}
check_lock($conf) if !$skiplock;
- vm_monitor_command($vmid, "stop");
+ vm_mon_cmd($vmid, "stop");
});
}
check_lock($conf) if !$skiplock;
- vm_monitor_command($vmid, "cont");
+ vm_mon_cmd($vmid, "cont");
});
}
my $conf = load_config($vmid);
- vm_monitor_command($vmid, "sendkey $key");
+ # there is no qmp command, so we use the human monitor command
+ vm_human_monitor_command($vmid, "sendkey $key");
});
}
});
}
-sub vm_stopall {
- my ($storecfg, $timeout) = @_;
-
- $timeout = 3*60 if !$timeout;
-
- my $cleanuphash = {};
-
- my $vzlist = vzlist();
- my $count = 0;
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
- $count++;
- $cleanuphash->{$vmid} = 1;
- }
-
- return if !$count;
-
- my $msg = "Stopping Qemu Server - sending shutdown requests to all VMs\n";
- syslog('info', $msg);
- warn $msg;
-
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
- eval { vm_monitor_command($vmid, "system_powerdown"); };
- warn $@ if $@;
- }
-
- my $wt = 5;
- my $maxtries = int(($timeout + $wt -1)/$wt);
- my $try = 0;
- while (($try < $maxtries) && $count) {
- $try++;
- sleep $wt;
-
- $vzlist = vzlist();
- $count = 0;
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
- $count++;
- }
- last if !$count;
- }
-
- if ($count) {
-
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
-
- warn "VM $vmid still running - sending stop now\n";
- eval { vm_monitor_command($vmid, "quit"); };
- warn $@ if $@;
- }
-
- $timeout = 30;
- $maxtries = int(($timeout + $wt -1)/$wt);
- $try = 0;
- while (($try < $maxtries) && $count) {
- $try++;
- sleep $wt;
-
- $vzlist = vzlist();
- $count = 0;
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
- $count++;
- }
- last if !$count;
- }
-
- if ($count) {
-
- foreach my $vmid (keys %$vzlist) {
- next if !$vzlist->{$vmid}->{pid};
-
- warn "VM $vmid still running - terminating now with SIGTERM\n";
- kill 15, $vzlist->{$vmid}->{pid};
- }
- sleep 1;
- }
-
- # this is called by system shotdown scripts, so remaining
- # processes gets killed anyways (no need to send kill -9 here)
- }
-
- $vzlist = vzlist();
- foreach my $vmid (keys %$cleanuphash) {
- next if $vzlist->{$vmid}->{pid};
- eval {
- my $conf = load_config($vmid);
- vm_stop_cleanup($storecfg, $vmid, $conf);
- };
- warn $@ if $@;
- }
-
- $msg = "Qemu Server stopped\n";
- syslog('info', $msg);
- print $msg;
-}
-
# pci helpers
sub file_write {
return -d $testdir;
}
-sub print_pci_addr {
- my ($id) = @_;
+sub print_pci_addr {
+ my ($id, $bridges) = @_;
my $res = '';
my $devices = {
#addr2 : first videocard
balloon0 => { bus => 0, addr => 3 },
watchdog => { bus => 0, addr => 4 },
- lsi0 => { bus => 0, addr => 5 },
- lsi1 => { bus => 0, addr => 6 },
+ scsihw0 => { bus => 0, addr => 5 },
+ scsihw1 => { bus => 0, addr => 6 },
+ ahci0 => { bus => 0, addr => 7 },
+ qga0 => { bus => 0, addr => 8 },
virtio0 => { bus => 0, addr => 10 },
virtio1 => { bus => 0, addr => 11 },
virtio2 => { bus => 0, addr => 12 },
net4 => { bus => 0, addr => 22 },
net5 => { bus => 0, addr => 23 },
#addr29 : usb-host (pve-usb.cfg)
+ 'pci.1' => { bus => 0, addr => 30 },
+ 'pci.2' => { bus => 0, addr => 31 },
+ 'net6' => { bus => 1, addr => 1 },
+ 'net7' => { bus => 1, addr => 2 },
+ 'net8' => { bus => 1, addr => 3 },
+ 'net9' => { bus => 1, addr => 4 },
+ 'net10' => { bus => 1, addr => 5 },
+ 'net11' => { bus => 1, addr => 6 },
+ 'net12' => { bus => 1, addr => 7 },
+ 'net13' => { bus => 1, addr => 8 },
+ 'net14' => { bus => 1, addr => 9 },
+ 'net15' => { bus => 1, addr => 10 },
+ 'net16' => { bus => 1, addr => 11 },
+ 'net17' => { bus => 1, addr => 12 },
+ 'net18' => { bus => 1, addr => 13 },
+ 'net19' => { bus => 1, addr => 14 },
+ 'net20' => { bus => 1, addr => 15 },
+ 'net21' => { bus => 1, addr => 16 },
+ 'net22' => { bus => 1, addr => 17 },
+ 'net23' => { bus => 1, addr => 18 },
+ 'net24' => { bus => 1, addr => 19 },
+ 'net25' => { bus => 1, addr => 20 },
+ 'net26' => { bus => 1, addr => 21 },
+ 'net27' => { bus => 1, addr => 22 },
+ 'net28' => { bus => 1, addr => 23 },
+ 'net29' => { bus => 1, addr => 24 },
+ 'net30' => { bus => 1, addr => 25 },
+ 'net31' => { bus => 1, addr => 26 },
+ 'virtio6' => { bus => 2, addr => 1 },
+ 'virtio7' => { bus => 2, addr => 2 },
+ 'virtio8' => { bus => 2, addr => 3 },
+ 'virtio9' => { bus => 2, addr => 4 },
+ 'virtio10' => { bus => 2, addr => 5 },
+ 'virtio11' => { bus => 2, addr => 6 },
+ 'virtio12' => { bus => 2, addr => 7 },
+ 'virtio13' => { bus => 2, addr => 8 },
+ 'virtio14' => { bus => 2, addr => 9 },
+ 'virtio15' => { bus => 2, addr => 10 },
};
if (defined($devices->{$id}->{bus}) && defined($devices->{$id}->{addr})) {
my $addr = sprintf("0x%x", $devices->{$id}->{addr});
- $res = ",bus=pci.$devices->{$id}->{bus},addr=$addr";
+ my $bus = $devices->{$id}->{bus};
+ $res = ",bus=pci.$bus,addr=$addr";
+ $bridges->{$bus} = 1 if $bridges;
}
return $res;
sub vm_balloonset {
my ($vmid, $value) = @_;
- vm_monitor_command($vmid, "balloon $value");
+ vm_mon_cmd($vmid, "balloon", value => $value);
}
# vzdump restore implementaion
sub archive_read_firstfile {
my $archive = shift;
-
+
die "ERROR: file '$archive' does not exist\n" if ! -f $archive;
# try to detect archive type first
my $cfg = cfs_read_file('storage.cfg');
PVE::Storage::vdisk_free($cfg, $volid);
}
- print STDERR "temporary volume '$volid' sucessfuly removed\n";
+ print STDERR "temporary volume '$volid' sucessfuly removed\n";
};
print STDERR "unable to cleanup '$volid' - $@" if $@;
} else {
print STDERR "unable to parse line in statfile - $line";
- }
+ }
}
$fd->close();
}
}
sub restore_archive {
- my ($archive, $vmid, $opts) = @_;
+ my ($archive, $vmid, $user, $opts) = @_;
if ($archive ne '-') {
my $firstfile = archive_read_firstfile($archive);
my $tocmd = "/usr/lib/qemu-server/qmextract";
$tocmd .= " --storage " . PVE::Tools::shellquote($opts->{storage}) if $opts->{storage};
+ $tocmd .= " --pool " . PVE::Tools::shellquote($opts->{pool}) if $opts->{pool};
$tocmd .= ' --prealloc' if $opts->{prealloc};
$tocmd .= ' --info' if $opts->{info};
- # tar option "xf" does not autodetect compression when read fron STDIN,
+ # tar option "xf" does not autodetect compression when read from STDIN,
# so we pipe to zcat
my $cmd = "zcat -f|tar xf " . PVE::Tools::shellquote($archive) . " " .
PVE::Tools::shellquote("--to-command=$tocmd");
local $ENV{VZDUMP_TMPDIR} = $tmpdir;
local $ENV{VZDUMP_VMID} = $vmid;
+ local $ENV{VZDUMP_USER} = $user;
my $conffile = PVE::QemuServer::config_file($vmid);
my $tmpfn = "$conffile.$$.tmp";
print STDERR "got interrupt - ignored\n";
};
- eval {
+ eval {
# enable interrupts
local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
die "interrupted by signal\n";
my $net = parse_net($netstr);
$net->{macaddr} = PVE::Tools::random_ether_addr() if $net->{macaddr};
$netstr = print_net($net);
- print $outfd "$id: $netstr\n";
+ print $outfd "$id: $netstr\n";
} elsif ($line =~ m/^((ide|scsi|virtio)\d+):\s*(\S+)\s*$/) {
my $virtdev = $1;
my $value = $2;
};
my $err = $@;
- if ($err) {
+ if ($err) {
unlink $tmpfn;
restore_cleanup("$tmpdir/qmrestore.stat") if !$opts->{info};
-
+
die $err;
- }
+ }
rmtree $tmpdir;
projects / qemu-server.git / blobdiff