X-Git-Url: https://git.proxmox.com/?p=qemu-server.git;a=blobdiff_plain;f=PVE%2FAPI2%2FQemu.pm;h=7f737bf8eaf3725ebde21290f52a7a10a28866f1;hp=1002c8755bf555a7d0a44bccd216b07b8d91b505;hb=b14477e718969468a9a5ef639533b9ff620e84ec;hpb=3e1f112286dc554bdf245e950b512842e66b70b7 diff --git a/PVE/API2/Qemu.pm b/PVE/API2/Qemu.pm index 1002c87..7f737bf 100644 --- a/PVE/API2/Qemu.pm +++ b/PVE/API2/Qemu.pm @@ -7,6 +7,7 @@ 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::SafeSyslog; @@ -26,6 +27,7 @@ use PVE::INotify; use PVE::Network; use PVE::Firewall; use PVE::API2::Firewall::VM; +use PVE::API2::Qemu::Agent; BEGIN { if (!$ENV{PVE_GENERATING_DOCS}) { @@ -63,7 +65,9 @@ my $check_storage_access = sub { my $volid = $drive->{file}; - if (!$volid || $volid eq 'none') { + if (!$volid || ($volid eq 'none' || $volid eq 'cloudinit')) { + # nothing to check + } elsif ($volid =~ m/^(([^:\s]+):)?(cloudinit)$/) { # nothing to check } elsif ($isCDROM && ($volid eq 'cdrom')) { $rpcenv->check($authuser, "/", ['Sys.Console']); @@ -78,6 +82,9 @@ my $check_storage_access = sub { PVE::Storage::check_volume_access($rpcenv, $authuser, $storecfg, $vmid, $volid); } }); + + $rpcenv->check($authuser, "/storage/$settings->{vmstatestorage}", ['Datastore.AllocateSpace']) + if defined($settings->{vmstatestorage}); }; my $check_storage_access_clone = sub { @@ -114,13 +121,16 @@ my $check_storage_access_clone = sub { } }); + $rpcenv->check($authuser, "/storage/$conf->{vmstatestorage}", ['Datastore.AllocateSpace']) + if defined($conf->{vmstatestorage}); + return $sharedvm; }; # 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 = []; @@ -134,6 +144,27 @@ my $create_disks = sub { if (!$volid || $volid eq 'none' || $volid eq 'cdrom') { delete $disk->{size}; $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk); + } elsif ($volid =~ m!^(?:([^/:\s]+):)?cloudinit$!) { + my $storeid = $1 || $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'; + } + # 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); + $disk->{file} = $volid; + $disk->{media} = 'cdrom'; + push @$vollist, $volid; + delete $disk->{format}; # no longer needed + $res->{$ds} = PVE::QemuServer::print_drive($vmid, $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; @@ -144,7 +175,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); } @@ -257,6 +288,16 @@ my $vmpoweroptions = { my $diskoptions = { 'boot' => 1, 'bootdisk' => 1, + 'vmstatestorage' => 1, +}; + +my $cloudinitoptions = { + cipassword => 1, + citype => 1, + ciuser => 1, + nameserver => 1, + searchdomain => 1, + sshkeys => 1, }; my $check_vm_modify_config_perm = sub { @@ -286,7 +327,7 @@ 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\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. @@ -324,7 +365,7 @@ __PACKAGE__->register_method({ type => 'array', items => { type => "object", - properties => {}, + properties => $PVE::QemuServer::vmstatus_return_properties, }, links => [ { rel => 'child', href => "{vmid}" } ], }, @@ -341,7 +382,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; } @@ -398,6 +438,18 @@ __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', + }, + start => { + optional => 1, + type => 'boolean', + default => 0, + description => "Start VM after it was created successfully.", + }, }), }, returns => { @@ -415,6 +467,7 @@ __PACKAGE__->register_method({ my $vmid = extract_param($param, 'vmid'); my $archive = extract_param($param, 'archive'); + my $is_restore = !!$archive; my $storage = extract_param($param, 'storage'); @@ -424,10 +477,19 @@ __PACKAGE__->register_method({ my $pool = extract_param($param, 'pool'); + my $bwlimit = extract_param($param, 'bwlimit'); + + my $start_after_create = extract_param($param, 'start'); + my $filename = PVE::QemuConfig->config_file($vmid); my $storecfg = PVE::Storage::config(); + if (defined(my $ssh_keys = $param->{sshkeys})) { + $ssh_keys = URI::Escape::uri_unescape($ssh_keys); + PVE::Tools::validate_ssh_public_keys($ssh_keys); + } + PVE::Cluster::check_cfs_quorum(); if (defined($pool)) { @@ -479,49 +541,41 @@ __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); + my $emsg = $is_restore ? "unable to restore VM $vmid -" : "unable to create VM $vmid -"; - PVE::QemuConfig->check_protection($conf, "unable to restore VM $vmid"); + eval { PVE::QemuConfig->create_and_lock_config($vmid, $force) }; + die "$emsg $@" if $@; - die "unable to restore vm $vmid - config file already exists\n" - if !$force; + my $restorefn = sub { + my $conf = PVE::QemuConfig->load_config($vmid); - die "unable to restore vm $vmid - vm is running\n" - if PVE::QemuServer::check_running($vmid); + PVE::QemuConfig->check_protection($conf, $emsg); - die "unable to restore vm $vmid - vm is a template\n" - if PVE::QemuConfig->is_template($conf); - - } 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); + die "$emsg vm is a template\n" if PVE::QemuConfig->is_template($conf); my $realcmd = sub { PVE::QemuServer::restore_archive($archive, $vmid, $authuser, { storage => $storage, pool => $pool, - unique => $unique }); + unique => $unique, + bwlimit => $bwlimit, }); 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); @@ -531,30 +585,24 @@ __PACKAGE__->register_method({ my $conf = $param; + my ($arch, undef) = PVE::QemuServer::get_basic_machine_info($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); - # try to be smart about bootdisk - my @disks = PVE::QemuServer::valid_drive_names(); - my $firstdisk; - foreach my $ds (reverse @disks) { - next if !$conf->{$ds}; - my $disk = PVE::QemuServer::parse_drive($ds, $conf->{$ds}); - next if PVE::QemuServer::drive_is_cdrom($disk); - $firstdisk = $ds; - } - - if (!$conf->{bootdisk} && $firstdisk) { - $conf->{bootdisk} = $firstdisk; + if (!$conf->{bootdisk}) { + my $firstdisk = PVE::QemuServer::resolve_first_disk($conf); + $conf->{bootdisk} = $firstdisk if $firstdisk; } # auto generate uuid if user did not specify smbios1 option if (!$conf->{smbios1}) { - my ($uuid, $uuid_str); - UUID::generate($uuid); - UUID::unparse($uuid, $uuid_str); - $conf->{smbios1} = "uuid=$uuid_str"; + $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); @@ -567,16 +615,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({ @@ -614,6 +694,7 @@ __PACKAGE__->register_method({ { subdir => 'status' }, { subdir => 'unlink' }, { subdir => 'vncproxy' }, + { subdir => 'termproxy' }, { subdir => 'migrate' }, { subdir => 'resize' }, { subdir => 'move' }, @@ -635,6 +716,11 @@ __PACKAGE__->register_method ({ path => '{vmid}/firewall', }); +__PACKAGE__->register_method ({ + subclass => "PVE::API2::Qemu::Agent", + path => '{vmid}/agent', +}); + __PACKAGE__->register_method({ name => 'rrd', path => '{vmid}/rrd', @@ -743,22 +829,42 @@ __PACKAGE__->register_method({ 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}); + my $snapname = $param->{snapshot}; + if ($snapname) { + my $snapshot = $conf->{snapshots}->{$snapname}; + die "snapshot '$snapname' does not exist\n" + if !defined($snapshot); + + # we need the digest of the file + $snapshot->{digest} = $conf->{digest}; + $conf = $snapshot; + } + delete $conf->{snapshots}; if (!$param->{current}) { @@ -776,6 +882,11 @@ __PACKAGE__->register_method({ delete $conf->{pending}; + # hide cloudinit password + if ($conf->{cipassword}) { + $conf->{cipassword} = '**********'; + } + return $conf; }}); @@ -840,6 +951,13 @@ __PACKAGE__->register_method({ $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; } @@ -849,6 +967,11 @@ __PACKAGE__->register_method({ 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; } @@ -889,9 +1012,16 @@ my $update_vm_api = sub { my $background_delay = extract_param($param, 'background_delay'); + if (defined(my $cipassword = $param->{cipassword})) { + # Same logic as in cloud-init (but with the regex fixed...) + $param->{cipassword} = PVE::Tools::encrypt_pw($cipassword) + if $cipassword !~ /^\$(?:[156]|2[ay])(\$.+){2}/; + } + my @paramarr = (); # used for log message foreach my $key (sort keys %$param) { - push @paramarr, "-$key", $param->{$key}; + my $value = $key eq 'cipassword' ? '' : $param->{$key}; + push @paramarr, "-$key", $value; } my $skiplock = extract_param($param, 'skiplock'); @@ -904,6 +1034,11 @@ my $update_vm_api = sub { my $force = extract_param($param, 'force'); + if (defined(my $ssh_keys = $param->{sshkeys})) { + $ssh_keys = URI::Escape::uri_unescape($ssh_keys); + PVE::Tools::validate_ssh_public_keys($ssh_keys); + } + die "no options specified\n" if !$delete_str && !$revert_str && !scalar(keys %$param); my $storecfg = PVE::Storage::config(); @@ -980,6 +1115,10 @@ my $update_vm_api = sub { # 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(); + } } } @@ -1059,8 +1198,11 @@ 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, undef) = PVE::QemuServer::get_basic_machine_info($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 { @@ -1069,7 +1211,7 @@ 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}}); } else { $conf->{pending}->{$opt} = $param->{$opt}; } @@ -1401,6 +1543,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"; @@ -1409,13 +1552,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::Cluster::get_ssh_info($node); # NOTE: kvm VNC traffic is already TLS encrypted or is known unsecure - $remcmd = ['/usr/bin/ssh', '-T', '-o', 'BatchMode=yes', $remip]; + $remcmd = PVE::Cluster::ssh_info_to_command($sshinfo, $use_serial ? '-t' : '-T'); } else { $family = PVE::Tools::get_host_address_family($node); } @@ -1431,16 +1575,23 @@ __PACKAGE__->register_method({ my $cmd; - if ($conf->{vga} && ($conf->{vga} =~ m/^serial\d+$/)) { + if ($use_serial) { - die "Websocket mode is not supported in vga serial mode!" if $websocket; + my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga}, '-escape', '0' ]; - my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga} ]; - #my $termcmd = "/usr/bin/qm terminal -iface $conf->{vga}"; $cmd = ['/usr/bin/vncterm', '-rfbport', $port, '-timeout', $timeout, '-authpath', $authpath, - '-perm', 'Sys.Console', '-c', @$remcmd, @$termcmd]; + '-perm', 'Sys.Console']; + + if ($param->{websocket}) { + $ENV{PVE_VNC_TICKET} = $ticket; # pass ticket to vncterm + push @$cmd, '-notls', '-listen', 'localhost'; + } + + push @$cmd, '-c', @$remcmd, @$termcmd; + PVE::Tools::run_command($cmd); + } else { $ENV{LC_PVE_TICKET} = $ticket if $websocket; # set ticket with "qm vncproxy" @@ -1487,6 +1638,101 @@ __PACKAGE__->register_method({ }; }}); +__PACKAGE__->register_method({ + name => 'termproxy', + path => '{vmid}/termproxy', + method => 'POST', + protected => 1, + permissions => { + check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]], + }, + description => "Creates a TCP proxy connections.", + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid'), + serial=> { + optional => 1, + type => 'string', + enum => [qw(serial0 serial1 serial2 serial3)], + description => "opens a serial terminal (defaults to display)", + }, + }, + }, + returns => { + additionalProperties => 0, + properties => { + user => { type => 'string' }, + ticket => { type => 'string' }, + port => { type => 'integer' }, + upid => { type => 'string' }, + }, + }, + code => sub { + my ($param) = @_; + + my $rpcenv = PVE::RPCEnvironment::get(); + + my $authuser = $rpcenv->get_user(); + + my $vmid = $param->{vmid}; + my $node = $param->{node}; + my $serial = $param->{serial}; + + 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}; + } + } + + my $authpath = "/vms/$vmid"; + + my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath); + + my $family; + my $remcmd = []; + + if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) { + (undef, $family) = PVE::Cluster::remote_node_ip($node); + my $sshinfo = PVE::Cluster::get_ssh_info($node); + $remcmd = PVE::Cluster::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 $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-escape', '0']; + push @$termcmd, '-iface', $serial if $serial; + + my $realcmd = sub { + my $upid = shift; + + syslog('info', "starting qemu termproxy $upid\n"); + + my $cmd = ['/usr/bin/termproxy', $port, '--path', $authpath, + '--perm', 'VM.Console', '--']; + push @$cmd, @$remcmd, @$termcmd; + + PVE::Tools::run_command($cmd); + }; + + my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd, 1); + + PVE::Tools::wait_for_vnc_port($port); + + return { + user => $authuser, + ticket => $ticket, + port => $port, + upid => $upid, + }; + }}); + __PACKAGE__->register_method({ name => 'vncwebsocket', path => '{vmid}/vncwebsocket', @@ -1648,7 +1894,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) = @_; @@ -1661,6 +1926,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}); return $status; }}); @@ -1751,7 +2017,7 @@ __PACKAGE__->register_method({ # read spice ticket from STDIN my $spice_ticket; if ($stateuri && ($stateuri eq 'tcp') && $migratedfrom && ($rpcenv->{type} eq 'cli')) { - if (defined(my $line = <>)) { + if (defined(my $line = )) { chomp $line; $spice_ticket = $line; } @@ -2307,7 +2573,9 @@ __PACKAGE__->register_method({ properties => { node => get_standard_option('pve-node'), vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), - newid => get_standard_option('pve-vmid', { description => 'VMID for the clone.' }), + newid => get_standard_option('pve-vmid', { + completion => \&PVE::Cluster::complete_next_vmid, + description => 'VMID for the clone.' }), name => { optional => 1, type => 'string', format => 'dns-name', @@ -2328,12 +2596,10 @@ __PACKAGE__->register_method({ }), storage => get_standard_option('pve-storage-id', { description => "Target storage for full clone.", - requires => 'full', optional => 1, }), 'format' => { - description => "Target format for file storage.", - requires => 'full', + description => "Target format for file storage. Only valid for full clone.", type => 'string', optional => 1, enum => [ 'raw', 'qcow2', 'vmdk'], @@ -2341,9 +2607,8 @@ __PACKAGE__->register_method({ full => { optional => 1, type => 'boolean', - description => "Create a full copy of all disk. This is always done when " . + description => "Create a full copy of all disks. This is always done when " . "you clone a normal VM. For VM templates, we try to create a linked clone by default.", - default => 0, }, target => get_standard_option('pve-node', { description => "Target node. Only allowed if the original VM is on shared storage.", @@ -2424,6 +2689,17 @@ __PACKAGE__->register_method({ die "snapshot '$snapname' does not exist\n" if $snapname && !defined( $conf->{snapshots}->{$snapname}); + my $full = extract_param($param, 'full'); + if (!defined($full)) { + $full = !PVE::QemuConfig->is_template($conf); + } + + die "parameter 'storage' not allowed for linked clones\n" + if defined($storage) && !$full; + + die "parameter 'format' not allowed for linked clones\n" + if defined($format) && !$full; + my $oldconf = $snapname ? $conf->{snapshots}->{$snapname} : $conf; my $sharedvm = &$check_storage_access_clone($rpcenv, $authuser, $storecfg, $oldconf, $storage); @@ -2459,10 +2735,10 @@ __PACKAGE__->register_method({ } 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)) { + if (PVE::QemuServer::drive_is_cdrom($drive, 1)) { $newconf->{$opt} = $value; # simply copy configuration } else { - if ($param->{full}) { + if ($full || PVE::QemuServer::drive_is_cloudinit($drive)) { die "Full clone feature is not supported for drive '$opt'\n" if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running); $fullclone->{$opt} = 1; @@ -2481,13 +2757,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}) { @@ -2539,6 +2817,14 @@ __PACKAGE__->register_method({ } 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) { @@ -2670,7 +2956,7 @@ __PACKAGE__->register_method({ my $old_volid = $drive->{file} || die "disk '$disk' has no associated volume\n"; - die "you can't move a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive); + die "you can't move a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive, 1); my $oldfmt; my ($oldstoreid, $oldvolname) = PVE::Storage::parse_volume_id($old_volid); @@ -2697,7 +2983,10 @@ __PACKAGE__->register_method({ my $newvollist = []; eval { - local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; }; + local $SIG{INT} = + local $SIG{TERM} = + local $SIG{QUIT} = + local $SIG{HUP} = sub { die "interrupted by signal\n"; }; warn "moving disk with snapshots, snapshots will not be moved!\n" if $snapshotted; @@ -2715,6 +3004,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 { PVE::QemuServer::vm_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} ]) @@ -2939,70 +3232,6 @@ __PACKAGE__->register_method({ return $res; }}); -my $guest_agent_commands = [ - 'ping', - 'get-time', - 'info', - 'fsfreeze-status', - 'fsfreeze-freeze', - 'fsfreeze-thaw', - 'fstrim', - 'network-get-interfaces', - 'get-vcpus', - 'get-fsinfo', - 'get-memory-blocks', - 'get-memory-block-info', - 'suspend-hybrid', - 'suspend-ram', - 'suspend-disk', - 'shutdown', - ]; - -__PACKAGE__->register_method({ - name => 'agent', - path => '{vmid}/agent', - method => 'POST', - protected => 1, - proxyto => 'node', - description => "Execute Qemu Guest Agent commands.", - permissions => { - check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]], - }, - parameters => { - additionalProperties => 0, - properties => { - node => get_standard_option('pve-node'), - vmid => get_standard_option('pve-vmid', { - completion => \&PVE::QemuServer::complete_vmid_running }), - command => { - type => 'string', - description => "The QGA command.", - enum => $guest_agent_commands, - }, - }, - }, - returns => { - type => 'object', - description => "Returns an object with a single `result` property. The type of that -property depends on the executed command.", - }, - code => sub { - my ($param) = @_; - - my $vmid = $param->{vmid}; - - my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists - - die "No Qemu Guest Agent\n" if !defined($conf->{agent}); - die "VM $vmid is not running\n" if !PVE::QemuServer::check_running($vmid); - - my $cmd = $param->{command}; - - my $res = PVE::QemuServer::vm_mon_cmd($vmid, "guest-$cmd"); - - return { result => $res }; - }}); - __PACKAGE__->register_method({ name => 'resize_vm', path => '{vmid}/resize', @@ -3147,7 +3376,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}" } ], }, @@ -3175,7 +3429,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; @@ -3339,7 +3598,7 @@ __PACKAGE__->register_method({ proxyto => 'node', description => "Get snapshot configuration", permissions => { - check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]], + check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot', 'VM.Snapshot.Rollback' ], any => 1], }, parameters => { additionalProperties => 0, @@ -3378,7 +3637,7 @@ __PACKAGE__->register_method({ proxyto => 'node', description => "Rollback VM state to specified snapshot.", permissions => { - check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]], + check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot', 'VM.Snapshot.Rollback' ], any => 1], }, parameters => { additionalProperties => 0,