X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FAPI2%2FQemu.pm;h=fbf036ae7d4d19061c6717489ae86342262c0426;hb=71c58bb7edd5916e61092acf67d57e032325ed9a;hp=0ba211d2c95ec091febd3ff769bc4055dacbf625;hpb=1ae43f8c11bb8286807a6d705b65d5482f0806ef;p=qemu-server.git diff --git a/PVE/API2/Qemu.pm b/PVE/API2/Qemu.pm index 0ba211d..fbf036a 100644 --- a/PVE/API2/Qemu.pm +++ b/PVE/API2/Qemu.pm @@ -4,12 +4,12 @@ use strict; use warnings; use Cwd 'abs_path'; use Net::SSLeay; -use UUID; use POSIX; use IO::Socket::IP; use URI::Escape; use PVE::Cluster qw (cfs_read_file cfs_write_file);; +use PVE::RRD; use PVE::SafeSyslog; use PVE::Tools qw(extract_param); use PVE::Exception qw(raise raise_param_exc raise_perm_exc); @@ -20,6 +20,7 @@ use PVE::ReplicationConfig; use PVE::GuestHelpers; use PVE::QemuConfig; use PVE::QemuServer; +use PVE::QemuServer::Monitor qw(mon_cmd); use PVE::QemuMigrate; use PVE::RPCEnvironment; use PVE::AccessControl; @@ -28,6 +29,9 @@ use PVE::Network; use PVE::Firewall; use PVE::API2::Firewall::VM; use PVE::API2::Qemu::Agent; +use PVE::VZDump::Plugin; +use PVE::DataCenterConfig; +use PVE::SSHInfo; BEGIN { if (!$ENV{PVE_GENERATING_DOCS}) { @@ -64,10 +68,9 @@ my $check_storage_access = sub { my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive); my $volid = $drive->{file}; + my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1); - if (!$volid || ($volid eq 'none' || $volid eq 'cloudinit')) { - # nothing to check - } elsif ($volid =~ m/^(([^:\s]+):)?(cloudinit)$/) { + if (!$volid || ($volid eq 'none' || $volid eq 'cloudinit' || (defined($volname) && $volname eq 'cloudinit'))) { # nothing to check } elsif ($isCDROM && ($volid eq 'cdrom')) { $rpcenv->check($authuser, "/", ['Sys.Console']); @@ -130,7 +133,7 @@ my $check_storage_access_clone = sub { # Note: $pool is only needed when creating a VM, because pool permissions # are automatically inherited if VM already exists inside a pool. my $create_disks = sub { - my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $settings, $default_storage) = @_; + my ($rpcenv, $authuser, $conf, $arch, $storecfg, $vmid, $pool, $settings, $default_storage) = @_; my $vollist = []; @@ -140,31 +143,33 @@ my $create_disks = sub { my ($ds, $disk) = @_; my $volid = $disk->{file}; + my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1); if (!$volid || $volid eq 'none' || $volid eq 'cdrom') { delete $disk->{size}; - $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk); - } elsif ($volid =~ m!^(?:([^/:\s]+):)?cloudinit$!) { - my $storeid = $1 || $default_storage; + $res->{$ds} = PVE::QemuServer::print_drive($disk); + } elsif (defined($volname) && $volname eq 'cloudinit') { + $storeid = $storeid // $default_storage; die "no storage ID specified (and no default storage)\n" if !$storeid; my $scfg = PVE::Storage::storage_config($storecfg, $storeid); my $name = "vm-$vmid-cloudinit"; + my $fmt = undef; if ($scfg->{path}) { - $name .= ".qcow2"; - $fmt = 'qcow2'; - }else{ - $fmt = 'raw'; + $fmt = $disk->{format} // "qcow2"; + $name .= ".$fmt"; + } else { + $fmt = $disk->{format} // "raw"; } - # FIXME: Reasonable size? qcow2 shouldn't grow if the space isn't used anyway? - my $cloudinit_iso_size = 5; # in MB - my $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, - $fmt, $name, $cloudinit_iso_size*1024); + + # Initial disk created with 4 MB and aligned to 4MB on regeneration + my $ci_size = PVE::QemuServer::Cloudinit::CLOUDINIT_DISK_SIZE; + my $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $fmt, $name, $ci_size/1024); $disk->{file} = $volid; $disk->{media} = 'cdrom'; push @$vollist, $volid; delete $disk->{format}; # no longer needed - $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk); + $res->{$ds} = PVE::QemuServer::print_drive($disk); } elsif ($volid =~ $NEW_DISK_RE) { my ($storeid, $size) = ($2 || $default_storage, $3); die "no storage ID specified (and no default storage)\n" if !$storeid; @@ -175,7 +180,7 @@ my $create_disks = sub { my $volid; if ($ds eq 'efidisk0') { - ($volid, $size) = PVE::QemuServer::create_efidisk($storecfg, $storeid, $vmid, $fmt); + ($volid, $size) = PVE::QemuServer::create_efidisk($storecfg, $storeid, $vmid, $fmt, $arch); } else { $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid, $fmt, undef, $size); } @@ -183,7 +188,7 @@ my $create_disks = sub { $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); + $res->{$ds} = PVE::QemuServer::print_drive($disk); } else { PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $volid); @@ -197,8 +202,6 @@ my $create_disks = sub { if ($volid_is_new) { - my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1); - PVE::Storage::activate_volumes($storecfg, [ $volid ]) if $storeid; my $size = PVE::Storage::volume_size_info($storecfg, $volid); @@ -208,7 +211,7 @@ my $create_disks = sub { $disk->{size} = $size; } - $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk); + $res->{$ds} = PVE::QemuServer::print_drive($disk); } }; @@ -259,6 +262,7 @@ my $hwtypeoptions = { 'tablet' => 1, 'vga' => 1, 'watchdog' => 1, + 'audio0' => 1, }; my $generaloptions = { @@ -279,6 +283,7 @@ my $generaloptions = { 'startup' => 1, 'tdf' => 1, 'template' => 1, + 'tags' => 1, }; my $vmpoweroptions = { @@ -291,16 +296,29 @@ my $diskoptions = { 'vmstatestorage' => 1, }; +my $cloudinitoptions = { + cicustom => 1, + cipassword => 1, + citype => 1, + ciuser => 1, + nameserver => 1, + searchdomain => 1, + sshkeys => 1, +}; + my $check_vm_modify_config_perm = sub { my ($rpcenv, $authuser, $vmid, $pool, $key_list) = @_; return 1 if $authuser eq 'root@pam'; foreach my $opt (@$key_list) { - # disk checks need to be done somewhere else + # some checks (e.g., disk, serial port, usb) need to be done somewhere + # else, as there the permission can be value dependend next if PVE::QemuServer::is_valid_drivename($opt); + next if $opt eq 'vmstate'; next if $opt eq 'cdrom'; - next if $opt =~ m/^unused\d+$/; + next if $opt =~ m/^(?:unused|serial|usb)\d+$/; + if ($cpuoptions->{$opt} || $opt =~ m/^numa\d+$/) { $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.CPU']); @@ -318,10 +336,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 ($opt =~ m/^(?:net|ipconfig)\d+$/) { + } elsif ($cloudinitoptions->{$opt} || ($opt =~ m/^(?:net|ipconfig)\d+$/)) { $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']); } else { - # catches usb\d+, hostpci\d+, args, lock, etc. + # catches hostpci\d+, args, lock, etc. # new options will be checked here die "only root can set '$opt' config\n"; } @@ -356,7 +374,7 @@ __PACKAGE__->register_method({ type => 'array', items => { type => "object", - properties => {}, + properties => $PVE::QemuServer::vmstatus_return_properties, }, links => [ { rel => 'child', href => "{vmid}" } ], }, @@ -373,7 +391,6 @@ __PACKAGE__->register_method({ next if !$rpcenv->check($authuser, "/vms/$vmid", [ 'VM.Audit' ], 1); my $data = $vmstatus->{$vmid}; - $data->{vmid} = int($vmid); push @$res, $data; } @@ -430,6 +447,19 @@ __PACKAGE__->register_method({ type => 'string', format => 'pve-poolid', description => "Add the VM to the specified pool.", }, + bwlimit => { + description => "Override I/O bandwidth limit (in KiB/s).", + optional => 1, + type => 'integer', + minimum => '0', + default => 'restore limit from datacenter or storage config', + }, + start => { + optional => 1, + type => 'boolean', + default => 0, + description => "Start VM after it was created successfully.", + }, }), }, returns => { @@ -439,26 +469,20 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $node = extract_param($param, 'node'); - my $vmid = extract_param($param, 'vmid'); my $archive = extract_param($param, 'archive'); + my $is_restore = !!$archive; - my $storage = extract_param($param, 'storage'); - + my $bwlimit = extract_param($param, 'bwlimit'); my $force = extract_param($param, 'force'); - - my $unique = extract_param($param, 'unique'); - my $pool = extract_param($param, 'pool'); - - my $filename = PVE::QemuConfig->config_file($vmid); - - my $storecfg = PVE::Storage::config(); + my $start_after_create = extract_param($param, 'start'); + my $storage = extract_param($param, 'storage'); + my $unique = extract_param($param, 'unique'); if (defined(my $ssh_keys = $param->{sshkeys})) { $ssh_keys = URI::Escape::uri_unescape($ssh_keys); @@ -467,6 +491,9 @@ __PACKAGE__->register_method({ PVE::Cluster::check_cfs_quorum(); + my $filename = PVE::QemuConfig->config_file($vmid); + my $storecfg = PVE::Storage::config(); + if (defined($pool)) { $rpcenv->check_pool_exist($pool); } @@ -498,7 +525,7 @@ __PACKAGE__->register_method({ raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive; PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive); - $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive); + $param->{$opt} = PVE::QemuServer::print_drive($drive); } } @@ -516,49 +543,48 @@ __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); - - PVE::QemuConfig->check_protection($conf, "unable to restore VM $vmid"); + my $emsg = $is_restore ? "unable to restore VM $vmid -" : "unable to create VM $vmid -"; - die "unable to restore vm $vmid - config file already exists\n" - if !$force; + eval { PVE::QemuConfig->create_and_lock_config($vmid, $force) }; + die "$emsg $@" if $@; - die "unable to restore vm $vmid - vm is running\n" - if PVE::QemuServer::check_running($vmid); + my $restorefn = sub { + my $conf = PVE::QemuConfig->load_config($vmid); - die "unable to restore vm $vmid - vm is a template\n" - if PVE::QemuConfig->is_template($conf); + PVE::QemuConfig->check_protection($conf, $emsg); - } else { - die "unable to restore vm $vmid - already existing on cluster node '$current_node'\n"; - } - } + die "$emsg vm is running\n" if PVE::QemuServer::check_running($vmid); my $realcmd = sub { PVE::QemuServer::restore_archive($archive, $vmid, $authuser, { storage => $storage, pool => $pool, - unique => $unique }); + unique => $unique, + bwlimit => $bwlimit, + }); + 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)) { + warn "Convert to template.\n"; + eval { PVE::QemuServer::template_create($vmid, $restored_conf) }; + warn $@ if $@; + } PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool; + + if ($start_after_create) { + eval { PVE::API2::Qemu->vm_start({ vmid => $vmid, node => $node }) }; + warn $@ if $@; + } }; # ensure no old replication state are exists PVE::ReplicationState::delete_guest_states($vmid); - return $rpcenv->fork_worker('qmrestore', $vmid, $authuser, $realcmd); + return PVE::QemuConfig->lock_config_full($vmid, 1, $realcmd); }; my $createfn = sub { - - # test after locking - PVE::Cluster::check_vmid_unused($vmid); - # ensure no old replication state are exists PVE::ReplicationState::delete_guest_states($vmid); @@ -568,9 +594,11 @@ __PACKAGE__->register_method({ my $conf = $param; + my $arch = PVE::QemuServer::get_vm_arch($conf); + eval { - $vollist = &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $param, $storage); + $vollist = &$create_disks($rpcenv, $authuser, $conf, $arch, $storecfg, $vmid, $pool, $param, $storage); if (!$conf->{bootdisk}) { my $firstdisk = PVE::QemuServer::resolve_first_disk($conf); @@ -582,6 +610,10 @@ __PACKAGE__->register_method({ $conf->{smbios1} = PVE::QemuServer::generate_smbios1_uuid(); } + if ((!defined($conf->{vmgenid}) || $conf->{vmgenid} eq '1') && $arch ne 'aarch64') { + $conf->{vmgenid} = PVE::QemuServer::generate_uuid(); + } + PVE::QemuConfig->write_config($vmid, $conf); }; @@ -592,16 +624,48 @@ __PACKAGE__->register_method({ eval { PVE::Storage::vdisk_free($storecfg, $volid); }; warn $@ if $@; } - die "create failed - $err"; + die "$emsg $err"; } PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool; }; - return $rpcenv->fork_worker('qmcreate', $vmid, $authuser, $realcmd); + PVE::QemuConfig->lock_config_full($vmid, 1, $realcmd); + + if ($start_after_create) { + print "Execute autostart\n"; + eval { PVE::API2::Qemu->vm_start({vmid => $vmid, node => $node}) }; + warn $@ if $@; + } }; - return PVE::QemuConfig->lock_config_full($vmid, 1, $archive ? $restorefn : $createfn); + my ($code, $worker_name); + if ($is_restore) { + $worker_name = 'qmrestore'; + $code = sub { + eval { $restorefn->() }; + if (my $err = $@) { + eval { PVE::QemuConfig->remove_lock($vmid, 'create') }; + warn $@ if $@; + die $err; + } + }; + } else { + $worker_name = 'qmcreate'; + $code = sub { + eval { $createfn->() }; + if (my $err = $@) { + eval { + my $conffile = PVE::QemuConfig->config_file($vmid); + unlink($conffile) or die "failed to remove config file: $!\n"; + }; + warn $@ if $@; + die $err; + } + }; + } + + return $rpcenv->fork_worker($worker_name, $vmid, $authuser, $code); }}); __PACKAGE__->register_method({ @@ -706,7 +770,7 @@ __PACKAGE__->register_method({ code => sub { my ($param) = @_; - return PVE::Cluster::create_rrd_graph( + return PVE::RRD::create_rrd_graph( "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{ds}, $param->{cf}); @@ -749,7 +813,7 @@ __PACKAGE__->register_method({ code => sub { my ($param) = @_; - return PVE::Cluster::create_rrd_data( + return PVE::RRD::create_rrd_data( "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{cf}); }}); @@ -768,51 +832,48 @@ __PACKAGE__->register_method({ properties => { node => get_standard_option('pve-node'), vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), - current => { - description => "Get current values (instead of pending values).", - optional => 1, + current => { + description => "Get current values (instead of pending values).", + optional => 1, default => 0, type => 'boolean', - }, + }, + snapshot => get_standard_option('pve-snapshot-name', { + description => "Fetch config values from given snapshot.", + optional => 1, + completion => sub { + my ($cmd, $pname, $cur, $args) = @_; + PVE::QemuConfig->snapshot_list($args->[0]); + }, + }), }, }, returns => { + description => "The current VM configuration.", type => "object", - properties => { + properties => PVE::QemuServer::json_config_properties({ digest => { type => 'string', description => 'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.', } - }, + }), }, code => sub { my ($param) = @_; - my $conf = PVE::QemuConfig->load_config($param->{vmid}); - - delete $conf->{snapshots}; - - if (!$param->{current}) { - foreach my $opt (keys %{$conf->{pending}}) { - next if $opt eq 'delete'; - my $value = $conf->{pending}->{$opt}; - next if ref($value); # just to be sure - $conf->{$opt} = $value; - } - my $pending_delete_hash = PVE::QemuServer::split_flagged_list($conf->{pending}->{delete}); - foreach my $opt (keys %$pending_delete_hash) { - delete $conf->{$opt} if $conf->{$opt}; - } - } - - delete $conf->{pending}; + raise_param_exc({ snapshot => "cannot use 'snapshot' parameter with 'current'", + current => "cannot use 'snapshot' parameter with 'current'"}) + if ($param->{snapshot} && $param->{current}); - # hide cloudinit password - if ($conf->{cipassword}) { - $conf->{cipassword} = '**********'; + my $conf; + if ($param->{snapshot}) { + $conf = PVE::QemuConfig->load_snapshot_config($param->{vmid}, $param->{snapshot}); + } else { + $conf = PVE::QemuConfig->load_current_config($param->{vmid}, $param->{current}); } - + $conf->{cipassword} = '**********' if $conf->{cipassword}; return $conf; + }}); __PACKAGE__->register_method({ @@ -866,49 +927,13 @@ __PACKAGE__->register_method({ my $conf = PVE::QemuConfig->load_config($param->{vmid}); - my $pending_delete_hash = PVE::QemuServer::split_flagged_list($conf->{pending}->{delete}); + my $pending_delete_hash = PVE::QemuConfig->parse_pending_delete($conf->{pending}->{delete}); - my $res = []; - - foreach my $opt (keys %$conf) { - next if ref($conf->{$opt}); - my $item = { key => $opt }; - $item->{value} = $conf->{$opt} if defined($conf->{$opt}); - $item->{pending} = $conf->{pending}->{$opt} if defined($conf->{pending}->{$opt}); - $item->{delete} = ($pending_delete_hash->{$opt} ? 2 : 1) if exists $pending_delete_hash->{$opt}; - - # hide cloudinit password - if ($opt eq 'cipassword') { - $item->{value} = '**********' if defined($item->{value}); - # the trailing space so that the pending string is different - $item->{pending} = '********** ' if defined($item->{pending}); - } - push @$res, $item; - } + $conf->{cipassword} = '**********' if defined($conf->{cipassword}); + $conf->{pending}->{cipassword} = '********** ' if defined($conf->{pending}->{cipassword}); - foreach my $opt (keys %{$conf->{pending}}) { - next if $opt eq 'delete'; - next if ref($conf->{pending}->{$opt}); # just to be sure - next if defined($conf->{$opt}); - my $item = { key => $opt }; - $item->{pending} = $conf->{pending}->{$opt}; - - # hide cloudinit password - if ($opt eq 'cipassword') { - $item->{pending} = '**********' if defined($item->{pending}); - } - push @$res, $item; - } - - while (my ($opt, $force) = each %$pending_delete_hash) { - next if $conf->{pending}->{$opt}; # just to be sure - next if $conf->{$opt}; - my $item = { key => $opt, delete => ($force ? 2 : 1)}; - push @$res, $item; - } - - return $res; - }}); + return PVE::GuestHelpers::config_with_pending_array($conf, $pending_delete_hash); + }}); # POST/PUT {vmid}/config implementation # @@ -1014,12 +1039,15 @@ my $update_vm_api = sub { my $volid = $drive->{file}; return if !$volid || !($drive->{replicate}//1); return if PVE::QemuServer::drive_is_cdrom($drive); - my ($storeid, $format); + + my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1); + return if $volname eq 'cloudinit'; + + my $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); @@ -1035,11 +1063,18 @@ my $update_vm_api = sub { 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); + $param->{$opt} = PVE::QemuServer::print_drive($drive); } elsif ($opt =~ m/^net(\d+)$/) { # add macaddr my $net = PVE::QemuServer::parse_net($param->{$opt}); $param->{$opt} = PVE::QemuServer::print_net($net); + } elsif ($opt eq 'vmgenid') { + if ($param->{$opt} eq '1') { + $param->{$opt} = PVE::QemuServer::generate_uuid(); + } + } elsif ($opt eq 'hookscript') { + eval { PVE::GuestHelpers::check_hookscript($param->{$opt}, $storecfg); }; + raise_param_exc({ $opt => $@ }) if $@; } } @@ -1056,6 +1091,15 @@ my $update_vm_api = sub { die "checksum missmatch (file change by other user?)\n" if $digest && $digest ne $conf->{digest}; + # 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') { + delete $conf->{lock}; # for check lock check, not written out + push @delete, 'lock'; # this is the real deal to write it out + } + push @delete, 'runningmachine' if $conf->{runningmachine}; + } + PVE::QemuConfig->check_lock($conf) if !$skiplock; foreach my $opt (keys %$revert) { @@ -1087,29 +1131,58 @@ 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})) { + + # value of what we want to delete, independent if pending or not + my $val = $conf->{$opt} // $conf->{pending}->{$opt}; + if (!defined($val)) { warn "cannot delete '$opt' - not set in current configuration!\n"; $modified->{$opt} = 0; next; } + my $is_pending_val = defined($conf->{pending}->{$opt}); + delete $conf->{pending}->{$opt}; if ($opt =~ m/^unused/) { - my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt}); + my $drive = PVE::QemuServer::parse_drive($opt, $val); 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::QemuConfig->write_config($vmid, $conf); } + } elsif ($opt eq 'vmstate') { + PVE::QemuConfig->check_protection($conf, "can't remove vmstate '$val'"); + # the user needs Disk and PowerMgmt privileges to remove the vmstate + $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk', 'VM.PowerMgmt' ]); + if (PVE::QemuServer::try_deallocate_drive($storecfg, $vmid, $conf, $opt, { file => $val }, $rpcenv, $authuser, 1)) { + delete $conf->{$opt}; + PVE::QemuConfig->write_config($vmid, $conf); + } } 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::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); + PVE::QemuConfig->write_config($vmid, $conf); + } elsif ($opt =~ m/^serial\d+$/) { + if ($val eq 'socket') { + $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.HWType']); + } elsif ($authuser ne 'root@pam') { + die "only root can delete '$opt' config for real devices\n"; + } + PVE::QemuConfig->add_to_pending_delete($conf, $opt, $force); + PVE::QemuConfig->write_config($vmid, $conf); + } elsif ($opt =~ m/^usb\d+$/) { + if ($val =~ m/spice/) { + $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.HWType']); + } elsif ($authuser ne 'root@pam') { + die "only root can delete '$opt' config for real devices\n"; + } + PVE::QemuConfig->add_to_pending_delete($conf, $opt, $force); PVE::QemuConfig->write_config($vmid, $conf); } else { - PVE::QemuServer::vmconfig_delete_pending_option($conf, $opt, $force); + PVE::QemuConfig->add_to_pending_delete($conf, $opt, $force); PVE::QemuConfig->write_config($vmid, $conf); } } @@ -1119,6 +1192,8 @@ my $update_vm_api = sub { $conf = PVE::QemuConfig->load_config($vmid); # update/reload next if defined($conf->{pending}->{$opt}) && ($param->{$opt} eq $conf->{pending}->{$opt}); # skip if nothing changed + 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? @@ -1130,17 +1205,31 @@ my $update_vm_api = sub { 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}, $storecfg, $vmid, undef, {$opt => $param->{$opt}}); + &$create_disks($rpcenv, $authuser, $conf->{pending}, $arch, $storecfg, $vmid, undef, {$opt => $param->{$opt}}); + } 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']); + } elsif ($authuser ne 'root@pam') { + die "only root can modify '$opt' config for real devices\n"; + } + $conf->{pending}->{$opt} = $param->{$opt}; + } elsif ($opt =~ m/^usb\d+/) { + if ((!defined($conf->{$opt}) || $conf->{$opt} =~ m/spice/) && $param->{$opt} =~ m/spice/) { + $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.HWType']); + } elsif ($authuser ne 'root@pam') { + die "only root can modify '$opt' config for real devices\n"; + } + $conf->{pending}->{$opt} = $param->{$opt}; } else { $conf->{pending}->{$opt} = $param->{$opt}; } - PVE::QemuServer::vmconfig_undelete_pending_option($conf, $opt); + PVE::QemuConfig->remove_from_pending_delete($conf, $opt); PVE::QemuConfig->write_config($vmid, $conf); } # remove pending changes when nothing changed $conf = PVE::QemuConfig->load_config($vmid); # update/reload - my $changes = PVE::QemuServer::vmconfig_cleanup_pending($conf); + my $changes = PVE::QemuConfig->cleanup_pending($conf); PVE::QemuConfig->write_config($vmid, $conf) if $changes; return if !scalar(keys %{$conf->{pending}}); @@ -1312,7 +1401,6 @@ __PACKAGE__->register_method({ } }); - __PACKAGE__->register_method({ name => 'destroy_vm', path => '{vmid}', @@ -1329,6 +1417,11 @@ __PACKAGE__->register_method({ 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.", + optional => 1, + }, }, }, returns => { @@ -1338,9 +1431,7 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); - my $vmid = $param->{vmid}; my $skiplock = $param->{skiplock}; @@ -1349,17 +1440,16 @@ __PACKAGE__->register_method({ # 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"); - 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); + if (!$param->{purge}) { + # 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); + } # early tests (repeat after locking) die "VM $vmid is running - destroy failed\n" @@ -1369,12 +1459,22 @@ __PACKAGE__->register_method({ my $upid = shift; 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)); - PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock); + PVE::QemuServer::destroy_vm($storecfg, $vmid, $skiplock, { lock => 'destroyed' }); - PVE::AccessControl::remove_vm_access($vmid); + PVE::AccessControl::remove_vm_access($vmid); + PVE::Firewall::remove_vmfw_conf($vmid); + if ($param->{purge}) { + PVE::ReplicationConfig::remove_vmid_jobs($vmid); + PVE::VZDump::Plugin::remove_vmid_from_backup_jobs($vmid); + } - PVE::Firewall::remove_vmfw_conf($vmid); + # only now remove the zombie config, else we can have reuse race + PVE::QemuConfig->destroy_config($vmid); + }); }; return $rpcenv->fork_worker('qmdestroy', $vmid, $authuser, $realcmd); @@ -1462,6 +1562,7 @@ __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 $authpath = "/vms/$vmid"; @@ -1470,13 +1571,14 @@ __PACKAGE__->register_method({ $sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192) if !$sslcert; - my ($remip, $family); + my $family; my $remcmd = []; if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) { - ($remip, $family) = PVE::Cluster::remote_node_ip($node); + (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 = ['/usr/bin/ssh', '-e', 'none', '-T', '-o', 'BatchMode=yes', $remip]; + $remcmd = PVE::SSHInfo::ssh_info_to_command($sshinfo, $use_serial ? '-t' : '-T'); } else { $family = PVE::Tools::get_host_address_family($node); } @@ -1492,8 +1594,7 @@ __PACKAGE__->register_method({ my $cmd; - if ($conf->{vga} && ($conf->{vga} =~ m/^serial\d+$/)) { - + if ($use_serial) { my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga}, '-escape', '0' ]; @@ -1610,19 +1711,20 @@ __PACKAGE__->register_method({ my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath); - my ($remip, $family); + my $family; + my $remcmd = []; if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) { - ($remip, $family) = PVE::Cluster::remote_node_ip($node); + (undef, $family) = PVE::Cluster::remote_node_ip($node); + my $sshinfo = PVE::SSHInfo::get_ssh_info($node); + $remcmd = PVE::SSHInfo::ssh_info_to_command($sshinfo, '-t'); + push @$remcmd, '--'; } else { $family = PVE::Tools::get_host_address_family($node); } my $port = PVE::Tools::next_vnc_port($family); - my $remcmd = $remip ? - ['/usr/bin/ssh', '-e', 'none', '-t', $remip, '--'] : []; - my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-escape', '0']; push @$termcmd, '-iface', $serial if $serial; @@ -1747,8 +1849,8 @@ __PACKAGE__->register_method({ my ($ticket, undef, $remote_viewer_config) = PVE::AccessControl::remote_viewer_config($authuser, $vmid, $node, $proxy, $title, $port); - PVE::QemuServer::vm_mon_cmd($vmid, "set_password", protocol => 'spice', password => $ticket); - PVE::QemuServer::vm_mon_cmd($vmid, "expire_password", protocol => 'spice', time => "+30"); + mon_cmd($vmid, "set_password", protocol => 'spice', password => $ticket); + mon_cmd($vmid, "expire_password", protocol => 'spice', time => "+30"); return $remote_viewer_config; }}); @@ -1789,6 +1891,10 @@ __PACKAGE__->register_method({ { subdir => 'current' }, { subdir => 'start' }, { subdir => 'stop' }, + { subdir => 'reset' }, + { subdir => 'shutdown' }, + { subdir => 'suspend' }, + { subdir => 'reboot' }, ]; return $res; @@ -1811,7 +1917,26 @@ __PACKAGE__->register_method({ vmid => get_standard_option('pve-vmid'), }, }, - returns => { type => 'object' }, + returns => { + type => 'object', + properties => { + %$PVE::QemuServer::vmstatus_return_properties, + ha => { + description => "HA manager service status.", + type => 'object', + }, + spice => { + description => "Qemu VGA configuration supports spice.", + type => 'boolean', + optional => 1, + }, + agent => { + description => "Qemu GuestAgent enabled in config.", + type => 'boolean', + optional => 1, + }, + }, + }, code => sub { my ($param) = @_; @@ -1824,8 +1949,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 $conf->{agent}; + $status->{agent} = 1 if (PVE::QemuServer::parse_guest_agent($conf)->{enabled}); return $status; }}); @@ -1862,7 +1986,7 @@ __PACKAGE__->register_method({ description => "CIDR of the (sub) network that is used for migration.", optional => 1, }, - machine => get_standard_option('pve-qm-machine'), + 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.)", type => 'string', @@ -1877,45 +2001,33 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $node = extract_param($param, 'node'); - my $vmid = extract_param($param, 'vmid'); my $machine = extract_param($param, 'machine'); - my $stateuri = extract_param($param, 'stateuri'); - raise_param_exc({ stateuri => "Only root may use this option." }) - if $stateuri && $authuser ne 'root@pam'; - - my $skiplock = extract_param($param, 'skiplock'); - raise_param_exc({ skiplock => "Only root may use this option." }) - if $skiplock && $authuser ne 'root@pam'; - - my $migratedfrom = extract_param($param, 'migratedfrom'); - raise_param_exc({ migratedfrom => "Only root may use this option." }) - if $migratedfrom && $authuser ne 'root@pam'; - - my $migration_type = extract_param($param, 'migration_type'); - raise_param_exc({ migration_type => "Only root may use this option." }) - if $migration_type && $authuser ne 'root@pam'; - - my $migration_network = extract_param($param, 'migration_network'); - raise_param_exc({ migration_network => "Only root may use this option." }) - if $migration_network && $authuser ne 'root@pam'; + my $get_root_param = sub { + my $value = extract_param($param, $_[0]); + raise_param_exc({ "$_[0]" => "Only root may use this option." }) + if $value && $authuser ne 'root@pam'; + return $value; + }; - my $targetstorage = extract_param($param, 'targetstorage'); - raise_param_exc({ targetstorage => "Only root may use this option." }) - if $targetstorage && $authuser ne 'root@pam'; + my $stateuri = $get_root_param->('stateuri'); + my $skiplock = $get_root_param->('skiplock'); + my $migratedfrom = $get_root_param->('migratedfrom'); + my $migration_type = $get_root_param->('migration_type'); + 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; # read spice ticket from STDIN my $spice_ticket; - if ($stateuri && ($stateuri eq 'tcp') && $migratedfrom && ($rpcenv->{type} eq 'cli')) { + if ($stateuri && ($stateuri eq 'tcp' || $stateuri eq 'unix') && $migratedfrom && ($rpcenv->{type} eq 'cli')) { if (defined(my $line = )) { chomp $line; $spice_ticket = $line; @@ -1926,20 +2038,14 @@ __PACKAGE__->register_method({ my $storecfg = PVE::Storage::config(); - if (PVE::HA::Config::vm_is_ha_managed($vmid) && !$stateuri && - $rpcenv->{type} ne 'ha') { - + if (PVE::HA::Config::vm_is_ha_managed($vmid) && !$stateuri && $rpcenv->{type} ne 'ha') { my $hacmd = sub { my $upid = shift; - my $service = "vm:$vmid"; - - my $cmd = ['ha-manager', 'set', $service, '--state', 'started']; - print "Requesting HA start for VM $vmid\n"; + my $cmd = ['ha-manager', 'set', "vm:$vmid", '--state', 'started']; PVE::Tools::run_command($cmd); - return; }; @@ -1954,7 +2060,6 @@ __PACKAGE__->register_method({ PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock, $migratedfrom, undef, $machine, $spice_ticket, $migration_network, $migration_type, $targetstorage); - return; }; @@ -2002,11 +2107,9 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $node = extract_param($param, 'node'); - my $vmid = extract_param($param, 'vmid'); my $skiplock = extract_param($param, 'skiplock'); @@ -2029,14 +2132,10 @@ __PACKAGE__->register_method({ my $hacmd = sub { my $upid = shift; - my $service = "vm:$vmid"; - - my $cmd = ['ha-manager', 'set', $service, '--state', 'stopped']; - print "Requesting HA stop for VM $vmid\n"; + my $cmd = ['ha-manager', 'crm-command', 'stop', "vm:$vmid", '0']; PVE::Tools::run_command($cmd); - return; }; @@ -2050,7 +2149,6 @@ __PACKAGE__->register_method({ PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout}, 0, 1, $keepActive, $migratedfrom); - return; }; @@ -2153,11 +2251,9 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $node = extract_param($param, 'node'); - my $vmid = extract_param($param, 'vmid'); my $skiplock = extract_param($param, 'skiplock'); @@ -2178,9 +2274,9 @@ __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 { - $qmpstatus = PVE::QemuServer::vm_qmp_command($vmid, { execute => "query-status" }, 0); + my $qmpstatus = eval { + PVE::QemuConfig::assert_config_exists_on_node($vmid); + mon_cmd($vmid, "query-status"); }; my $err = $@ if $@; @@ -2193,20 +2289,16 @@ __PACKAGE__->register_method({ } } - if (PVE::HA::Config::vm_is_ha_managed($vmid) && - ($rpcenv->{type} ne 'ha')) { + if (PVE::HA::Config::vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') { + my $timeout = $param->{timeout} // 60; my $hacmd = sub { my $upid = shift; - my $service = "vm:$vmid"; - - my $cmd = ['ha-manager', 'set', $service, '--state', 'stopped']; - print "Requesting HA stop for VM $vmid\n"; + my $cmd = ['ha-manager', 'crm-command', 'stop', "vm:$vmid", "$timeout"]; PVE::Tools::run_command($cmd); - return; }; @@ -2221,7 +2313,6 @@ __PACKAGE__->register_method({ PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout}, $shutdown, $param->{forceStop}, $keepActive); - return; }; @@ -2229,6 +2320,65 @@ __PACKAGE__->register_method({ } }}); +__PACKAGE__->register_method({ + name => 'vm_reboot', + path => '{vmid}/status/reboot', + method => 'POST', + protected => 1, + proxyto => 'node', + description => "Reboot the VM by shutting it down, and starting it again. Applies pending changes.", + permissions => { + check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]], + }, + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', + { completion => \&PVE::QemuServer::complete_vmid_running }), + timeout => { + description => "Wait maximal timeout seconds for the shutdown.", + type => 'integer', + minimum => 0, + optional => 1, + }, + }, + }, + returns => { + type => 'string', + }, + code => sub { + my ($param) = @_; + + my $rpcenv = PVE::RPCEnvironment::get(); + my $authuser = $rpcenv->get_user(); + + 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 $vmid not running\n" if !PVE::QemuServer::check_running($vmid); + + my $realcmd = sub { + my $upid = shift; + + syslog('info', "requesting reboot of VM $vmid: $upid\n"); + PVE::QemuServer::vm_reboot($vmid, $param->{timeout}); + return; + }; + + return $rpcenv->fork_worker('qmreboot', $vmid, $authuser, $realcmd); + }}); + __PACKAGE__->register_method({ name => 'vm_suspend', path => '{vmid}/status/suspend', @@ -2246,6 +2396,18 @@ __PACKAGE__->register_method({ vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid_running }), skiplock => get_standard_option('skiplock'), + todisk => { + type => 'boolean', + default => 0, + optional => 1, + description => 'If set, suspends the VM to disk. Will be resumed on next VM start.', + }, + statestorage => get_standard_option('pve-storage-id', { + description => "The storage for the VM state", + requires => 'todisk', + optional => 1, + completion => \&PVE::Storage::complete_storage_enabled, + }), }, }, returns => { @@ -2255,30 +2417,36 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $node = extract_param($param, 'node'); - my $vmid = extract_param($param, 'vmid'); + my $todisk = extract_param($param, 'todisk') // 0; + + my $statestorage = extract_param($param, 'statestorage'); + my $skiplock = extract_param($param, 'skiplock'); 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); + die "Cannot suspend HA managed VM to disk\n" + if $todisk && PVE::HA::Config::vm_is_ha_managed($vmid); + my $realcmd = sub { my $upid = shift; syslog('info', "suspend VM $vmid: $upid\n"); - PVE::QemuServer::vm_suspend($vmid, $skiplock); + PVE::QemuServer::vm_suspend($vmid, $skiplock, $todisk, $statestorage); return; }; - return $rpcenv->fork_worker('qmsuspend', $vmid, $authuser, $realcmd); + my $taskname = $todisk ? 'qmsuspend' : 'qmpause'; + return $rpcenv->fork_worker($taskname, $vmid, $authuser, $realcmd); }}); __PACKAGE__->register_method({ @@ -2322,14 +2490,28 @@ __PACKAGE__->register_method({ my $nocheck = extract_param($param, 'nocheck'); - die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid, $nocheck); + my $to_disk_suspended; + eval { + PVE::QemuConfig->lock_config($vmid, sub { + my $conf = PVE::QemuConfig->load_config($vmid); + $to_disk_suspended = PVE::QemuConfig->has_lock($conf, 'suspended'); + }); + }; + + die "VM $vmid not running\n" + if !$to_disk_suspended && !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, $nocheck); + if (!$to_disk_suspended) { + PVE::QemuServer::vm_resume($vmid, $skiplock, $nocheck); + } else { + my $storecfg = PVE::Storage::config(); + PVE::QemuServer::vm_start($storecfg, $vmid, undef, $skiplock); + } return; }; @@ -2513,6 +2695,13 @@ __PACKAGE__->register_method({ description => "Target node. Only allowed if the original VM is on shared storage.", optional => 1, }), + bwlimit => { + description => "Override I/O bandwidth limit (in KiB/s).", + optional => 1, + type => 'integer', + minimum => '0', + default => 'clone limit from datacenter or storage config', + }, }, }, returns => { @@ -2656,13 +2845,15 @@ __PACKAGE__->register_method({ } # auto generate a new uuid - my ($uuid, $uuid_str); - UUID::generate($uuid); - UUID::unparse($uuid, $uuid_str); my $smbios1 = PVE::QemuServer::parse_smbios1($newconf->{smbios1} || ''); - $smbios1->{uuid} = $uuid_str; + $smbios1->{uuid} = PVE::QemuServer::generate_uuid(); $newconf->{smbios1} = PVE::QemuServer::print_smbios1($smbios1); + # auto generate a new vmgenid if the option was set + if ($newconf->{vmgenid}) { + $newconf->{vmgenid} = PVE::QemuServer::generate_uuid(); + } + delete $newconf->{template}; if ($param->{name}) { @@ -2696,6 +2887,8 @@ __PACKAGE__->register_method({ PVE::Storage::activate_volumes($storecfg, $vollist, $snapname); + my $bwlimit = extract_param($param, 'bwlimit'); + my $total_jobs = scalar(keys %{$drives}); my $i = 1; @@ -2703,17 +2896,30 @@ __PACKAGE__->register_method({ my $drive = $drives->{$opt}; my $skipcomplete = ($total_jobs != $i); # finish after last drive + 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, $skipcomplete, $oldconf->{agent}); + $jobs, $skipcomplete, $oldconf->{agent}, $clonelimit); - $newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive); + $newconf->{$opt} = PVE::QemuServer::print_drive($newdrive); PVE::QemuConfig->write_config($newid, $newconf); $i++; } delete $newconf->{lock}; + + # do not write pending changes + if (my @changes = keys %{$newconf->{pending}}) { + my $pending = join(',', @changes); + warn "found pending changes for '$pending', discarding for clone\n"; + delete $newconf->{pending}; + } + PVE::QemuConfig->write_config($newid, $newconf); if ($target) { @@ -2803,6 +3009,13 @@ __PACKAGE__->register_method({ maxLength => 40, optional => 1, }, + bwlimit => { + description => "Override I/O bandwidth limit (in KiB/s).", + optional => 1, + type => 'integer', + minimum => '0', + default => 'move limit from datacenter or storage config', + }, }, }, returns => { @@ -2880,10 +3093,13 @@ __PACKAGE__->register_method({ warn "moving disk with snapshots, snapshots will not be moved!\n" if $snapshotted; + 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); + $vmid, $storeid, $format, 1, $newvollist, undef, undef, undef, $movelimit); - $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $newdrive); + $conf->{$disk} = PVE::QemuServer::print_drive($newdrive); PVE::QemuConfig->add_unused_volume($conf, $old_volid) if !$param->{delete}; @@ -2893,6 +3109,10 @@ __PACKAGE__->register_method({ PVE::QemuConfig->write_config($vmid, $conf); + if ($running && PVE::QemuServer::parse_guest_agent($conf)->{fstrim_cloned_disks} && PVE::QemuServer::qga_check_running($vmid)) { + eval { mon_cmd($vmid, "guest-fstrim"); }; + } + eval { # try to deactivate volumes - avoid lvm LVs to be active on several nodes PVE::Storage::deactivate_volumes($storecfg, [ $newdrive->{file} ]) @@ -2924,6 +3144,138 @@ __PACKAGE__->register_method({ return PVE::QemuConfig->lock_config($vmid, $updatefn); }}); +my $check_vm_disks_local = sub { + my ($storecfg, $vmconf, $vmid) = @_; + + my $local_disks = {}; + + # add some more information to the disks e.g. cdrom + PVE::QemuServer::foreach_volid($vmconf, sub { + my ($volid, $attr) = @_; + + my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1); + if ($storeid) { + my $scfg = PVE::Storage::storage_config($storecfg, $storeid); + return if $scfg->{shared}; + } + # The shared attr here is just a special case where the vdisk + # is marked as shared manually + return if $attr->{shared}; + return if $attr->{cdrom} and $volid eq "none"; + + if (exists $local_disks->{$volid}) { + @{$local_disks->{$volid}}{keys %$attr} = values %$attr + } else { + $local_disks->{$volid} = $attr; + # ensure volid is present in case it's needed + $local_disks->{$volid}->{volid} = $volid; + } + }); + + return $local_disks; +}; + +__PACKAGE__->register_method({ + name => 'migrate_vm_precondition', + path => '{vmid}/migrate', + method => 'GET', + protected => 1, + proxyto => 'node', + description => "Get preconditions for migration.", + permissions => { + check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]], + }, + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), + target => get_standard_option('pve-node', { + description => "Target node.", + completion => \&PVE::Cluster::complete_migration_target, + optional => 1, + }), + }, + }, + returns => { + type => "object", + properties => { + running => { type => 'boolean' }, + allowed_nodes => { + type => 'array', + optional => 1, + description => "List nodes allowed for offline migration, only passed if VM is offline" + }, + not_allowed_nodes => { + type => 'object', + optional => 1, + description => "List not allowed nodes with additional informations, only passed if VM is offline" + }, + local_disks => { + type => 'array', + description => "List local disks including CD-Rom, unsused and not referenced disks" + }, + local_resources => { + type => 'array', + description => "List local resources e.g. pci, usb" + } + }, + }, + code => sub { + my ($param) = @_; + + my $rpcenv = PVE::RPCEnvironment::get(); + + my $authuser = $rpcenv->get_user(); + + PVE::Cluster::check_cfs_quorum(); + + my $res = {}; + + my $vmid = extract_param($param, 'vmid'); + my $target = extract_param($param, 'target'); + my $localnode = PVE::INotify::nodename(); + + + # test if VM exists + my $vmconf = PVE::QemuConfig->load_config($vmid); + my $storecfg = PVE::Storage::config(); + + + # try to detect errors early + PVE::QemuConfig->check_lock($vmconf); + + $res->{running} = PVE::QemuServer::check_running($vmid) ? 1:0; + + # if vm is not running, return target nodes where local storage is available + # for offline migration + if (!$res->{running}) { + $res->{allowed_nodes} = []; + my $checked_nodes = PVE::QemuServer::check_local_storage_availability($vmconf, $storecfg); + delete $checked_nodes->{$localnode}; + + foreach my $node (keys %$checked_nodes) { + if (!defined $checked_nodes->{$node}->{unavailable_storages}) { + push @{$res->{allowed_nodes}}, $node; + } + + } + $res->{not_allowed_nodes} = $checked_nodes; + } + + + my $local_disks = &$check_vm_disks_local($storecfg, $vmconf, $vmid); + $res->{local_disks} = [ values %$local_disks ];; + + my $local_resources = PVE::QemuServer::check_local_resources($vmconf, 1); + + $res->{local_resources} = $local_resources; + + return $res; + + + }}); + __PACKAGE__->register_method({ name => 'migrate_vm', path => '{vmid}/migrate', @@ -2939,13 +3291,13 @@ __PACKAGE__->register_method({ properties => { node => get_standard_option('pve-node'), vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), - target => get_standard_option('pve-node', { + target => get_standard_option('pve-node', { description => "Target node.", completion => \&PVE::Cluster::complete_migration_target, }), online => { type => 'boolean', - description => "Use online/live migration.", + description => "Use online/live migration if VM is running. Ignored if VM is stopped.", optional => 1, }, force => { @@ -2972,8 +3324,15 @@ __PACKAGE__->register_method({ targetstorage => get_standard_option('pve-storage-id', { description => "Default target storage.", optional => 1, - completion => \&PVE::QemuServer::complete_storage, + completion => \&PVE::QemuServer::complete_migration_storage, }), + bwlimit => { + description => "Override I/O bandwidth limit (in KiB/s).", + optional => 1, + type => 'integer', + minimum => '0', + default => 'migrate limit from datacenter or storage config', + }, }, }, returns => { @@ -2984,7 +3343,6 @@ __PACKAGE__->register_method({ my ($param) = @_; my $rpcenv = PVE::RPCEnvironment::get(); - my $authuser = $rpcenv->get_user(); my $target = extract_param($param, 'target'); @@ -3000,9 +3358,6 @@ __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'; @@ -3021,10 +3376,15 @@ __PACKAGE__->register_method({ PVE::QemuConfig->check_lock($conf); if (PVE::QemuServer::check_running($vmid)) { - die "cant migrate running VM without --online\n" - if !$param->{online}; + die "can't migrate running VM without --online\n" if !$param->{online}; + } 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}) { @@ -3038,14 +3398,10 @@ __PACKAGE__->register_method({ my $hacmd = sub { my $upid = shift; - my $service = "vm:$vmid"; - - my $cmd = ['ha-manager', 'migrate', $service, $target]; - print "Requesting HA migration for VM $vmid to node $target\n"; + my $cmd = ['ha-manager', 'migrate', "vm:$vmid", $target]; PVE::Tools::run_command($cmd); - return; }; @@ -3110,7 +3466,7 @@ __PACKAGE__->register_method({ my $res = ''; eval { - $res = PVE::QemuServer::vm_human_monitor_command($vmid, $param->{command}); + $res = PVE::QemuServer::Monitor::hmp_cmd($vmid, $param->{command}); }; $res = "ERROR: $@" if $@; @@ -3190,7 +3546,7 @@ __PACKAGE__->register_method({ my (undef, undef, undef, undef, undef, undef, $format) = PVE::Storage::parse_volname($storecfg, $drive->{file}); - die "can't resize volume: $disk if snapshot exists\n" + die "can't resize volume: $disk if snapshot exists\n" if %{$conf->{snapshots}} && $format eq 'qcow2'; my $volid = $drive->{file}; @@ -3206,6 +3562,8 @@ __PACKAGE__->register_method({ PVE::Storage::activate_volumes($storecfg, [$volid]); my $size = PVE::Storage::volume_size_info($storecfg, $volid, 5); + die "Could not determine current size of volume '$volid'\n" if !defined($size); + die "internal error" if $sizestr !~ m/^(\+)?(\d+(\.\d+)?)([KMGT])?$/; my ($ext, $newsize, $unit) = ($1, $2, $4); if ($unit) { @@ -3231,7 +3589,7 @@ __PACKAGE__->register_method({ PVE::QemuServer::qemu_block_resize($vmid, "drive-$disk", $storecfg, $volid, $newsize); $drive->{size} = $newsize; - $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $drive); + $conf->{$disk} = PVE::QemuServer::print_drive($drive); PVE::QemuConfig->write_config($vmid, $conf); }; @@ -3261,7 +3619,32 @@ __PACKAGE__->register_method({ type => 'array', items => { type => "object", - properties => {}, + properties => { + name => { + description => "Snapshot identifier. Value 'current' identifies the current VM.", + type => 'string', + }, + vmstate => { + description => "Snapshot includes RAM.", + type => 'boolean', + optional => 1, + }, + description => { + description => "Snapshot description.", + type => 'string', + }, + snaptime => { + description => "Snapshot creation time", + type => 'integer', + renderer => 'timestamp', + optional => 1, + }, + parent => { + description => "Parent snapshot identifier.", + type => 'string', + optional => 1, + }, + }, }, links => [ { rel => 'child', href => "{name}" } ], }, @@ -3289,7 +3672,12 @@ __PACKAGE__->register_method({ } my $running = PVE::QemuServer::check_running($vmid, 1) ? 1 : 0; - my $current = { name => 'current', digest => $conf->{digest}, running => $running }; + my $current = { + name => 'current', + digest => $conf->{digest}, + running => $running, + description => "You are here!", + }; $current->{parent} = $conf->{parent} if $conf->{parent}; push @$res, $current; @@ -3345,9 +3733,12 @@ __PACKAGE__->register_method({ die "unable to use snapshot name 'current' (reserved name)\n" if $snapname eq 'current'; + die "unable to use snapshot name 'pending' (reserved name)\n" + if lc($snapname) eq 'pending'; + my $realcmd = sub { PVE::Cluster::log_msg('info', $authuser, "snapshot VM $vmid: $snapname"); - PVE::QemuConfig->snapshot_create($vmid, $snapname, $param->{vmstate}, + PVE::QemuConfig->snapshot_create($vmid, $snapname, $param->{vmstate}, $param->{description}); }; @@ -3648,4 +4039,36 @@ __PACKAGE__->register_method({ return undef; }}); +__PACKAGE__->register_method({ + name => 'cloudinit_generated_config_dump', + path => '{vmid}/cloudinit/dump', + method => 'GET', + proxyto => 'node', + description => "Get automatically generated cloudinit config.", + permissions => { + check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]], + }, + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), + type => { + description => 'Config type.', + type => 'string', + enum => ['user', 'network', 'meta'], + }, + }, + }, + returns => { + type => 'string', + }, + code => sub { + my ($param) = @_; + + my $conf = PVE::QemuConfig->load_config($param->{vmid}); + + return PVE::QemuServer::Cloudinit::dump_cloudinit_config($conf, $param->{vmid}, $param->{type}); + }}); + 1;