X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FAPI2%2FQemu.pm;h=8bb68a4879bde01ecc363dade87551da00016627;hb=8989736707634628a43de8e2737e858518513d27;hp=83b3c19bef01f520168ba522383185b22370342d;hpb=335af808a431fbab21381c523c6df5850d4b19c1;p=qemu-server.git

diff --git a/PVE/API2/Qemu.pm b/PVE/API2/Qemu.pm
index 83b3c19..8bb68a4 100644
--- a/PVE/API2/Qemu.pm
+++ b/PVE/API2/Qemu.pm
@@ -13,6 +13,7 @@ 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::QemuConfig;
 use PVE::QemuServer;
 use PVE::QemuMigrate;
 use PVE::RPCEnvironment;
@@ -21,6 +22,7 @@ use PVE::INotify;
 use PVE::Network;
 use PVE::Firewall;
 use PVE::API2::Firewall::VM;
+use PVE::HA::Env::PVE2;
 use PVE::HA::Config;
 
 use Data::Dumper; # fixme: remove
@@ -181,14 +183,12 @@ my $check_vm_modify_config_perm = sub {
 
     foreach my $opt (@$key_list) {
 	# disk checks need to be done somewhere else
-	next if PVE::QemuServer::valid_drivename($opt);
+	next if PVE::QemuServer::is_valid_drivename($opt);
 
 	if ($opt eq 'sockets' || $opt eq 'cores' ||
 	    $opt eq 'cpu' || $opt eq 'smp' || $opt eq 'vcpus' ||
 	    $opt eq 'cpulimit' || $opt eq 'cpuunits') {
 	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.CPU']);
-	} elsif ($opt eq 'boot' || $opt eq 'bootdisk') {
-	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
 	} elsif ($opt eq 'memory' || $opt eq 'balloon' || $opt eq 'shares') {
 	    $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Memory']);
 	} elsif ($opt eq 'args' || $opt eq 'lock') {
@@ -221,6 +221,11 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
+	    full => {
+		type => 'boolean',
+		optional => 1,
+		description => "Determine the full status of active VMs.",
+	    },
 	},
     },
     returns => {
@@ -237,7 +242,7 @@ __PACKAGE__->register_method({
 	my $rpcenv = PVE::RPCEnvironment::get();
 	my $authuser = $rpcenv->get_user();
 
-	my $vmstatus = PVE::QemuServer::vmstatus();
+	my $vmstatus = PVE::QemuServer::vmstatus(undef, $param->{full});
 
 	my $res = [];
 	foreach my $vmid (keys %$vmstatus) {
@@ -327,7 +332,7 @@ __PACKAGE__->register_method({
 
 	my $pool = extract_param($param, 'pool');
 
-	my $filename = PVE::QemuServer::config_file($vmid);
+	my $filename = PVE::QemuConfig->config_file($vmid);
 
 	my $storecfg = PVE::Storage::config();
 
@@ -359,7 +364,7 @@ __PACKAGE__->register_method({
 	    &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, $pool, [ keys %$param]);
 
 	    foreach my $opt (keys %$param) {
-		if (PVE::QemuServer::valid_drivename($opt)) {
+		if (PVE::QemuServer::is_valid_drivename($opt)) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 		    raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
 
@@ -383,14 +388,22 @@ __PACKAGE__->register_method({
 	}
 
 	my $restorefn = sub {
+	    my $vmlist = PVE::Cluster::get_vmlist();
+	    if ($vmlist->{ids}->{$vmid}) {
+		my $current_node = $vmlist->{ids}->{$vmid}->{node};
+		if ($current_node eq $node) {
+		    my $conf = PVE::QemuConfig->load_config($vmid);
 
-	    # fixme: this test does not work if VM exists on other node!
-	    if (-f $filename) {
-		die "unable to restore vm $vmid: config file already exists\n"
-		    if !$force;
+		    PVE::QemuConfig->check_protection($conf, "unable to restore VM $vmid");
 
-		die "unable to restore vm $vmid: vm is running\n"
-		    if PVE::QemuServer::check_running($vmid);
+		    die "unable to restore vm $vmid - config file already exists\n"
+			if !$force;
+
+		    die "unable to restore vm $vmid - vm is running\n"
+			if PVE::QemuServer::check_running($vmid);
+		} else {
+		    die "unable to restore vm $vmid - already existing on cluster node '$current_node'\n";
+		}
 	    }
 
 	    my $realcmd = sub {
@@ -408,8 +421,7 @@ __PACKAGE__->register_method({
 	my $createfn = sub {
 
 	    # test after locking
-	    die "unable to create vm $vmid: config file already exists\n"
-		if -f $filename;
+	    PVE::Cluster::check_vmid_unused($vmid);
 
 	    my $realcmd = sub {
 
@@ -422,7 +434,7 @@ __PACKAGE__->register_method({
 		    $vollist = &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $param, $storage);
 
 		    # try to be smart about bootdisk
-		    my @disks = PVE::QemuServer::disknames();
+		    my @disks = PVE::QemuServer::valid_drive_names();
 		    my $firstdisk;
 		    foreach my $ds (reverse @disks) {
 			next if !$conf->{$ds};
@@ -443,7 +455,7 @@ __PACKAGE__->register_method({
 			$conf->{smbios1} = "uuid=$uuid_str";
 		    }
 
-		    PVE::QemuServer::update_config_nolock($vmid, $conf);
+		    PVE::QemuConfig->write_config($vmid, $conf);
 
 		};
 		my $err = $@;
@@ -462,7 +474,7 @@ __PACKAGE__->register_method({
 	    return $rpcenv->fork_worker('qmcreate', $vmid, $authuser, $realcmd);
 	};
 
-	return PVE::QemuServer::lock_config_full($vmid, 1, $archive ? $restorefn : $createfn);
+	return PVE::QemuConfig->lock_config_full($vmid, 1, $archive ? $restorefn : $createfn);
     }});
 
 __PACKAGE__->register_method({
@@ -642,7 +654,7 @@ __PACKAGE__->register_method({
     code => sub {
 	my ($param) = @_;
 
-	my $conf = PVE::QemuServer::load_config($param->{vmid});
+	my $conf = PVE::QemuConfig->load_config($param->{vmid});
 
 	delete $conf->{snapshots};
 
@@ -713,7 +725,7 @@ __PACKAGE__->register_method({
     code => sub {
 	my ($param) = @_;
 
-	my $conf = PVE::QemuServer::load_config($param->{vmid});
+	my $conf = PVE::QemuConfig->load_config($param->{vmid});
 
 	my $pending_delete_hash = PVE::QemuServer::split_flagged_list($conf->{pending}->{delete});
 
@@ -832,7 +844,7 @@ my $update_vm_api  = sub {
     }
 
     foreach my $opt (keys %$param) {
-	if (PVE::QemuServer::valid_drivename($opt)) {
+	if (PVE::QemuServer::is_valid_drivename($opt)) {
 	    # cleanup drive path
 	    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 	    PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
@@ -852,12 +864,12 @@ my $update_vm_api  = sub {
 
     my $updatefn =  sub {
 
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 
 	die "checksum missmatch (file change by other user?)\n"
 	    if $digest && $digest ne $conf->{digest};
 
-	PVE::QemuServer::check_lock($conf) if !$skiplock;
+	PVE::QemuConfig->check_lock($conf) if !$skiplock;
 
 	foreach my $opt (keys %$revert) {
 	    if (defined($conf->{$opt})) {
@@ -887,32 +899,34 @@ my $update_vm_api  = sub {
 
 	    foreach my $opt (@delete) {
 		$modified->{$opt} = 1;
-		$conf = PVE::QemuServer::load_config($vmid); # update/reload
+		$conf = PVE::QemuConfig->load_config($vmid); # update/reload
 		if ($opt =~ m/^unused/) {
-		    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
 		    my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
+		    PVE::QemuConfig->check_protection($conf, "can't remove unused disk '$drive->{file}'");
+		    $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
 		    if (PVE::QemuServer::try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser)) {
 			delete $conf->{$opt};
-			PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+			PVE::QemuConfig->write_config($vmid, $conf);
 		    }
-		} elsif (PVE::QemuServer::valid_drivename($opt)) {
+		} 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']);
 		    PVE::QemuServer::vmconfig_register_unused_drive($storecfg, $vmid, $conf, PVE::QemuServer::parse_drive($opt, $conf->{pending}->{$opt}))
 			if defined($conf->{pending}->{$opt});
 		    PVE::QemuServer::vmconfig_delete_pending_option($conf, $opt, $force);
-		    PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+		    PVE::QemuConfig->write_config($vmid, $conf);
 		} else {
 		    PVE::QemuServer::vmconfig_delete_pending_option($conf, $opt, $force);
-		    PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+		    PVE::QemuConfig->write_config($vmid, $conf);
 		}
 	    }
 
 	    foreach my $opt (keys %$param) { # add/change
 		$modified->{$opt} = 1;
-		$conf = PVE::QemuServer::load_config($vmid); # update/reload
+		$conf = PVE::QemuConfig->load_config($vmid); # update/reload
 		next if defined($conf->{pending}->{$opt}) && ($param->{$opt} eq $conf->{pending}->{$opt}); # skip if nothing changed
 
-		if (PVE::QemuServer::valid_drivename($opt)) {
+		if (PVE::QemuServer::is_valid_drivename($opt)) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 		    if (PVE::QemuServer::drive_is_cdrom($drive)) { # CDROM
 			$rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
@@ -927,13 +941,13 @@ my $update_vm_api  = sub {
 		    $conf->{pending}->{$opt} = $param->{$opt};
 		}
 		PVE::QemuServer::vmconfig_undelete_pending_option($conf, $opt);
-		PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+		PVE::QemuConfig->write_config($vmid, $conf);
 	    }
 
 	    # remove pending changes when nothing changed
-	    $conf = PVE::QemuServer::load_config($vmid); # update/reload
+	    $conf = PVE::QemuConfig->load_config($vmid); # update/reload
 	    my $changes = PVE::QemuServer::vmconfig_cleanup_pending($conf);
-	    PVE::QemuServer::update_config_nolock($vmid, $conf, 1) if $changes;
+	    PVE::QemuConfig->write_config($vmid, $conf) if $changes;
 
 	    return if !scalar(keys %{$conf->{pending}});
 
@@ -941,7 +955,7 @@ my $update_vm_api  = sub {
 
 	    # apply pending changes
 
-	    $conf = PVE::QemuServer::load_config($vmid); # update/reload
+	    $conf = PVE::QemuConfig->load_config($vmid); # update/reload
 
 	    if ($running) {
 		my $errors = {};
@@ -987,7 +1001,7 @@ my $update_vm_api  = sub {
 	}
     };
 
-    return PVE::QemuServer::lock_config($vmid, $updatefn);
+    return PVE::QemuConfig->lock_config($vmid, $updatefn);
 };
 
 my $vm_config_perm_list = [
@@ -1140,16 +1154,19 @@ __PACKAGE__->register_method({
 	    if $skiplock && $authuser ne 'root@pam';
 
 	# test if VM exists
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 
 	my $storecfg = PVE::Storage::config();
 
-	die  "can't remove VM $vmid - protection mode enabled\n"
-	    if ($conf->{protection} == 1);
+	PVE::QemuConfig->check_protection($conf, "can't remove VM $vmid");
 
 	die "unable to remove VM $vmid - used in HA resources\n"
 	    if PVE::HA::Config::vm_is_ha_managed($vmid);
 
+	# early tests (repeat after locking)
+	die "VM $vmid is running - destroy failed\n"
+	    if PVE::QemuServer::check_running($vmid);
+
 	my $realcmd = sub {
 	    my $upid = shift;
 
@@ -1246,7 +1263,7 @@ __PACKAGE__->register_method({
 	my $node = $param->{node};
 	my $websocket = $param->{websocket};
 
-	my $conf = PVE::QemuServer::load_config($vmid, $node); # check if VM exists
+	my $conf = PVE::QemuConfig->load_config($vmid, $node); # check if VM exists
 
 	my $authpath = "/vms/$vmid";
 
@@ -1363,7 +1380,7 @@ __PACKAGE__->register_method({
 
 	PVE::AccessControl::verify_vnc_ticket($param->{vncticket}, $authuser, $authpath);
 
-	my $conf = PVE::QemuServer::load_config($vmid, $node); # VM exists ?
+	my $conf = PVE::QemuConfig->load_config($vmid, $node); # VM exists ?
 
 	# Note: VNC ports are acessible from outside, so we do not gain any
 	# security if we verify that $param->{port} belongs to VM $vmid. This
@@ -1404,7 +1421,7 @@ __PACKAGE__->register_method({
 	my $node = $param->{node};
 	my $proxy = $param->{proxy};
 
-	my $conf = PVE::QemuServer::load_config($vmid, $node);
+	my $conf = PVE::QemuConfig->load_config($vmid, $node);
 	my $title = "VM $vmid";
 	$title .= " - ". $conf->{name} if $conf->{name};
 
@@ -1449,7 +1466,7 @@ __PACKAGE__->register_method({
 	my ($param) = @_;
 
 	# test if VM exists
-	my $conf = PVE::QemuServer::load_config($param->{vmid});
+	my $conf = PVE::QemuConfig->load_config($param->{vmid});
 
 	my $res = [
 	    { subdir => 'current' },
@@ -1482,7 +1499,7 @@ __PACKAGE__->register_method({
 	my ($param) = @_;
 
 	# test if VM exists
-	my $conf = PVE::QemuServer::load_config($param->{vmid});
+	my $conf = PVE::QemuConfig->load_config($param->{vmid});
 
 	my $vmstatus = PVE::QemuServer::vmstatus($param->{vmid}, 1);
 	my $status = $vmstatus->{$param->{vmid}};
@@ -1508,7 +1525,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_stopped }),
 	    skiplock => get_standard_option('skiplock'),
 	    stateuri => get_standard_option('pve-qm-stateuri'),
 	    migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
@@ -1552,6 +1570,8 @@ __PACKAGE__->register_method({
 	    }
 	}
 
+	PVE::Cluster::check_cfs_quorum();
+
 	my $storecfg = PVE::Storage::config();
 
 	if (PVE::HA::Config::vm_is_ha_managed($vmid) && !$stateuri &&
@@ -1596,7 +1616,8 @@ __PACKAGE__->register_method({
     method => 'POST',
     protected => 1,
     proxyto => 'node',
-    description => "Stop virtual machine.",
+    description => "Stop virtual machine. The qemu process will exit immediately. This" .
+	"is akin to pulling the power plug of a running computer and may damage the VM data",
     permissions => {
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
@@ -1604,7 +1625,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
 	    migratedfrom => get_standard_option('pve-node', { optional => 1 }),
 	    timeout => {
@@ -1698,7 +1720,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
 	},
     },
@@ -1739,7 +1762,8 @@ __PACKAGE__->register_method({
     method => 'POST',
     protected => 1,
     proxyto => 'node',
-    description => "Shutdown virtual machine.",
+    description => "Shutdown virtual machine. This is similar to pressing the power button on a physical machine." .
+	"This will send an ACPI event for the guest OS, which should then proceed to a clean shutdown.",
     permissions => {
 	check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
     },
@@ -1747,7 +1771,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
 	    timeout => {
 		description => "Wait maximal timeout seconds.",
@@ -1793,13 +1818,36 @@ __PACKAGE__->register_method({
 
 	my $storecfg = PVE::Storage::config();
 
+	my $shutdown = 1;
+
+	# if vm is paused, do not shutdown (but stop if forceStop = 1)
+	# otherwise, we will infer a shutdown command, but run into the timeout,
+	# then when the vm is resumed, it will instantly shutdown
+	#
+	# 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 {
+	    $qmpstatus = PVE::QemuServer::vm_qmp_command($vmid, { execute => "query-status" }, 0);
+	};
+	my $err = $@ if $@;
+
+	if (!$err && $qmpstatus->{status} eq "paused") {
+	    if ($param->{forceStop}) {
+		warn "VM is paused - stop instead of shutdown\n";
+		$shutdown = 0;
+	    } else {
+		die "VM is paused - cannot shutdown\n";
+	    }
+	}
+
 	my $realcmd = sub {
 	    my $upid = shift;
 
 	    syslog('info', "shutdown VM $vmid: $upid\n");
 
 	    PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
-				     1, $param->{forceStop}, $keepActive);
+				     $shutdown, $param->{forceStop}, $keepActive);
 
 	    return;
 	};
@@ -1821,7 +1869,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
 	},
     },
@@ -1872,8 +1921,11 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
+	    nocheck => { type => 'boolean', optional => 1 },
+
 	},
     },
     returns => {
@@ -1894,14 +1946,16 @@ __PACKAGE__->register_method({
 	raise_param_exc({ skiplock => "Only root may use this option." })
 	    if $skiplock && $authuser ne 'root@pam';
 
-	die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
+	my $nocheck = extract_param($param, 'nocheck');
+
+	die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid, $nocheck);
 
 	my $realcmd = sub {
 	    my $upid = shift;
 
 	    syslog('info', "resume VM $vmid: $upid\n");
 
-	    PVE::QemuServer::vm_resume($vmid, $skiplock);
+	    PVE::QemuServer::vm_resume($vmid, $skiplock, $nocheck);
 
 	    return;
 	};
@@ -1923,7 +1977,8 @@ __PACKAGE__->register_method({
     	additionalProperties => 0,
 	properties => {
 	    node => get_standard_option('pve-node'),
-	    vmid => get_standard_option('pve-vmid'),
+	    vmid => get_standard_option('pve-vmid',
+					{ completion => \&PVE::QemuServer::complete_vmid_running }),
 	    skiplock => get_standard_option('skiplock'),
 	    key => {
 		description => "The key (qemu monitor encoding).",
@@ -2000,7 +2055,7 @@ __PACKAGE__->register_method({
 
 	my $running = PVE::QemuServer::check_running($vmid);
 
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 
 	if($snapname){
 	    my $snap = $conf->{snapshots}->{$snapname};
@@ -2010,7 +2065,7 @@ __PACKAGE__->register_method({
 	my $storecfg = PVE::Storage::config();
 
 	my $nodelist = PVE::QemuServer::shared_nodes($conf, $storecfg);
-	my $hasFeature = PVE::QemuServer::has_feature($feature, $conf, $storecfg, $snapname, $running);
+	my $hasFeature = PVE::QemuConfig->has_feature($feature, $conf, $storecfg, $snapname, $running);
 
 	return {
 	    hasFeature => $hasFeature,
@@ -2149,9 +2204,9 @@ __PACKAGE__->register_method({
 	    # do all tests after lock
 	    # we also try to do all tests before we fork the worker
 
-	    my $conf = PVE::QemuServer::load_config($vmid);
+	    my $conf = PVE::QemuConfig->load_config($vmid);
 
-	    PVE::QemuServer::check_lock($conf);
+	    PVE::QemuConfig->check_lock($conf);
 
 	    my $verify_running = PVE::QemuServer::check_running($vmid) || 0;
 
@@ -2166,13 +2221,14 @@ __PACKAGE__->register_method({
 
 	    die "can't clone VM to node '$target' (VM uses local storage)\n" if $target && !$sharedvm;
 
-	    my $conffile = PVE::QemuServer::config_file($newid);
+	    my $conffile = PVE::QemuConfig->config_file($newid);
 
 	    die "unable to create VM $newid: config file already exists\n"
 		if -f $conffile;
 
 	    my $newconf = { lock => 'clone' };
 	    my $drives = {};
+	    my $fullclone = {};
 	    my $vollist = [];
 
 	    foreach my $opt (keys %$oldconf) {
@@ -2190,7 +2246,7 @@ __PACKAGE__->register_method({
 		    my $net = PVE::QemuServer::parse_net($value);
 		    $net->{macaddr} =  PVE::Tools::random_ether_addr();
 		    $newconf->{$opt} = PVE::QemuServer::print_net($net);
-		} elsif (PVE::QemuServer::valid_drivename($opt)) {
+		} elsif (PVE::QemuServer::is_valid_drivename($opt)) {
 		    my $drive = PVE::QemuServer::parse_drive($opt, $value);
 		    die "unable to parse drive options for '$opt'\n" if !$drive;
 		    if (PVE::QemuServer::drive_is_cdrom($drive)) {
@@ -2199,7 +2255,7 @@ __PACKAGE__->register_method({
 			if ($param->{full}) {
 			    die "Full clone feature is not available"
 				if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running);
-			    $drive->{full} = 1;
+			    $fullclone->{$opt} = 1;
 			} else {
 			    # not full means clone instead of copy
 			    die "Linked clone feature is not available"
@@ -2249,27 +2305,27 @@ __PACKAGE__->register_method({
 		eval {
 		    local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
 
-		    PVE::Storage::activate_volumes($storecfg, $vollist);
+		    PVE::Storage::activate_volumes($storecfg, $vollist, $snapname);
 
 		    foreach my $opt (keys %$drives) {
 			my $drive = $drives->{$opt};
 
 			my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
-								   $newid, $storage, $format, $drive->{full}, $newvollist);
+								   $newid, $storage, $format, $fullclone->{$opt}, $newvollist);
 
 			$newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive);
 
-			PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
+			PVE::QemuConfig->write_config($newid, $newconf);
 		    }
 
 		    delete $newconf->{lock};
-		    PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
+		    PVE::QemuConfig->write_config($newid, $newconf);
 
                     if ($target) {
 			# always deactivate volumes - avoid lvm LVs to be active on several nodes
-			PVE::Storage::deactivate_volumes($storecfg, $vollist);
+			PVE::Storage::deactivate_volumes($storecfg, $vollist, $snapname) if !$running;
 
-			my $newconffile = PVE::QemuServer::config_file($newid, $target);
+			my $newconffile = PVE::QemuConfig->config_file($newid, $target);
 			die "Failed to move config to node '$target' - rename failed: $!\n"
 			    if !rename($conffile, $newconffile);
 		    }
@@ -2296,9 +2352,9 @@ __PACKAGE__->register_method({
 	    return $rpcenv->fork_worker('qmclone', $vmid, $authuser, $realcmd);
 	};
 
-	return PVE::QemuServer::lock_config_mode($vmid, 1, $shared_lock, sub {
+	return PVE::QemuConfig->lock_config_mode($vmid, 1, $shared_lock, sub {
 	    # Aquire exclusive lock lock for $newid
-	    return PVE::QemuServer::lock_config_full($newid, 1, $clonefn);
+	    return PVE::QemuConfig->lock_config_full($newid, 1, $clonefn);
 	});
 
     }});
@@ -2327,7 +2383,7 @@ __PACKAGE__->register_method({
 	    disk => {
 	        type => 'string',
 		description => "The disk you want to move.",
-		enum => [ PVE::QemuServer::disknames() ],
+		enum => [ PVE::QemuServer::valid_drive_names() ],
 	    },
             storage => get_standard_option('pve-storage-id', {
 		description => "Target storage.",
@@ -2380,7 +2436,7 @@ __PACKAGE__->register_method({
 
 	my $updatefn =  sub {
 
-	    my $conf = PVE::QemuServer::load_config($vmid);
+	    my $conf = PVE::QemuConfig->load_config($vmid);
 
 	    die "checksum missmatch (file change by other user?)\n"
 		if $digest && $digest ne $conf->{digest};
@@ -2420,9 +2476,9 @@ __PACKAGE__->register_method({
 
 		    $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $newdrive);
 
-		    PVE::QemuServer::add_unused_volume($conf, $old_volid) if !$param->{delete};
+		    PVE::QemuConfig->add_unused_volume($conf, $old_volid) if !$param->{delete};
 
-		    PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+		    PVE::QemuConfig->write_config($vmid, $conf);
 
 		    eval {
 			# try to deactivate volumes - avoid lvm LVs to be active on several nodes
@@ -2441,12 +2497,10 @@ __PACKAGE__->register_method({
                 }
 
 		if ($param->{delete}) {
-                    my $used_paths = PVE::QemuServer::get_used_paths($vmid, $storecfg, $conf, 1, 1);
-                    my $path = PVE::Storage::path($storecfg, $old_volid);
-		    if ($used_paths->{$path}){
-			warn "volume $old_volid have snapshots. Can't delete it\n";
-			PVE::QemuServer::add_unused_volume($conf, $old_volid);
-			PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+                    if (PVE::QemuServer::is_volume_in_use($storecfg, $conf, undef, $old_volid)) {
+			warn "volume $old_volid still has snapshots, can't delete it\n";
+			PVE::QemuConfig->add_unused_volume($conf, $old_volid);
+			PVE::QemuConfig->write_config($vmid, $conf);
 		    } else {
 			eval { PVE::Storage::vdisk_free($storecfg, $old_volid); };
 			warn $@ if $@;
@@ -2457,7 +2511,7 @@ __PACKAGE__->register_method({
             return $rpcenv->fork_worker('qmmove', $vmid, $authuser, $realcmd);
 	};
 
-	return PVE::QemuServer::lock_config($vmid, $updatefn);
+	return PVE::QemuConfig->lock_config($vmid, $updatefn);
     }});
 
 __PACKAGE__->register_method({
@@ -2519,11 +2573,11 @@ __PACKAGE__->register_method({
 	    if $param->{force} && $authuser ne 'root@pam';
 
 	# test if VM exists
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 
 	# try to detect errors early
 
-	PVE::QemuServer::check_lock($conf);
+	PVE::QemuConfig->check_lock($conf);
 
 	if (PVE::QemuServer::check_running($vmid)) {
 	    die "cant migrate running VM without --online\n"
@@ -2591,7 +2645,7 @@ __PACKAGE__->register_method({
 
 	my $vmid = $param->{vmid};
 
-	my $conf = PVE::QemuServer::load_config ($vmid); # check if VM exists
+	my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists
 
 	my $res = '';
 	eval {
@@ -2621,7 +2675,7 @@ __PACKAGE__->register_method({
 	    disk => {
 		type => 'string',
 		description => "The disk you want to resize.",
-		enum => [PVE::QemuServer::disknames()],
+		enum => [PVE::QemuServer::valid_drive_names()],
 	    },
 	    size => {
 		type => 'string',
@@ -2662,11 +2716,11 @@ __PACKAGE__->register_method({
 
         my $updatefn =  sub {
 
-            my $conf = PVE::QemuServer::load_config($vmid);
+            my $conf = PVE::QemuConfig->load_config($vmid);
 
             die "checksum missmatch (file change by other user?)\n"
                 if $digest && $digest ne $conf->{digest};
-            PVE::QemuServer::check_lock($conf) if !$skiplock;
+            PVE::QemuConfig->check_lock($conf) if !$skiplock;
 
 	    die "disk '$disk' does not exist\n" if !$conf->{$disk};
 
@@ -2717,10 +2771,10 @@ __PACKAGE__->register_method({
 	    $drive->{size} = $newsize;
 	    $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $drive);
 
-	    PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+	    PVE::QemuConfig->write_config($vmid, $conf);
 	};
 
-        PVE::QemuServer::lock_config($vmid, $updatefn);
+        PVE::QemuConfig->lock_config($vmid, $updatefn);
         return undef;
     }});
 
@@ -2754,7 +2808,7 @@ __PACKAGE__->register_method({
 
 	my $vmid = $param->{vmid};
 
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 	my $snaphash = $conf->{snapshots} || {};
 
 	my $res = [];
@@ -2831,7 +2885,7 @@ __PACKAGE__->register_method({
 
 	my $realcmd = sub {
 	    PVE::Cluster::log_msg('info', $authuser, "snapshot VM $vmid: $snapname");
-	    PVE::QemuServer::snapshot_create($vmid, $snapname, $param->{vmstate}, 
+	    PVE::QemuConfig->snapshot_create($vmid, $snapname, $param->{vmstate}, 
 					     $param->{description});
 	};
 
@@ -2912,9 +2966,9 @@ __PACKAGE__->register_method({
 
 	my $updatefn =  sub {
 
-	    my $conf = PVE::QemuServer::load_config($vmid);
+	    my $conf = PVE::QemuConfig->load_config($vmid);
 
-	    PVE::QemuServer::check_lock($conf);
+	    PVE::QemuConfig->check_lock($conf);
 
 	    my $snap = $conf->{snapshots}->{$snapname};
 
@@ -2922,10 +2976,10 @@ __PACKAGE__->register_method({
 
 	    $snap->{description} = $param->{description} if defined($param->{description});
 
-	     PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+	     PVE::QemuConfig->write_config($vmid, $conf);
 	};
 
-	PVE::QemuServer::lock_config($vmid, $updatefn);
+	PVE::QemuConfig->lock_config($vmid, $updatefn);
 
 	return undef;
     }});
@@ -2959,7 +3013,7 @@ __PACKAGE__->register_method({
 
 	my $snapname = extract_param($param, 'snapname');
 
-	my $conf = PVE::QemuServer::load_config($vmid);
+	my $conf = PVE::QemuConfig->load_config($vmid);
 
 	my $snap = $conf->{snapshots}->{$snapname};
 
@@ -3005,7 +3059,7 @@ __PACKAGE__->register_method({
 
 	my $realcmd = sub {
 	    PVE::Cluster::log_msg('info', $authuser, "rollback snapshot VM $vmid: $snapname");
-	    PVE::QemuServer::snapshot_rollback($vmid, $snapname);
+	    PVE::QemuConfig->snapshot_rollback($vmid, $snapname);
 	};
 
 	return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $realcmd);
@@ -3053,7 +3107,7 @@ __PACKAGE__->register_method({
 
 	my $realcmd = sub {
 	    PVE::Cluster::log_msg('info', $authuser, "delete snapshot VM $vmid: $snapname");
-	    PVE::QemuServer::snapshot_delete($vmid, $snapname, $param->{force});
+	    PVE::QemuConfig->snapshot_delete($vmid, $snapname, $param->{force});
 	};
 
 	return $rpcenv->fork_worker('qmdelsnapshot', $vmid, $authuser, $realcmd);
@@ -3079,7 +3133,7 @@ __PACKAGE__->register_method({
 		optional => 1,
 		type => 'string',
 		description => "If you want to convert only 1 disk to base image.",
-		enum => [PVE::QemuServer::disknames()],
+		enum => [PVE::QemuServer::valid_drive_names()],
 	    },
 
 	},
@@ -3100,15 +3154,15 @@ __PACKAGE__->register_method({
 
 	my $updatefn =  sub {
 
-	    my $conf = PVE::QemuServer::load_config($vmid);
+	    my $conf = PVE::QemuConfig->load_config($vmid);
 
-	    PVE::QemuServer::check_lock($conf);
+	    PVE::QemuConfig->check_lock($conf);
 
 	    die "unable to create template, because VM contains snapshots\n"
 		if $conf->{snapshots} && scalar(keys %{$conf->{snapshots}});
 
 	    die "you can't convert a template to a template\n"
-		if PVE::QemuServer::is_template($conf) && !$disk;
+		if PVE::QemuConfig->is_template($conf) && !$disk;
 
 	    die "you can't convert a VM to template if VM is running\n"
 		if PVE::QemuServer::check_running($vmid);
@@ -3118,12 +3172,12 @@ __PACKAGE__->register_method({
 	    };
 
 	    $conf->{template} = 1;
-	    PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
+	    PVE::QemuConfig->write_config($vmid, $conf);
 
 	    return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
 	};
 
-	PVE::QemuServer::lock_config($vmid, $updatefn);
+	PVE::QemuConfig->lock_config($vmid, $updatefn);
 	return undef;
     }});