X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FAPI2%2FQemu.pm;h=869eb8c109aeb87883e43b0cbc2483b5adf53a2a;hb=c268337d9325bf534675578039c375273843a1f3;hp=779fdd89a9627b2d0056b8583d973bc4b8100034;hpb=29ddbe702b06711132b63a4809e4dc51276f7bac;p=qemu-server.git

diff --git a/PVE/API2/Qemu.pm b/PVE/API2/Qemu.pm
index 779fdd8..869eb8c 100644
--- a/PVE/API2/Qemu.pm
+++ b/PVE/API2/Qemu.pm
@@ -5,6 +5,8 @@ use warnings;
 use Cwd 'abs_path';
 use Net::SSLeay;
 use UUID;
+use POSIX;
+use IO::Socket::IP;
 
 use PVE::Cluster qw (cfs_read_file cfs_write_file);;
 use PVE::SafeSyslog;
@@ -13,6 +15,8 @@ use PVE::Exception qw(raise raise_param_exc raise_perm_exc);
 use PVE::Storage;
 use PVE::JSONSchema qw(get_standard_option);
 use PVE::RESTHandler;
+use PVE::ReplicationConfig;
+use PVE::GuestHelpers;
 use PVE::QemuConfig;
 use PVE::QemuServer;
 use PVE::QemuMigrate;
@@ -22,8 +26,15 @@ use PVE::INotify;
 use PVE::Network;
 use PVE::Firewall;
 use PVE::API2::Firewall::VM;
-use PVE::HA::Env::PVE2;
-use PVE::HA::Config;
+
+BEGIN {
+    if (!$ENV{PVE_GENERATING_DOCS}) {
+	require PVE::HA::Env::PVE2;
+	import PVE::HA::Env::PVE2;
+	require PVE::HA::Config;
+	import PVE::HA::Config;
+    }
+}
 
 use Data::Dumper; # fixme: remove
 
@@ -41,6 +52,7 @@ my $resolve_cdrom_alias = sub {
     }
 };
 
+my $NEW_DISK_RE = qr!^(([^/:\s]+):)?(\d+(\.\d+)?)$!;
 my $check_storage_access = sub {
    my ($rpcenv, $authuser, $storecfg, $vmid, $settings, $default_storage) = @_;
 
@@ -55,12 +67,15 @@ my $check_storage_access = sub {
 	    # nothing to check
 	} elsif ($isCDROM && ($volid eq 'cdrom')) {
 	    $rpcenv->check($authuser, "/", ['Sys.Console']);
-	} elsif (!$isCDROM && ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/)) {
+	} elsif (!$isCDROM && ($volid =~ $NEW_DISK_RE)) {
 	    my ($storeid, $size) = ($2 || $default_storage, $3);
 	    die "no storage ID specified (and no default storage)\n" if !$storeid;
 	    $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
+	    my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
+	    raise_param_exc({ storage => "storage '$storeid' does not support vm images"})
+		if !$scfg->{content}->{images};
 	} else {
-	    $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
+	    PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $volid);
 	}
     });
 };
@@ -110,7 +125,8 @@ my $create_disks = sub {
     my $vollist = [];
 
     my $res = {};
-    PVE::QemuServer::foreach_drive($settings, sub {
+
+    my $code = sub {
 	my ($ds, $disk) = @_;
 
 	my $volid = $disk->{file};
@@ -118,46 +134,28 @@ my $create_disks = sub {
 	if (!$volid || $volid eq 'none' || $volid eq 'cdrom') {
 	    delete $disk->{size};
 	    $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
-	} elsif ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/) {
+	} elsif ($volid =~ $NEW_DISK_RE) {
 	    my ($storeid, $size) = ($2 || $default_storage, $3);
 	    die "no storage ID specified (and no default storage)\n" if !$storeid;
 	    my $defformat = PVE::Storage::storage_default_format($storecfg, $storeid);
 	    my $fmt = $disk->{format} || $defformat;
 
+	    $size = PVE::Tools::convert_size($size, 'gb' => 'kb'); # vdisk_alloc uses kb
+
 	    my $volid;
 	    if ($ds eq 'efidisk0') {
-		# handle efidisk
-		my $ovmfvars = '/usr/share/kvm/OVMF_VARS-pure-efi.fd';
-		die "uefi vars image not found\n" if ! -f $ovmfvars;
-		$volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
-						      $fmt, undef, 128);
-		$disk->{file} = $volid;
-		$disk->{size} = 128*1024;
-		my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
-		my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
-		my $qemufmt = PVE::QemuServer::qemu_img_format($scfg, $volname);
-		my $path = PVE::Storage::path($storecfg, $volid);
-		my $efidiskcmd = ['/usr/bin/qemu-img', 'convert', '-n', '-f', 'raw', '-O', $qemufmt];
-		push @$efidiskcmd, $ovmfvars;
-		push @$efidiskcmd, $path;
-
-		PVE::Storage::activate_volumes($storecfg, [$volid]);
-
-		eval { PVE::Tools::run_command($efidiskcmd); };
-		my $err = $@;
-		die "Copying of EFI Vars image failed: $err" if $err;
+		($volid, $size) = PVE::QemuServer::create_efidisk($storecfg, $storeid, $vmid, $fmt);
 	    } else {
-		$volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
-						      $fmt, undef, $size*1024*1024);
-		$disk->{file} = $volid;
-		$disk->{size} = $size*1024*1024*1024;
+		$volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $fmt, undef, $size);
 	    }
 	    push @$vollist, $volid;
+	    $disk->{file} = $volid;
+	    $disk->{size} = PVE::Tools::convert_size($size, 'kb' => 'b');
 	    delete $disk->{format}; # no longer needed
 	    $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
 	} else {
 
-	    $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
+	    PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $volid);
 
 	    my $volid_is_new = 1;
 
@@ -181,7 +179,9 @@ my $create_disks = sub {
 
 	    $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
 	}
-    });
+    };
+
+    eval { PVE::QemuServer::foreach_drive($settings, $code); };
 
     # free allocated images on error
     if (my $err = $@) {
@@ -474,7 +474,7 @@ __PACKAGE__->register_method({
 		die "pipe requires cli environment\n"
 		    if $rpcenv->{type} ne 'cli';
 	    } else {
-		$rpcenv->check_volume_access($authuser, $storecfg, $vmid, $archive);
+		PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $archive);
 		$archive = PVE::Storage::abs_filesystem_path($storecfg, $archive);
 	    }
 	}
@@ -511,6 +511,9 @@ __PACKAGE__->register_method({
 		PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
 	    };
 
+	    # ensure no old replication state are exists
+	    PVE::ReplicationState::delete_guest_states($vmid);
+
 	    return $rpcenv->fork_worker('qmrestore', $vmid, $authuser, $realcmd);
 	};
 
@@ -519,6 +522,9 @@ __PACKAGE__->register_method({
 	    # test after locking
 	    PVE::Cluster::check_vmid_unused($vmid);
 
+	    # ensure no old replication state are exists
+	    PVE::ReplicationState::delete_guest_states($vmid);
+
 	    my $realcmd = sub {
 
 		my $vollist = [];
@@ -614,6 +620,7 @@ __PACKAGE__->register_method({
 	    { subdir => 'rrd' },
 	    { subdir => 'rrddata' },
 	    { subdir => 'monitor' },
+	    { subdir => 'agent' },
 	    { subdir => 'snapshot' },
 	    { subdir => 'spiceproxy' },
 	    { subdir => 'sendkey' },
@@ -883,7 +890,7 @@ my $update_vm_api  = sub {
     my $background_delay = extract_param($param, 'background_delay');
 
     my @paramarr = (); # used for log message
-    foreach my $key (keys %$param) {
+    foreach my $key (sort keys %$param) {
 	push @paramarr, "-$key", $param->{$key};
     }
 
@@ -939,12 +946,35 @@ my $update_vm_api  = sub {
 	push @delete, $opt;
     }
 
+    my $repl_conf = PVE::ReplicationConfig->new();
+    my $is_replicated = $repl_conf->check_for_existing_jobs($vmid, 1);
+    my $check_replication = sub {
+	my ($drive) = @_;
+	return if !$is_replicated;
+	my $volid = $drive->{file};
+	return if !$volid || !($drive->{replicate}//1);
+	return if PVE::QemuServer::drive_is_cdrom($drive);
+	my ($storeid, $format);
+	if ($volid =~ $NEW_DISK_RE) {
+	    $storeid = $2;
+	    $format = $drive->{format} || PVE::Storage::storage_default_format($storecfg, $storeid);
+	} else {
+	    ($storeid, undef) = PVE::Storage::parse_volume_id($volid, 1);
+	    $format = (PVE::Storage::parse_volname($storecfg, $volid))[6];
+	}
+	return if PVE::Storage::storage_can_replicate($storecfg, $storeid, $format);
+	my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
+	return if $scfg->{shared};
+	die "cannot add non-replicatable volume to a replicated VM\n";
+    };
+
     foreach my $opt (keys %$param) {
 	if (PVE::QemuServer::is_valid_drivename($opt)) {
 	    # cleanup drive path
 	    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 	    raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
 	    PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
+	    $check_replication->($drive);
 	    $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
 	} elsif ($opt =~ m/^net(\d+)$/) {
 	    # add macaddr
@@ -997,6 +1027,12 @@ my $update_vm_api  = sub {
 	    foreach my $opt (@delete) {
 		$modified->{$opt} = 1;
 		$conf = PVE::QemuConfig->load_config($vmid); # update/reload
+		if (!defined($conf->{$opt}) && !defined($conf->{pending}->{$opt})) {
+		    warn "cannot delete '$opt' - not set in current configuration!\n";
+		    $modified->{$opt} = 0;
+		    next;
+		}
+
 		if ($opt =~ m/^unused/) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
 		    PVE::QemuConfig->check_protection($conf, "can't remove unused disk '$drive->{file}'");
@@ -1260,6 +1296,10 @@ __PACKAGE__->register_method({
 	die "unable to remove VM $vmid - used in HA resources\n"
 	    if PVE::HA::Config::vm_is_ha_managed($vmid);
 
+	# do not allow destroy if there are replication jobs
+	my $repl_conf = PVE::ReplicationConfig->new();
+	$repl_conf->check_for_existing_jobs($vmid);
+
 	# early tests (repeat after locking)
 	die "VM $vmid is running - destroy failed\n"
 	    if PVE::QemuServer::check_running($vmid);
@@ -1400,24 +1440,41 @@ __PACKAGE__->register_method({
 		$cmd = ['/usr/bin/vncterm', '-rfbport', $port,
 			'-timeout', $timeout, '-authpath', $authpath,
 			'-perm', 'Sys.Console', '-c', @$remcmd, @$termcmd];
+		PVE::Tools::run_command($cmd);
 	    } else {
 
 		$ENV{LC_PVE_TICKET} = $ticket if $websocket; # set ticket with "qm vncproxy"
 
-		my $qmcmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
-
-		my $qmstr = join(' ', @$qmcmd);
-
-		# also redirect stderr (else we get RFB protocol errors)
-		$cmd = ['/bin/nc6', '-l', '-p', $port, '-w', $timeout, '-e', "$qmstr 2>/dev/null"];
+		$cmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
+
+		my $sock = IO::Socket::IP->new(
+		    ReuseAddr => 1,
+		    Listen => 1,
+		    LocalPort => $port,
+		    Proto => 'tcp',
+		    GetAddrInfoFlags => 0,
+		    ) or die "failed to create socket: $!\n";
+		# Inside the worker we shouldn't have any previous alarms
+		# running anyway...:
+		alarm(0);
+		local $SIG{ALRM} = sub { die "connection timed out\n" };
+		alarm $timeout;
+		accept(my $cli, $sock) or die "connection failed: $!\n";
+		alarm(0);
+		close($sock);
+		if (PVE::Tools::run_command($cmd,
+		    output => '>&'.fileno($cli),
+		    input => '<&'.fileno($cli),
+		    noerr => 1) != 0)
+		{
+		    die "Failed to run vncproxy.\n";
+		}
 	    }
 
-	    PVE::Tools::run_command($cmd);
-
 	    return;
 	};
 
-	my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd);
+	my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd, 1);
 
 	PVE::Tools::wait_for_vnc_port($port);
 
@@ -1641,6 +1698,11 @@ __PACKAGE__->register_method({
 		optional => 1,
 	    },
 	    machine => get_standard_option('pve-qm-machine'),
+	    targetstorage => {
+		description => "Target storage for the migration. (Can be '1' to use the same storage id as on the source node.)",
+		type => 'string',
+		optional => 1
+	    }
 	},
     },
     returns => {
@@ -1679,6 +1741,13 @@ __PACKAGE__->register_method({
 	raise_param_exc({ migration_network => "Only root may use this option." })
 	    if $migration_network && $authuser ne 'root@pam';
 
+	my $targetstorage = extract_param($param, 'targetstorage');
+	raise_param_exc({ targetstorage => "Only root may use this option." })
+	    if $targetstorage && $authuser ne 'root@pam';
+
+	raise_param_exc({ targetstorage => "targetstorage can only by used with migratedfrom." })
+	    if $targetstorage && !$migratedfrom;
+
 	# read spice ticket from STDIN
 	my $spice_ticket;
 	if ($stateuri && ($stateuri eq 'tcp') && $migratedfrom && ($rpcenv->{type} eq 'cli')) {
@@ -1702,7 +1771,7 @@ __PACKAGE__->register_method({
 
 		my $cmd = ['ha-manager', 'set', $service, '--state', 'started'];
 
-		print "Executing HA start for VM $vmid\n";
+		print "Requesting HA start for VM $vmid\n";
 
 		PVE::Tools::run_command($cmd);
 
@@ -1719,7 +1788,7 @@ __PACKAGE__->register_method({
 		syslog('info', "start VM $vmid: $upid\n");
 
 		PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock, $migratedfrom, undef,
-					  $machine, $spice_ticket, $migration_network, $migration_type);
+					  $machine, $spice_ticket, $migration_network, $migration_type, $targetstorage);
 
 		return;
 	    };
@@ -1799,7 +1868,7 @@ __PACKAGE__->register_method({
 
 		my $cmd = ['ha-manager', 'set', $service, '--state', 'stopped'];
 
-		print "Executing HA stop for VM $vmid\n";
+		print "Requesting HA stop for VM $vmid\n";
 
 		PVE::Tools::run_command($cmd);
 
@@ -1959,18 +2028,40 @@ __PACKAGE__->register_method({
 	    }
 	}
 
-	my $realcmd = sub {
-	    my $upid = shift;
+	if (PVE::HA::Config::vm_is_ha_managed($vmid) &&
+	    ($rpcenv->{type} ne 'ha')) {
+
+	    my $hacmd = sub {
+		my $upid = shift;
 
-	    syslog('info', "shutdown VM $vmid: $upid\n");
+		my $service = "vm:$vmid";
 
-	    PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
-				     $shutdown, $param->{forceStop}, $keepActive);
+		my $cmd = ['ha-manager', 'set', $service, '--state', 'stopped'];
 
-	    return;
-	};
+		print "Requesting HA stop for VM $vmid\n";
+
+		PVE::Tools::run_command($cmd);
+
+		return;
+	    };
+
+	    return $rpcenv->fork_worker('hastop', $vmid, $authuser, $hacmd);
 
-	return $rpcenv->fork_worker('qmshutdown', $vmid, $authuser, $realcmd);
+	} else {
+
+	    my $realcmd = sub {
+		my $upid = shift;
+
+		syslog('info', "shutdown VM $vmid: $upid\n");
+
+		PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
+					 $shutdown, $param->{forceStop}, $keepActive);
+
+		return;
+	    };
+
+	    return $rpcenv->fork_worker('qmshutdown', $vmid, $authuser, $realcmd);
+	}
     }});
 
 __PACKAGE__->register_method({
@@ -2372,12 +2463,12 @@ __PACKAGE__->register_method({
 			$newconf->{$opt} = $value; # simply copy configuration
 		    } else {
 			if ($param->{full}) {
-			    die "Full clone feature is not available"
+			    die "Full clone feature is not supported for drive '$opt'\n"
 				if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running);
 			    $fullclone->{$opt} = 1;
 			} else {
 			    # not full means clone instead of copy
-			    die "Linked clone feature is not available"
+			    die "Linked clone feature is not supported for drive '$opt'\n"
 				if !PVE::Storage::volume_has_feature($storecfg, 'clone', $drive->{file}, $snapname, $running);
 			}
 			$drives->{$opt} = $drive;
@@ -2420,21 +2511,31 @@ __PACKAGE__->register_method({
 		my $upid = shift;
 
 		my $newvollist = [];
+		my $jobs = {};
 
 		eval {
-		    local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
+		    local $SIG{INT} =
+			local $SIG{TERM} =
+			local $SIG{QUIT} =
+			local $SIG{HUP} = sub { die "interrupted by signal\n"; };
 
 		    PVE::Storage::activate_volumes($storecfg, $vollist, $snapname);
 
+		    my $total_jobs = scalar(keys %{$drives});
+		    my $i = 1;
+
 		    foreach my $opt (keys %$drives) {
 			my $drive = $drives->{$opt};
+			my $skipcomplete = ($total_jobs != $i); # finish after last drive
 
 			my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
-								   $newid, $storage, $format, $fullclone->{$opt}, $newvollist);
+								   $newid, $storage, $format, $fullclone->{$opt}, $newvollist,
+								   $jobs, $skipcomplete, $oldconf->{agent});
 
 			$newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive);
 
 			PVE::QemuConfig->write_config($newid, $newconf);
+			$i++;
 		    }
 
 		    delete $newconf->{lock};
@@ -2455,6 +2556,8 @@ __PACKAGE__->register_method({
 		if (my $err = $@) {
 		    unlink $conffile;
 
+		    eval { PVE::QemuServer::qemu_blockjobs_cancel($vmid, $jobs) };
+
 		    sleep 1; # some storage like rbd need to wait before release volume - really?
 
 		    foreach my $volid (@$newvollist) {
@@ -2487,17 +2590,15 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     description => "Move volume to different storage.",
     permissions => {
-	description => "You need 'VM.Config.Disk' permissions on /vms/{vmid}, " .
-	    "and 'Datastore.AllocateSpace' permissions on the storage.",
-	check =>
-	[ 'and',
-	  ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
-	  ['perm', '/storage/{storage}', [ 'Datastore.AllocateSpace' ]],
-	],
+	description => "You need 'VM.Config.Disk' permissions on /vms/{vmid}, and 'Datastore.AllocateSpace' permissions on the storage.",
+	check => [ 'and',
+		   ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
+		   ['perm', '/storage/{storage}', [ 'Datastore.AllocateSpace' ]],
+	    ],
     },
     parameters => {
         additionalProperties => 0,
-        properties => {
+	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
 	    disk => {
@@ -2596,7 +2697,10 @@ __PACKAGE__->register_method({
 		my $newvollist = [];
 
 		eval {
-		    local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
+		    local $SIG{INT} =
+			local $SIG{TERM} =
+			local $SIG{QUIT} =
+			local $SIG{HUP} = sub { die "interrupted by signal\n"; };
 
 		    warn "moving disk with snapshots, snapshots will not be moved!\n"
 			if $snapshotted;
@@ -2608,6 +2712,10 @@ __PACKAGE__->register_method({
 
 		    PVE::QemuConfig->add_unused_volume($conf, $old_volid) if !$param->{delete};
 
+		    # convert moved disk to base if part of template
+		    PVE::QemuServer::template_create($vmid, $conf, $disk)
+			if PVE::QemuConfig->is_template($conf);
+
 		    PVE::QemuConfig->write_config($vmid, $conf);
 
 		    eval {
@@ -2673,17 +2781,24 @@ __PACKAGE__->register_method({
 	    migration_type => {
 		type => 'string',
 		enum => ['secure', 'insecure'],
-		description => "Migration traffic is encrypted using an SSH " .
-		  "tunnel by default. On secure, completely private networks " .
-		  "this can be disabled to increase performance.",
+		description => "Migration traffic is encrypted using an SSH tunnel by default. On secure, completely private networks this can be disabled to increase performance.",
 		optional => 1,
 	    },
 	    migration_network => {
-		type => 'string',
-		format => 'CIDR',
+		type => 'string', format => 'CIDR',
 		description => "CIDR of the (sub) network that is used for migration.",
 		optional => 1,
 	    },
+	    "with-local-disks" => {
+		type => 'boolean',
+		description => "Enable live storage migration for local disk",
+		optional => 1,
+	    },
+            targetstorage => get_standard_option('pve-storage-id', {
+		description => "Default target storage.",
+		optional => 1,
+		completion => \&PVE::QemuServer::complete_storage,
+            }),
 	},
     },
     returns => {
@@ -2710,6 +2825,9 @@ __PACKAGE__->register_method({
 
 	my $vmid = extract_param($param, 'vmid');
 
+	raise_param_exc({ targetstorage => "Live storage migration can only be done online." })
+	    if !$param->{online} && $param->{targetstorage};
+
 	raise_param_exc({ force => "Only root may use this option." })
 	    if $param->{force} && $authuser ne 'root@pam';
 
@@ -2733,7 +2851,12 @@ __PACKAGE__->register_method({
 	}
 
 	my $storecfg = PVE::Storage::config();
-	PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
+
+	if( $param->{targetstorage}) {
+	    PVE::Storage::storage_check_node($storecfg, $param->{targetstorage}, $target);
+        } else {
+	    PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
+	}
 
 	if (PVE::HA::Config::vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
 
@@ -2744,7 +2867,7 @@ __PACKAGE__->register_method({
 
 		my $cmd = ['ha-manager', 'migrate', $service, $target];
 
-		print "Executing HA migrate for VM $vmid to node $target\n";
+		print "Requesting HA migration for VM $vmid to node $target\n";
 
 		PVE::Tools::run_command($cmd);
 
@@ -2756,12 +2879,14 @@ __PACKAGE__->register_method({
 	} else {
 
 	    my $realcmd = sub {
-		my $upid = shift;
-
 		PVE::QemuMigrate->migrate($target, $targetip, $vmid, $param);
 	    };
 
-	    return $rpcenv->fork_worker('qmigrate', $vmid, $authuser, $realcmd);
+	    my $worker = sub {
+		return PVE::GuestHelpers::guest_migration_lock($vmid, 10, $realcmd);
+	    };
+
+	    return $rpcenv->fork_worker('qmigrate', $vmid, $authuser, $worker);
 	}
 
     }});
@@ -2774,7 +2899,8 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     description => "Execute Qemu monitor commands.",
     permissions => {
-	check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
+	description => "Sys.Modify is required for (sub)commands which are not read-only ('info *' and 'help')",
+        check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
     },
     parameters => {
     	additionalProperties => 0,
@@ -2791,6 +2917,18 @@ __PACKAGE__->register_method({
     code => sub {
 	my ($param) = @_;
 
+	my $rpcenv = PVE::RPCEnvironment::get();
+	my $authuser = $rpcenv->get_user();
+
+	my $is_ro = sub {
+	    my $command = shift;
+	    return $command =~ m/^\s*info(\s+|$)/
+	        || $command =~ m/^\s*help\s*$/;
+	};
+
+	$rpcenv->check_full($authuser, "/", ['Sys.Modify'])
+	    if !&$is_ro($param->{command});
+
 	my $vmid = $param->{vmid};
 
 	my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists
@@ -2804,6 +2942,70 @@ __PACKAGE__->register_method({
 	return $res;
     }});
 
+my $guest_agent_commands = [
+    'ping',
+    'get-time',
+    'info',
+    'fsfreeze-status',
+    'fsfreeze-freeze',
+    'fsfreeze-thaw',
+    'fstrim',
+    'network-get-interfaces',
+    'get-vcpus',
+    'get-fsinfo',
+    'get-memory-blocks',
+    'get-memory-block-info',
+    'suspend-hybrid',
+    'suspend-ram',
+    'suspend-disk',
+    'shutdown',
+    ];
+
+__PACKAGE__->register_method({
+    name => 'agent',
+    path => '{vmid}/agent',
+    method => 'POST',
+    protected => 1,
+    proxyto => 'node',
+    description => "Execute Qemu Guest Agent commands.",
+    permissions => {
+	check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
+    },
+    parameters => {
+	additionalProperties => 0,
+	properties => {
+	    node => get_standard_option('pve-node'),
+	    vmid => get_standard_option('pve-vmid', {
+                   completion => \&PVE::QemuServer::complete_vmid_running }),
+	    command => {
+		type => 'string',
+		description => "The QGA command.",
+		enum => $guest_agent_commands,
+	    },
+	},
+    },
+    returns => {
+	type => 'object',
+	description => "Returns an object with a single `result` property. The type of that
+property depends on the executed command.",
+    },
+    code => sub {
+	my ($param) = @_;
+
+	my $vmid = $param->{vmid};
+
+	my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists
+
+	die "No Qemu Guest Agent\n" if !defined($conf->{agent});
+	die "VM $vmid is not running\n" if !PVE::QemuServer::check_running($vmid);
+
+	my $cmd = $param->{command};
+
+	my $res = PVE::QemuServer::vm_mon_cmd($vmid, "guest-$cmd");
+
+	return { result => $res };
+    }});
+
 __PACKAGE__->register_method({
     name => 'resize_vm',
     path => '{vmid}/resize',
@@ -2828,7 +3030,7 @@ __PACKAGE__->register_method({
 	    size => {
 		type => 'string',
 		pattern => '\+?\d+(\.\d+)?[KMGT]?',
-		description => "The new size. With the '+' sign the value is added to the actual size of the volume and without it, the value is taken as an absolute one. Shrinking disk size is not supported.",
+		description => "The new size. With the `+` sign the value is added to the actual size of the volume and without it, the value is taken as an absolute one. Shrinking disk size is not supported.",
 	    },
 	    digest => {
 		type => 'string',
@@ -2909,7 +3111,7 @@ __PACKAGE__->register_method({
 	    $newsize += $size if $ext;
 	    $newsize = int($newsize);
 
-	    die "unable to skrink disk size\n" if $newsize < $size;
+	    die "shrinking disks is not supported\n" if $newsize < $size;
 
 	    return if $size == $newsize;
 
@@ -3140,7 +3342,7 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     description => "Get snapshot configuration",
     permissions => {
-	check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
+	check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot', 'VM.Snapshot.Rollback' ], any => 1],
     },
     parameters => {
 	additionalProperties => 0,
@@ -3179,7 +3381,7 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     description => "Rollback VM state to specified snapshot.",
     permissions => {
-	check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
+	check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot', 'VM.Snapshot.Rollback' ], any => 1],
     },
     parameters => {
 	additionalProperties => 0,
@@ -3211,7 +3413,12 @@ __PACKAGE__->register_method({
 	    PVE::QemuConfig->snapshot_rollback($vmid, $snapname);
 	};
 
-	return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $realcmd);
+	my $worker = sub {
+	    # hold migration lock, this makes sure that nobody create replication snapshots
+	    return PVE::GuestHelpers::guest_migration_lock($vmid, 10, $realcmd);
+	};
+
+	return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $worker);
     }});
 
 __PACKAGE__->register_method({