X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FAPI2%2FQemu.pm;h=8c5abc139f7291456107c40a00bf21fd8a767aac;hb=c21013ac58e8f178ba7e07722702747b50bfb980;hp=fa8315e1d18f0572ba3cb6be381e6c5c541b2d6b;hpb=c4ac8f713caa54ae94b3ca3d22d98ca2ef62e669;p=qemu-server.git

diff --git a/PVE/API2/Qemu.pm b/PVE/API2/Qemu.pm
index fa8315e..8c5abc1 100644
--- a/PVE/API2/Qemu.pm
+++ b/PVE/API2/Qemu.pm
@@ -7,6 +7,7 @@ use Net::SSLeay;
 use POSIX;
 use IO::Socket::IP;
 use URI::Escape;
+use Crypt::OpenSSL::Random;
 
 use PVE::Cluster qw (cfs_read_file cfs_write_file);;
 use PVE::RRD;
@@ -21,6 +22,7 @@ use PVE::GuestHelpers;
 use PVE::QemuConfig;
 use PVE::QemuServer;
 use PVE::QemuServer::Drive;
+use PVE::QemuServer::CPUConfig;
 use PVE::QemuServer::Monitor qw(mon_cmd);
 use PVE::QemuMigrate;
 use PVE::RPCEnvironment;
@@ -63,7 +65,7 @@ my $NEW_DISK_RE = qr!^(([^/:\s]+):)?(\d+(\.\d+)?)$!;
 my $check_storage_access = sub {
    my ($rpcenv, $authuser, $storecfg, $vmid, $settings, $default_storage) = @_;
 
-   PVE::QemuServer::foreach_drive($settings, sub {
+   PVE::QemuConfig->foreach_volume($settings, sub {
 	my ($ds, $drive) = @_;
 
 	my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
@@ -96,7 +98,7 @@ my $check_storage_access_clone = sub {
 
    my $sharedvm = 1;
 
-   PVE::QemuServer::foreach_drive($conf, sub {
+   PVE::QemuConfig->foreach_volume($conf, sub {
 	my ($ds, $drive) = @_;
 
 	my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
@@ -181,7 +183,12 @@ my $create_disks = sub {
 
 	    my $volid;
 	    if ($ds eq 'efidisk0') {
-		($volid, $size) = PVE::QemuServer::create_efidisk($storecfg, $storeid, $vmid, $fmt, $arch);
+		($volid, $size) = PVE::QemuServer::create_efidisk(
+		    $storecfg, $storeid, $vmid, $fmt, $arch, $disk);
+	    } elsif ($ds eq 'tpmstate0') {
+		# swtpm can only use raw volumes, and uses a fixed size
+		$size = PVE::Tools::convert_size(PVE::QemuServer::Drive::TPMSTATE_DISK_SIZE, 'b' => 'kb');
+		$volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, "raw", undef, $size);
 	    } else {
 		$volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $fmt, undef, $size);
 	    }
@@ -216,7 +223,7 @@ my $create_disks = sub {
 	}
     };
 
-    eval { PVE::QemuServer::foreach_drive($settings, $code); };
+    eval { PVE::QemuConfig->foreach_volume($settings, $code); };
 
     # free allocated images on error
     if (my $err = $@) {
@@ -236,6 +243,26 @@ my $create_disks = sub {
     return $vollist;
 };
 
+my $check_cpu_model_access = sub {
+    my ($rpcenv, $authuser, $new, $existing) = @_;
+
+    return if !defined($new->{cpu});
+
+    my $cpu = PVE::JSONSchema::check_format('pve-vm-cpu-conf', $new->{cpu});
+    return if !$cpu || !$cpu->{cputype}; # always allow default
+    my $cputype = $cpu->{cputype};
+
+    if ($existing && $existing->{cpu}) {
+	# changing only other settings doesn't require permissions for CPU model
+	my $existingCpu = PVE::JSONSchema::check_format('pve-vm-cpu-conf', $existing->{cpu});
+	return if $existingCpu->{cputype} eq $cputype;
+    }
+
+    if (PVE::QemuServer::CPUConfig::is_custom_model($cputype)) {
+	$rpcenv->check($authuser, "/nodes", ['Sys.Audit']);
+    }
+};
+
 my $cpuoptions = {
     'cores' => 1,
     'cpu' => 1,
@@ -307,6 +334,42 @@ my $cloudinitoptions = {
     sshkeys => 1,
 };
 
+my $check_vm_create_serial_perm = sub {
+    my ($rpcenv, $authuser, $vmid, $pool, $param) = @_;
+
+    return 1 if $authuser eq 'root@pam';
+
+    foreach my $opt (keys %{$param}) {
+	next if $opt !~ m/^serial\d+$/;
+
+	if ($param->{$opt} eq 'socket') {
+	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.HWType']);
+	} else {
+	    die "only root can set '$opt' config for real devices\n";
+	}
+    }
+
+    return 1;
+};
+
+my $check_vm_create_usb_perm = sub {
+    my ($rpcenv, $authuser, $vmid, $pool, $param) = @_;
+
+    return 1 if $authuser eq 'root@pam';
+
+    foreach my $opt (keys %{$param}) {
+	next if $opt !~ m/^usb\d+$/;
+
+	if ($param->{$opt} =~ m/spice/) {
+	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.HWType']);
+	} else {
+	    die "only root can set '$opt' config for real devices\n";
+	}
+    }
+
+    return 1;
+};
+
 my $check_vm_modify_config_perm = sub {
     my ($rpcenv, $authuser, $vmid, $pool, $key_list) = @_;
 
@@ -336,8 +399,10 @@ my $check_vm_modify_config_perm = sub {
 	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.PowerMgmt']);
 	} elsif ($diskoptions->{$opt}) {
 	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
-	} elsif ($cloudinitoptions->{$opt} || ($opt =~ m/^(?:net|ipconfig)\d+$/)) {
+	} elsif ($opt =~ m/^(?:net|ipconfig)\d+$/) {
 	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']);
+	} elsif ($cloudinitoptions->{$opt}) {
+	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Cloudinit', 'VM.Config.Network'], 1);
 	} elsif ($opt eq 'vmstate') {
 	    # the user needs Disk and PowerMgmt privileges to change the vmstate
 	    # also needs privileges on the storage, that will be checked later
@@ -364,7 +429,7 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     protected => 1, # qemu pid files are only readable by root
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    full => {
@@ -404,7 +469,7 @@ __PACKAGE__->register_method({
 my $parse_restore_archive = sub {
     my ($storecfg, $archive) = @_;
 
-    my ($archive_storeid, $archive_volname) = PVE::Storage::parse_volume_id($archive);
+    my ($archive_storeid, $archive_volname) = PVE::Storage::parse_volume_id($archive, 1);
 
     if (defined($archive_storeid)) {
 	my $scfg =  PVE::Storage::storage_config($storecfg, $archive_storeid);
@@ -437,7 +502,7 @@ __PACKAGE__->register_method({
     protected => 1,
     proxyto => 'node',
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => PVE::QemuServer::json_config_properties(
 	    {
 		node => get_standard_option('pve-node'),
@@ -466,6 +531,12 @@ __PACKAGE__->register_method({
 		    description => "Assign a unique random ethernet address.",
 		    requires => 'archive',
 		},
+		'live-restore' => {
+		    optional => 1,
+		    type => 'boolean',
+		    description => "Start the VM immediately from the backup and restore in background. PBS only.",
+		    requires => 'archive',
+		},
 		pool => {
 		    optional => 1,
 		    type => 'string', format => 'pve-poolid',
@@ -507,6 +578,7 @@ __PACKAGE__->register_method({
 	my $start_after_create = extract_param($param, 'start');
 	my $storage = extract_param($param, 'storage');
 	my $unique = extract_param($param, 'unique');
+	my $live_restore = extract_param($param, 'live-restore');
 
 	if (defined(my $ssh_keys = $param->{sshkeys})) {
 		$ssh_keys = URI::Escape::uri_unescape($ssh_keys);
@@ -543,6 +615,11 @@ __PACKAGE__->register_method({
 
 	    &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, $pool, [ keys %$param]);
 
+	    &$check_vm_create_serial_perm($rpcenv, $authuser, $vmid, $pool, $param);
+	    &$check_vm_create_usb_perm($rpcenv, $authuser, $vmid, $pool, $param);
+
+	    &$check_cpu_model_access($rpcenv, $authuser, $param);
+
 	    foreach my $opt (keys %$param) {
 		if (PVE::QemuServer::is_valid_drivename($opt)) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
@@ -559,8 +636,7 @@ __PACKAGE__->register_method({
 	    raise_param_exc({ archive => "option conflicts with other options ($keystr)"}) if $keystr;
 
 	    if ($archive eq '-') {
-		die "pipe requires cli environment\n"
-		    if $rpcenv->{type} ne 'cli';
+		die "pipe requires cli environment\n" if $rpcenv->{type} ne 'cli';
 		$archive = { type => 'pipe' };
 	    } else {
 		PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $archive);
@@ -574,6 +650,7 @@ __PACKAGE__->register_method({
 	eval { PVE::QemuConfig->create_and_lock_config($vmid, $force) };
 	die "$emsg $@" if $@;
 
+	my $restored_data = 0;
 	my $restorefn = sub {
 	    my $conf = PVE::QemuConfig->load_config($vmid);
 
@@ -587,14 +664,19 @@ __PACKAGE__->register_method({
 		    pool => $pool,
 		    unique => $unique,
 		    bwlimit => $bwlimit,
+		    live => $live_restore,
 		};
 		if ($archive->{type} eq 'file' || $archive->{type} eq 'pipe') {
+		    die "live-restore is only compatible with backup images from a Proxmox Backup Server\n"
+			if $live_restore;
 		    PVE::QemuServer::restore_file_archive($archive->{path} // '-', $vmid, $authuser, $restore_options);
 		} elsif ($archive->{type} eq 'pbs') {
 		    PVE::QemuServer::restore_proxmox_backup_archive($archive->{volid}, $vmid, $authuser, $restore_options);
 		} else {
 		    die "unknown backup archive type\n";
 		}
+		$restored_data = 1;
+
 		my $restored_conf = PVE::QemuConfig->load_config($vmid);
 		# Convert restored VM to template if backup was VM template
 		if (PVE::QemuConfig->is_template($restored_conf)) {
@@ -602,8 +684,6 @@ __PACKAGE__->register_method({
 		    eval { PVE::QemuServer::template_create($vmid, $restored_conf) };
 		    warn $@ if $@;
 		}
-
-		PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
 	    };
 
 	    # ensure no old replication state are exists
@@ -611,7 +691,7 @@ __PACKAGE__->register_method({
 
 	    PVE::QemuConfig->lock_config_full($vmid, 1, $realcmd);
 
-	    if ($start_after_create) {
+	    if ($start_after_create && !$live_restore) {
 		print "Execute autostart\n";
 		eval { PVE::API2::Qemu->vm_start({ vmid => $vmid, node => $node }) };
 		warn $@ if $@;
@@ -630,9 +710,9 @@ __PACKAGE__->register_method({
 		eval {
 		    $vollist = &$create_disks($rpcenv, $authuser, $conf, $arch, $storecfg, $vmid, $pool, $param, $storage);
 
-		    if (!$conf->{bootdisk}) {
-			my $firstdisk = PVE::QemuServer::Drive::resolve_first_disk($conf);
-			$conf->{bootdisk} = $firstdisk if $firstdisk;
+		    if (!$conf->{boot}) {
+			my $devs = PVE::QemuServer::get_default_bootdevices($conf);
+			$conf->{boot} = PVE::QemuServer::print_bootorder($devs);
 		    }
 
 		    # auto generate uuid if user did not specify smbios1 option
@@ -644,6 +724,14 @@ __PACKAGE__->register_method({
 			$conf->{vmgenid} = PVE::QemuServer::generate_uuid();
 		    }
 
+		    my $machine = $conf->{machine};
+		    if (!$machine || $machine =~ m/^(?:pc|q35|virt)$/) {
+			# always pin Windows' machine version on create, they get to easily confused
+			if (PVE::QemuServer::windows_version($conf->{ostype})) {
+			    $conf->{machine} = PVE::QemuServer::windows_get_pinned_machine_version($machine);
+			}
+		    }
+
 		    PVE::QemuConfig->write_config($vmid, $conf);
 
 		};
@@ -677,6 +765,13 @@ __PACKAGE__->register_method({
 		if (my $err = $@) {
 		    eval { PVE::QemuConfig->remove_lock($vmid, 'create') };
 		    warn $@ if $@;
+		    if ($restored_data) {
+			warn "error after data was restored, VM disks should be OK but config may "
+			    ."require adaptions. VM $vmid state is NOT cleaned up.\n";
+		    } else {
+			warn "error before or during data restore, some or all disks were not "
+			    ."completely restored. VM $vmid state is NOT cleaned up.\n";
+		    }
 		    die $err;
 		}
 	    };
@@ -708,7 +803,7 @@ __PACKAGE__->register_method({
 	user => 'all',
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -770,7 +865,7 @@ __PACKAGE__->register_method({
     },
     description => "Read VM RRD statistics (returns PNG)",
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -816,7 +911,7 @@ __PACKAGE__->register_method({
     },
     description => "Read VM RRD statistics",
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -859,7 +954,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
@@ -1072,7 +1167,10 @@ my $update_vm_api  = sub {
 	return if PVE::QemuServer::drive_is_cdrom($drive);
 
 	my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
-	return if $volname eq 'cloudinit';
+	die "cannot add non-managed/pass-through volume to a replicated VM\n"
+	    if !defined($storeid);
+
+	return if defined($volname) && $volname eq 'cloudinit';
 
 	my $format;
 	if ($volid =~ $NEW_DISK_RE) {
@@ -1122,6 +1220,8 @@ my $update_vm_api  = sub {
 	die "checksum missmatch (file change by other user?)\n"
 	    if $digest && $digest ne $conf->{digest};
 
+	&$check_cpu_model_access($rpcenv, $authuser, $param, $conf);
+
 	# FIXME: 'suspended' lock should probabyl be a state or "weak" lock?!
 	if (scalar(@delete) && grep { $_ eq 'vmstate'} @delete) {
 	    if (defined($conf->{lock}) && $conf->{lock} eq 'suspended') {
@@ -1129,6 +1229,7 @@ my $update_vm_api  = sub {
 		push @delete, 'lock'; # this is the real deal to write it out
 	    }
 	    push @delete, 'runningmachine' if $conf->{runningmachine};
+	    push @delete, 'runningcpu' if $conf->{runningcpu};
 	}
 
 	PVE::QemuConfig->check_lock($conf) if !$skiplock;
@@ -1159,6 +1260,24 @@ my $update_vm_api  = sub {
 
 	    my $modified = {}; # record what $option we modify
 
+	    my @bootorder;
+	    if (my $boot = $conf->{boot}) {
+		my $bootcfg = PVE::JSONSchema::parse_property_string('pve-qm-boot', $boot);
+		@bootorder = PVE::Tools::split_list($bootcfg->{order}) if $bootcfg && $bootcfg->{order};
+	    }
+	    my $bootorder_deleted = grep {$_ eq 'bootorder'} @delete;
+
+	    my $check_drive_perms = sub {
+		my ($opt, $val) = @_;
+		my $drive = PVE::QemuServer::parse_drive($opt, $val);
+		# FIXME: cloudinit: CDROM or Disk?
+		if (PVE::QemuServer::drive_is_cdrom($drive)) { # CDROM
+		    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
+		} else {
+		    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
+		}
+	    };
+
 	    foreach my $opt (@delete) {
 		$modified->{$opt} = 1;
 		$conf = PVE::QemuConfig->load_config($vmid); # update/reload
@@ -1173,6 +1292,13 @@ my $update_vm_api  = sub {
 		my $is_pending_val = defined($conf->{pending}->{$opt});
 		delete $conf->{pending}->{$opt};
 
+		# remove from bootorder if necessary
+		if (!$bootorder_deleted && @bootorder && grep {$_ eq $opt} @bootorder) {
+		    @bootorder = grep {$_ ne $opt} @bootorder;
+		    $conf->{pending}->{boot} = PVE::QemuServer::print_bootorder(\@bootorder);
+		    $modified->{boot} = 1;
+		}
+
 		if ($opt =~ m/^unused/) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $val);
 		    PVE::QemuConfig->check_protection($conf, "can't remove unused disk '$drive->{file}'");
@@ -1189,7 +1315,7 @@ my $update_vm_api  = sub {
 		    }
 		} elsif (PVE::QemuServer::is_valid_drivename($opt)) {
 		    PVE::QemuConfig->check_protection($conf, "can't remove drive '$opt'");
-		    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
+		    $check_drive_perms->($opt, $val);
 		    PVE::QemuServer::vmconfig_register_unused_drive($storecfg, $vmid, $conf, PVE::QemuServer::parse_drive($opt, $val))
 			if $is_pending_val;
 		    PVE::QemuConfig->add_to_pending_delete($conf, $opt, $force);
@@ -1224,17 +1350,28 @@ my $update_vm_api  = sub {
 		my $arch = PVE::QemuServer::get_vm_arch($conf);
 
 		if (PVE::QemuServer::is_valid_drivename($opt)) {
-		    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
-		    # FIXME: cloudinit: CDROM or Disk?
-		    if (PVE::QemuServer::drive_is_cdrom($drive)) { # CDROM
-			$rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
-		    } else {
-			$rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
+		    # old drive
+		    if ($conf->{$opt}) {
+			$check_drive_perms->($opt, $conf->{$opt});
 		    }
+
+		    # new drive
+		    $check_drive_perms->($opt, $param->{$opt});
 		    PVE::QemuServer::vmconfig_register_unused_drive($storecfg, $vmid, $conf, PVE::QemuServer::parse_drive($opt, $conf->{pending}->{$opt}))
 			if defined($conf->{pending}->{$opt});
 
 		    &$create_disks($rpcenv, $authuser, $conf->{pending}, $arch, $storecfg, $vmid, undef, {$opt => $param->{$opt}});
+
+		    # default legacy boot order implies all cdroms anyway
+		    if (@bootorder) {
+			# append new CD drives to bootorder to mark them bootable
+			my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
+			if (PVE::QemuServer::drive_is_cdrom($drive, 1) && !grep(/^$opt$/, @bootorder)) {
+			    push @bootorder, $opt;
+			    $conf->{pending}->{boot} = PVE::QemuServer::print_bootorder(\@bootorder);
+			    $modified->{boot} = 1;
+			}
+		    }
 		} elsif ($opt =~ m/^serial\d+/) {
 		    if ((!defined($conf->{$opt}) || $conf->{$opt} eq 'socket') && $param->{$opt} eq 'socket') {
 			$rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.HWType']);
@@ -1251,6 +1388,24 @@ my $update_vm_api  = sub {
 		    $conf->{pending}->{$opt} = $param->{$opt};
 		} else {
 		    $conf->{pending}->{$opt} = $param->{$opt};
+
+		    if ($opt eq 'boot') {
+			my $new_bootcfg = PVE::JSONSchema::parse_property_string('pve-qm-boot', $param->{$opt});
+			if ($new_bootcfg->{order}) {
+			    my @devs = PVE::Tools::split_list($new_bootcfg->{order});
+			    for my $dev (@devs) {
+				my $exists = $conf->{$dev} || $conf->{pending}->{$dev};
+				my $deleted = grep {$_ eq $dev} @delete;
+				die "invalid bootorder: device '$dev' does not exist'\n"
+				    if !$exists || $deleted;
+			    }
+
+			    # remove legacy boot order settings if new one set
+			    $conf->{pending}->{$opt} = PVE::QemuServer::print_bootorder(\@devs);
+			    PVE::QemuConfig->add_to_pending_delete($conf, "bootdisk")
+				if $conf->{bootdisk};
+			}
+		    }
 		}
 		PVE::QemuConfig->remove_from_pending_delete($conf, $opt);
 		PVE::QemuConfig->write_config($vmid, $conf);
@@ -1273,7 +1428,7 @@ my $update_vm_api  = sub {
 	    if ($running) {
 		PVE::QemuServer::vmconfig_hotplug_pending($vmid, $conf, $storecfg, $modified, $errors);
 	    } else {
-		PVE::QemuServer::vmconfig_apply_pending($vmid, $conf, $storecfg, $running, $errors);
+		PVE::QemuServer::vmconfig_apply_pending($vmid, $conf, $storecfg, $errors);
 	    }
 	    raise_param_exc($errors) if scalar(keys %$errors);
 
@@ -1282,7 +1437,7 @@ my $update_vm_api  = sub {
 
 	if ($sync) {
 	    &$worker();
-	    return undef;
+	    return;
 	} else {
 	    my $upid = $rpcenv->fork_worker('qmconfig', $vmid, $authuser, $worker);
 
@@ -1304,7 +1459,7 @@ my $update_vm_api  = sub {
 
 		if (!$running) {
 		    my $status = PVE::Tools::upid_read_status($upid);
-		    return undef if $status eq 'OK';
+		    return if !PVE::Tools::upid_status_is_error($status);
 		    die $status;
 		}
 	    }
@@ -1324,6 +1479,7 @@ my $vm_config_perm_list = [
 	    'VM.Config.Network',
 	    'VM.Config.HWType',
 	    'VM.Config.Options',
+	    'VM.Config.Cloudinit',
     ];
 
 __PACKAGE__->register_method({
@@ -1337,7 +1493,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => PVE::QemuServer::json_config_properties(
 	    {
 		node => get_standard_option('pve-node'),
@@ -1392,7 +1548,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => PVE::QemuServer::json_config_properties(
 	    {
 		node => get_standard_option('pve-node'),
@@ -1426,7 +1582,7 @@ __PACKAGE__->register_method({
     code => sub {
 	my ($param) = @_;
 	&$update_vm_api($param, 1);
-	return undef;
+	return;
     }
 });
 
@@ -1436,21 +1592,29 @@ __PACKAGE__->register_method({
     method => 'DELETE',
     protected => 1,
     proxyto => 'node',
-    description => "Destroy the vm (also delete all used/owned volumes).",
+    description => "Destroy the VM and  all used/owned volumes. Removes any VM specific permissions"
+	." and firewall rules",
     permissions => {
 	check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid_stopped }),
 	    skiplock => get_standard_option('skiplock'),
 	    purge => {
 		type => 'boolean',
-		description => "Remove vmid from backup cron jobs.",
+		description => "Remove VMID from configurations, like backup & replication jobs and HA.",
 		optional => 1,
 	    },
+	    'destroy-unreferenced-disks' => {
+		type => 'boolean',
+		description => "If set, destroy additionally all disks not referenced in the config"
+		 ." but with a matching VMID from all enabled storages.",
+		optional => 1,
+		default => 0,
+	    },
 	},
     },
     returns => {
@@ -1467,34 +1631,47 @@ __PACKAGE__->register_method({
 	raise_param_exc({ skiplock => "Only root may use this option." })
 	    if $skiplock && $authuser ne 'root@pam';
 
-	# test if VM exists
-	my $conf = PVE::QemuConfig->load_config($vmid);
-	my $storecfg = PVE::Storage::config();
-	PVE::QemuConfig->check_protection($conf, "can't remove VM $vmid");
+	my $early_checks = sub {
+	    # test if VM exists
+	    my $conf = PVE::QemuConfig->load_config($vmid);
+	    PVE::QemuConfig->check_protection($conf, "can't remove VM $vmid");
 
-	my $ha_managed = PVE::HA::Config::service_is_configured("vm:$vmid");
+	    my $ha_managed = PVE::HA::Config::service_is_configured("vm:$vmid");
 
-	if (!$param->{purge}) {
-	    die "unable to remove VM $vmid - used in HA resources and purge parameter not set.\n"
-		if $ha_managed;
-	    # don't allow destroy if with replication jobs but no purge param
-	    my $repl_conf = PVE::ReplicationConfig->new();
-	    $repl_conf->check_for_existing_jobs($vmid);
-	}
+	    if (!$param->{purge}) {
+		die "unable to remove VM $vmid - used in HA resources and purge parameter not set.\n"
+		    if $ha_managed;
+		# don't allow destroy if with replication jobs but no purge param
+		my $repl_conf = PVE::ReplicationConfig->new();
+		$repl_conf->check_for_existing_jobs($vmid);
+	    }
+
+	    die "VM $vmid is running - destroy failed\n"
+		if PVE::QemuServer::check_running($vmid);
+
+	    return $ha_managed;
+	};
 
-	# early tests (repeat after locking)
-	die "VM $vmid is running - destroy failed\n"
-	    if PVE::QemuServer::check_running($vmid);
+	$early_checks->();
 
 	my $realcmd = sub {
 	    my $upid = shift;
 
+	    my $storecfg = PVE::Storage::config();
+
 	    syslog('info', "destroy VM $vmid: $upid\n");
 	    PVE::QemuConfig->lock_config($vmid, sub {
-		die "VM $vmid is running - destroy failed\n"
-		    if (PVE::QemuServer::check_running($vmid));
+		# repeat, config might have changed
+		my $ha_managed = $early_checks->();
+
+		my $purge_unreferenced = $param->{'destroy-unreferenced-disks'};
 
-		PVE::QemuServer::destroy_vm($storecfg, $vmid, $skiplock, { lock => 'destroyed' });
+		PVE::QemuServer::destroy_vm(
+		    $storecfg,
+		    $vmid,
+		    $skiplock, { lock => 'destroyed' },
+		    $purge_unreferenced,
+		);
 
 		PVE::AccessControl::remove_vm_access($vmid);
 		PVE::Firewall::remove_vmfw_conf($vmid);
@@ -1528,7 +1705,7 @@ __PACKAGE__->register_method({
 	check => [ 'perm', '/vms/{vmid}', ['VM.Config.Disk']],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
@@ -1551,9 +1728,26 @@ __PACKAGE__->register_method({
 
 	__PACKAGE__->update_vm($param);
 
-	return undef;
+	return;
     }});
 
+# uses good entropy, each char is limited to 6 bit to get printable chars simply
+my $gen_rand_chars = sub {
+    my ($length) = @_;
+
+    die "invalid length $length" if $length < 1;
+
+    my $min = ord('!'); # first printable ascii
+
+    my $rand_bytes = Crypt::OpenSSL::Random::random_bytes($length);
+    die "failed to generate random bytes!\n"
+      if !$rand_bytes;
+
+    my $str = join('', map { chr((ord($_) & 0x3F) + $min) } split('', $rand_bytes));
+
+    return $str;
+};
+
 my $sslcert;
 
 __PACKAGE__->register_method({
@@ -1566,7 +1760,7 @@ __PACKAGE__->register_method({
     },
     description => "Creates a TCP VNC proxy connections.",
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -1575,13 +1769,25 @@ __PACKAGE__->register_method({
 		type => 'boolean',
 		description => "starts websockify instead of vncproxy",
 	    },
+	    'generate-password' => {
+		optional => 1,
+		type => 'boolean',
+		default => 0,
+		description => "Generates a random password to be used as ticket instead of the API ticket.",
+	    },
 	},
     },
     returns => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    user => { type => 'string' },
 	    ticket => { type => 'string' },
+	    password => {
+		optional => 1,
+		description => "Returned if requested with 'generate-password' param."
+		    ." Consists of printable ASCII characters ('!' .. '~').",
+		type => 'string',
+	    },
 	    cert => { type => 'string' },
 	    port => { type => 'integer' },
 	    upid => { type => 'string' },
@@ -1599,11 +1805,20 @@ __PACKAGE__->register_method({
 	my $websocket = $param->{websocket};
 
 	my $conf = PVE::QemuConfig->load_config($vmid, $node); # check if VM exists
-	my $use_serial = ($conf->{vga} && ($conf->{vga} =~ m/^serial\d+$/));
+
+	my $serial;
+	if ($conf->{vga}) {
+	    my $vga = PVE::QemuServer::parse_vga($conf->{vga});
+	    $serial = $vga->{type} if $vga->{type} =~ m/^serial\d+$/;
+	}
 
 	my $authpath = "/vms/$vmid";
 
 	my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath);
+	my $password = $ticket;
+	if ($param->{'generate-password'}) {
+	    $password = $gen_rand_chars->(8);
+	}
 
 	$sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192)
 	    if !$sslcert;
@@ -1615,7 +1830,7 @@ __PACKAGE__->register_method({
 	    (undef, $family) = PVE::Cluster::remote_node_ip($node);
 	    my $sshinfo = PVE::SSHInfo::get_ssh_info($node);
 	    # NOTE: kvm VNC traffic is already TLS encrypted or is known unsecure
-	    $remcmd = PVE::SSHInfo::ssh_info_to_command($sshinfo, $use_serial ? '-t' : '-T');
+	    $remcmd = PVE::SSHInfo::ssh_info_to_command($sshinfo, defined($serial) ? '-t' : '-T');
 	} else {
 	    $family = PVE::Tools::get_host_address_family($node);
 	}
@@ -1631,16 +1846,16 @@ __PACKAGE__->register_method({
 
 	    my $cmd;
 
-	    if ($use_serial) {
+	    if (defined($serial)) {
 
-		my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga}, '-escape', '0' ];
+		my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $serial, '-escape', '0' ];
 
 		$cmd = ['/usr/bin/vncterm', '-rfbport', $port,
 			'-timeout', $timeout, '-authpath', $authpath,
 			'-perm', 'Sys.Console'];
 
 		if ($param->{websocket}) {
-		    $ENV{PVE_VNC_TICKET} = $ticket; # pass ticket to vncterm
+		    $ENV{PVE_VNC_TICKET} = $password; # pass ticket to vncterm
 		    push @$cmd, '-notls', '-listen', 'localhost';
 		}
 
@@ -1650,7 +1865,7 @@ __PACKAGE__->register_method({
 
 	    } else {
 
-		$ENV{LC_PVE_TICKET} = $ticket if $websocket; # set ticket with "qm vncproxy"
+		$ENV{LC_PVE_TICKET} = $password if $websocket; # set ticket with "qm vncproxy"
 
 		$cmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
 
@@ -1660,7 +1875,7 @@ __PACKAGE__->register_method({
 		    LocalPort => $port,
 		    Proto => 'tcp',
 		    GetAddrInfoFlags => 0,
-		    ) or die "failed to create socket: $!\n";
+		) or die "failed to create socket: $!\n";
 		# Inside the worker we shouldn't have any previous alarms
 		# running anyway...:
 		alarm(0);
@@ -1685,13 +1900,16 @@ __PACKAGE__->register_method({
 
 	PVE::Tools::wait_for_vnc_port($port);
 
-	return {
+	my $res = {
 	    user => $authuser,
 	    ticket => $ticket,
 	    port => $port,
 	    upid => $upid,
 	    cert => $sslcert,
 	};
+	$res->{password} = $password if $param->{'generate-password'};
+
+	return $res;
     }});
 
 __PACKAGE__->register_method({
@@ -1739,8 +1957,9 @@ __PACKAGE__->register_method({
 	my $conf = PVE::QemuConfig->load_config($vmid, $node); # check if VM exists
 
 	if (!defined($serial)) {
-	    if ($conf->{vga} && $conf->{vga} =~ m/^serial\d+$/) {
-		$serial = $conf->{vga};
+	    if ($conf->{vga}) {
+		my $vga = PVE::QemuServer::parse_vga($conf->{vga});
+		$serial = $vga->{type} if $vga->{type} =~ m/^serial\d+$/;
 	    }
 	}
 
@@ -1799,7 +2018,7 @@ __PACKAGE__->register_method({
     },
     description => "Opens a weksocket for VNC traffic.",
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -1858,7 +2077,7 @@ __PACKAGE__->register_method({
     },
     description => "Returns a SPICE configuration to connect to the VM.",
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -1902,7 +2121,7 @@ __PACKAGE__->register_method({
 	user => 'all',
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -1948,7 +2167,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -1986,7 +2205,7 @@ __PACKAGE__->register_method({
 	$status->{ha} = PVE::HA::Config::get_service_status("vm:$param->{vmid}");
 
 	$status->{spice} = 1 if PVE::QemuServer::vga_conf_has_spice($conf->{vga});
-	$status->{agent} = 1 if (PVE::QemuServer::parse_guest_agent($conf)->{enabled});
+	$status->{agent} = 1 if PVE::QemuServer::get_qga_key($conf, 'enabled');
 
 	return $status;
     }});
@@ -2002,7 +2221,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2024,11 +2243,12 @@ __PACKAGE__->register_method({
 		optional => 1,
 	    },
 	    machine => get_standard_option('pve-qemu-machine'),
-	    targetstorage => {
-		description => "Target storage for the migration. (Can be '1' to use the same storage id as on the source node.)",
+	    'force-cpu' => {
+		description => "Override QEMU's -cpu argument with the given string.",
 		type => 'string',
-		optional => 1
+		optional => 1,
 	    },
+	    targetstorage => get_standard_option('pve-targetstorage'),
 	    timeout => {
 		description => "Wait maximal timeout seconds.",
 		type => 'integer',
@@ -2052,6 +2272,7 @@ __PACKAGE__->register_method({
 	my $timeout = extract_param($param, 'timeout');
 
 	my $machine = extract_param($param, 'machine');
+	my $force_cpu = extract_param($param, 'force-cpu');
 
 	my $get_root_param = sub {
 	    my $value = extract_param($param, $_[0]);
@@ -2067,12 +2288,20 @@ __PACKAGE__->register_method({
 	my $migration_network = $get_root_param->('migration_network');
 	my $targetstorage = $get_root_param->('targetstorage');
 
-	raise_param_exc({ targetstorage => "targetstorage can only by used with migratedfrom." })
-	    if $targetstorage && !$migratedfrom;
+	my $storagemap;
+
+	if ($targetstorage) {
+	    raise_param_exc({ targetstorage => "targetstorage can only by used with migratedfrom." })
+		if !$migratedfrom;
+	    $storagemap = eval { PVE::JSONSchema::parse_idmap($targetstorage, 'pve-storage-id') };
+	    raise_param_exc({ targetstorage => "failed to parse storage map: $@" })
+		if $@;
+	}
 
 	# read spice ticket from STDIN
 	my $spice_ticket;
 	my $nbd_protocol_version = 0;
+	my $replicated_volumes = {};
 	if ($stateuri && ($stateuri eq 'tcp' || $stateuri eq 'unix') && $migratedfrom && ($rpcenv->{type} eq 'cli')) {
 	    while (defined(my $line = <STDIN>)) {
 		chomp $line;
@@ -2080,6 +2309,8 @@ __PACKAGE__->register_method({
 		    $spice_ticket = $1;
 		} elsif ($line =~ m/^nbd_protocol_version: (\d+)$/) {
 		    $nbd_protocol_version = $1;
+		} elsif ($line =~ m/^replicated_volume: (.*)$/) {
+		    $replicated_volumes->{$1} = 1;
 		} else {
 		    # fallback for old source node
 		    $spice_ticket = $line;
@@ -2111,9 +2342,25 @@ __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, $targetstorage, $timeout,
-					  $nbd_protocol_version);
+		my $migrate_opts = {
+		    migratedfrom => $migratedfrom,
+		    spice_ticket => $spice_ticket,
+		    network => $migration_network,
+		    type => $migration_type,
+		    storagemap => $storagemap,
+		    nbd_proto_version => $nbd_protocol_version,
+		    replicated_volumes => $replicated_volumes,
+		};
+
+		my $params = {
+		    statefile => $stateuri,
+		    skiplock => $skiplock,
+		    forcemachine => $machine,
+		    timeout => $timeout,
+		    forcecpu => $force_cpu,
+		};
+
+		PVE::QemuServer::vm_start($storecfg, $vmid, $params, $migrate_opts);
 		return;
 	    };
 
@@ -2133,7 +2380,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2221,7 +2468,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2272,7 +2519,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2328,13 +2575,7 @@ __PACKAGE__->register_method({
 	#
 	# checking the qmp status here to get feedback to the gui/cli/api
 	# and the status query should not take too long
-	my $qmpstatus = eval {
-	    PVE::QemuConfig::assert_config_exists_on_node($vmid);
-	    mon_cmd($vmid, "query-status");
-	};
-	my $err = $@ if $@;
-
-	if (!$err && $qmpstatus->{status} eq "paused") {
+	if (PVE::QemuServer::vm_is_paused($vmid)) {
 	    if ($param->{forceStop}) {
 		warn "VM is paused - stop instead of shutdown\n";
 		$shutdown = 0;
@@ -2410,15 +2651,7 @@ __PACKAGE__->register_method({
 	my $node = extract_param($param, 'node');
 	my $vmid = extract_param($param, 'vmid');
 
-	my $qmpstatus = eval {
-	    PVE::QemuConfig::assert_config_exists_on_node($vmid);
-	    mon_cmd($vmid, "query-status");
-	};
-	my $err = $@ if $@;
-
-	if (!$err && $qmpstatus->{status} eq "paused") {
-	    die "VM is paused - cannot shutdown\n";
-	}
+	die "VM is paused - cannot shutdown\n" if PVE::QemuServer::vm_is_paused($vmid);
 
 	die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
 
@@ -2447,7 +2680,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2531,7 +2764,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2560,6 +2793,8 @@ __PACKAGE__->register_method({
 	    if $skiplock && $authuser ne 'root@pam';
 
 	my $nocheck = extract_param($param, 'nocheck');
+	raise_param_exc({ nocheck => "Only root may use this option." })
+	    if $nocheck && $authuser ne 'root@pam';
 
 	my $to_disk_suspended;
 	eval {
@@ -2581,7 +2816,7 @@ __PACKAGE__->register_method({
 		PVE::QemuServer::vm_resume($vmid, $skiplock, $nocheck);
 	    } else {
 		my $storecfg = PVE::Storage::config();
-		PVE::QemuServer::vm_start($storecfg, $vmid, undef, $skiplock);
+		PVE::QemuServer::vm_start($storecfg, $vmid, { skiplock => $skiplock });
 	    }
 
 	    return;
@@ -2601,7 +2836,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid',
@@ -2645,7 +2880,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -2721,7 +2956,7 @@ __PACKAGE__->register_method({
 	]
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
@@ -2810,7 +3045,7 @@ __PACKAGE__->register_method({
 	    PVE::Storage::storage_check_enabled($storecfg, $storage);
 	    if ($target) {
 		# check if storage is available on target node
-		PVE::Storage::storage_check_node($storecfg, $storage, $target);
+		PVE::Storage::storage_check_enabled($storecfg, $storage, $target);
 		# clone only works if target storage is shared
 		my $scfg = PVE::Storage::storage_config($storecfg, $storage);
 		die "can't clone to non-shared storage '$storage'\n" if !$scfg->{shared};
@@ -2821,9 +3056,6 @@ __PACKAGE__->register_method({
 
 	my $running = PVE::QemuServer::check_running($vmid) || 0;
 
-	# exclusive lock if VM is running - else shared lock is enough;
-	my $shared_lock = $running ? 0 : 1;
-
 	my $clonefn = sub {
 	    # do all tests after lock but before forking worker - if possible
 
@@ -2892,6 +3124,7 @@ __PACKAGE__->register_method({
 				if !PVE::Storage::volume_has_feature($storecfg, 'clone', $drive->{file}, $snapname, $running);
 			}
 			$drives->{$opt} = $drive;
+			next if PVE::QemuServer::drive_is_cloudinit($drive);
 			push @$vollist, $drive->{file};
 		    }
 		} else {
@@ -2944,19 +3177,34 @@ __PACKAGE__->register_method({
 		    my $total_jobs = scalar(keys %{$drives});
 		    my $i = 1;
 
-		    foreach my $opt (keys %$drives) {
+		    foreach my $opt (sort keys %$drives) {
 			my $drive = $drives->{$opt};
 			my $skipcomplete = ($total_jobs != $i); # finish after last drive
-			my $completion = $skipcomplete ? 'skip' : 'wait';
+			my $completion = $skipcomplete ? 'skip' : 'complete';
 
 			my $src_sid = PVE::Storage::parse_volume_id($drive->{file});
 			my $storage_list = [ $src_sid ];
 			push @$storage_list, $storage if defined($storage);
 			my $clonelimit = PVE::Storage::get_bandwidth_limit('clone', $storage_list, $bwlimit);
 
-			my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
-								   $newid, $storage, $format, $fullclone->{$opt}, $newvollist,
-								   $jobs, $completion, $oldconf->{agent}, $clonelimit);
+			my $newdrive = PVE::QemuServer::clone_disk(
+			    $storecfg,
+			    $vmid,
+			    $running,
+			    $opt,
+			    $drive,
+			    $snapname,
+			    $newid,
+			    $storage,
+			    $format,
+			    $fullclone->{$opt},
+			    $newvollist,
+			    $jobs,
+			    $completion,
+			    $oldconf->{agent},
+			    $clonelimit,
+			    $oldconf
+			);
 
 			$newconf->{$opt} = PVE::QemuServer::print_drive($newdrive);
 
@@ -3011,11 +3259,17 @@ __PACKAGE__->register_method({
 	    return $rpcenv->fork_worker('qmclone', $vmid, $authuser, $realcmd);
 	};
 
-	return PVE::QemuConfig->lock_config_mode($vmid, 1, $shared_lock, sub {
-	    # Aquire exclusive lock lock for $newid
+	# Aquire exclusive lock lock for $newid
+	my $lock_target_vm = sub {
 	    return PVE::QemuConfig->lock_config_full($newid, 1, $clonefn);
-	});
+	};
 
+	# exclusive lock if VM is running - else shared lock is enough;
+	if ($running) {
+	    return PVE::QemuConfig->lock_config_full($vmid, 1, $lock_target_vm);
+	} else {
+	    return PVE::QemuConfig->lock_config_shared($vmid, 1, $lock_target_vm);
+	}
     }});
 
 __PACKAGE__->register_method({
@@ -3033,7 +3287,7 @@ __PACKAGE__->register_method({
 	    ],
     },
     parameters => {
-        additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
@@ -3142,9 +3396,24 @@ __PACKAGE__->register_method({
 		    my $bwlimit = extract_param($param, 'bwlimit');
 		    my $movelimit = PVE::Storage::get_bandwidth_limit('move', [$oldstoreid, $storeid], $bwlimit);
 
-		    my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $disk, $drive, undef,
-							       $vmid, $storeid, $format, 1, $newvollist, undef, undef, undef, $movelimit);
-
+		    my $newdrive = PVE::QemuServer::clone_disk(
+			$storecfg,
+			$vmid,
+			$running,
+			$disk,
+			$drive,
+			undef,
+			$vmid,
+			$storeid,
+			$format,
+			1,
+			$newvollist,
+			undef,
+			undef,
+			undef,
+			$movelimit,
+			$conf,
+		    );
 		    $conf->{$disk} = PVE::QemuServer::print_drive($newdrive);
 
 		    PVE::QemuConfig->add_unused_volume($conf, $old_volid) if !$param->{delete};
@@ -3155,7 +3424,7 @@ __PACKAGE__->register_method({
 
 		    PVE::QemuConfig->write_config($vmid, $conf);
 
-		    my $do_trim = PVE::QemuServer::parse_guest_agent($conf)->{fstrim_cloned_disks};
+		    my $do_trim = PVE::QemuServer::get_qga_key($conf, 'fstrim_cloned_disks');
 		    if ($running && $do_trim && PVE::QemuServer::qga_check_running($vmid)) {
 			eval { mon_cmd($vmid, "guest-fstrim") };
 		    }
@@ -3333,7 +3602,7 @@ __PACKAGE__->register_method({
 	check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
@@ -3367,9 +3636,7 @@ __PACKAGE__->register_method({
 		description => "Enable live storage migration for local disk",
 		optional => 1,
 	    },
-            targetstorage => get_standard_option('pve-storage-id', {
-		description => "Default target storage.",
-		optional => 1,
+            targetstorage => get_standard_option('pve-targetstorage', {
 		completion => \&PVE::QemuServer::complete_migration_storage,
             }),
 	    bwlimit => {
@@ -3423,18 +3690,49 @@ __PACKAGE__->register_method({
 
 	if (PVE::QemuServer::check_running($vmid)) {
 	    die "can't migrate running VM without --online\n" if !$param->{online};
+
+	    my $repl_conf = PVE::ReplicationConfig->new();
+	    my $is_replicated = $repl_conf->check_for_existing_jobs($vmid, 1);
+	    my $is_replicated_to_target = defined($repl_conf->find_local_replication_job($vmid, $target));
+	    if (!$param->{force} && $is_replicated && !$is_replicated_to_target) {
+		die "Cannot live-migrate replicated VM to node '$target' - not a replication " .
+		    "target. Use 'force' to override.\n";
+	    }
 	} else {
 	    warn "VM isn't running. Doing offline migration instead.\n" if $param->{online};
 	    $param->{online} = 0;
 	}
 
-	raise_param_exc({ targetstorage => "Live storage migration can only be done online." })
-	    if !$param->{online} && $param->{targetstorage};
-
 	my $storecfg = PVE::Storage::config();
 
-	if( $param->{targetstorage}) {
-	    PVE::Storage::storage_check_node($storecfg, $param->{targetstorage}, $target);
+	if (my $targetstorage = $param->{targetstorage}) {
+	    my $check_storage = sub {
+		my ($target_sid) = @_;
+		PVE::Storage::storage_check_enabled($storecfg, $target_sid, $target);
+		$rpcenv->check($authuser, "/storage/$target_sid", ['Datastore.AllocateSpace']);
+		my $scfg = PVE::Storage::storage_config($storecfg, $target_sid);
+		raise_param_exc({ targetstorage => "storage '$target_sid' does not support vm images"})
+		    if !$scfg->{content}->{images};
+	    };
+
+	    my $storagemap = eval { PVE::JSONSchema::parse_idmap($targetstorage, 'pve-storage-id') };
+	    raise_param_exc({ targetstorage => "failed to parse storage map: $@" })
+		if $@;
+
+	    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk'])
+		if !defined($storagemap->{identity});
+
+	    foreach my $target_sid (values %{$storagemap->{entries}}) {
+		$check_storage->($target_sid);
+	    }
+
+	    $check_storage->($storagemap->{default})
+		if $storagemap->{default};
+
+	    PVE::QemuServer::check_storage_availability($storecfg, $conf, $target)
+		if $storagemap->{identity};
+
+	    $param->{storagemap} = $storagemap;
         } else {
 	    PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
 	}
@@ -3480,7 +3778,7 @@ __PACKAGE__->register_method({
         check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid'),
@@ -3530,8 +3828,8 @@ __PACKAGE__->register_method({
         check => ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
     },
     parameters => {
-        additionalProperties => 0,
-        properties => {
+	additionalProperties => 0,
+	properties => {
 	    node => get_standard_option('pve-node'),
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
 	    skiplock => get_standard_option('skiplock'),
@@ -3634,15 +3932,14 @@ __PACKAGE__->register_method({
 
 	    PVE::QemuServer::qemu_block_resize($vmid, "drive-$disk", $storecfg, $volid, $newsize);
 
-	    my $effective_size = eval { PVE::Storage::volume_size_info($storecfg, $volid, 3); };
-	    $drive->{size} = $effective_size // $newsize;
+	    $drive->{size} = $newsize;
 	    $conf->{$disk} = PVE::QemuServer::print_drive($drive);
 
 	    PVE::QemuConfig->write_config($vmid, $conf);
 	};
 
         PVE::QemuConfig->lock_config($vmid, $updatefn);
-        return undef;
+        return;
     }});
 
 __PACKAGE__->register_method({
@@ -3656,7 +3953,7 @@ __PACKAGE__->register_method({
     proxyto => 'node',
     protected => 1, # qemu pid files are only readable by root
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
 	    node => get_standard_option('pve-node'),
@@ -3801,7 +4098,7 @@ __PACKAGE__->register_method({
 	user => 'all',
     },
     parameters => {
-    	additionalProperties => 0,
+	additionalProperties => 0,
 	properties => {
 	    vmid => get_standard_option('pve-vmid'),
 	    node => get_standard_option('pve-node'),
@@ -3862,7 +4159,7 @@ __PACKAGE__->register_method({
 
 	my $snapname = extract_param($param, 'snapname');
 
-	return undef if !defined($param->{description});
+	return if !defined($param->{description});
 
 	my $updatefn =  sub {
 
@@ -3881,7 +4178,7 @@ __PACKAGE__->register_method({
 
 	PVE::QemuConfig->lock_config($vmid, $updatefn);
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method({
@@ -4043,7 +4340,10 @@ __PACKAGE__->register_method({
 
 	},
     },
-    returns => { type => 'null'},
+    returns => {
+	type => 'string',
+	description => "the task ID.",
+    },
     code => sub {
 	my ($param) = @_;
 
@@ -4057,8 +4357,7 @@ __PACKAGE__->register_method({
 
 	my $disk = extract_param($param, 'disk');
 
-	my $updatefn =  sub {
-
+	my $load_and_check = sub {
 	    my $conf = PVE::QemuConfig->load_config($vmid);
 
 	    PVE::QemuConfig->check_lock($conf);
@@ -4072,18 +4371,23 @@ __PACKAGE__->register_method({
 	    die "you can't convert a VM to template if VM is running\n"
 		if PVE::QemuServer::check_running($vmid);
 
-	    my $realcmd = sub {
-		PVE::QemuServer::template_create($vmid, $conf, $disk);
-	    };
+	    return $conf;
+	};
 
-	    $conf->{template} = 1;
-	    PVE::QemuConfig->write_config($vmid, $conf);
+	$load_and_check->();
+
+	my $realcmd = sub {
+	    PVE::QemuConfig->lock_config($vmid, sub {
+		my $conf = $load_and_check->();
+
+		$conf->{template} = 1;
+		PVE::QemuConfig->write_config($vmid, $conf);
 
-	    return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
+		PVE::QemuServer::template_create($vmid, $conf, $disk);
+	    });
 	};
 
-	PVE::QemuConfig->lock_config($vmid, $updatefn);
-	return undef;
+	return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
     }});
 
 __PACKAGE__->register_method({