]> git.proxmox.com Git - qemu-server.git/blame - PVE/API2/Qemu.pm
projects / qemu-server.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add qm listsnapshot call
[qemu-server.git] / PVE / API2 / Qemu.pm
CommitLineData
1e3baf05
DM		 1package PVE::API2::Qemu;
2
3use strict;
4use warnings;
5b9d692a 5use Cwd 'abs_path';
451b2b81 6use Net::SSLeay;
47314bf5 7use UUID;
1e3baf05 8
502d18a2 9use PVE::Cluster qw (cfs_read_file cfs_write_file);;
1e3baf05
DM		 10use PVE::SafeSyslog;
11use PVE::Tools qw(extract_param);
f9bfceef 12use PVE::Exception qw(raise raise_param_exc raise_perm_exc);
1e3baf05
DM		 13use PVE::Storage;
14use PVE::JSONSchema qw(get_standard_option);
15use PVE::RESTHandler;
ffda963f 16use PVE::QemuConfig;
1e3baf05 17use PVE::QemuServer;
3ea94c60 18use PVE::QemuMigrate;
1e3baf05
DM		 19use PVE::RPCEnvironment;
20use PVE::AccessControl;
21use PVE::INotify;
de8f60b2 22use PVE::Network;
e9abcde6 23use PVE::Firewall;
228a998b 24use PVE::API2::Firewall::VM;
0dbcc8c9 25use PVE::HA::Env::PVE2;
2003f0f8 26use PVE::HA::Config;
1e3baf05
DM		 27
28use Data::Dumper; # fixme: remove
29
30use base qw(PVE::RESTHandler);
31
32my $opt_force_description = "Force physical removal. Without this, we simple remove the disk from the config file and create an additional configuration entry called 'unused[n]', which contains the volume ID. Unlink of unused[n] always cause physical removal.";
33
34my $resolve_cdrom_alias = sub {
35 my $param = shift;
36
37 if (my $value = $param->{cdrom}) {
38 $value .= ",media=cdrom" if $value !~ m/media=/;
39 $param->{ide2} = $value;
40 delete $param->{cdrom};
41 }
42};
43
ae57f6b3 44my $check_storage_access = sub {
fcbb753e 45 my ($rpcenv, $authuser, $storecfg, $vmid, $settings, $default_storage) = @_;
a0d1b1a2 46
ae57f6b3
DM		 47 PVE::QemuServer::foreach_drive($settings, sub {
48 my ($ds, $drive) = @_;
a0d1b1a2 49
ae57f6b3 50 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
a0d1b1a2 51
ae57f6b3 52 my $volid = $drive->{file};
a0d1b1a2 53
09d0ee64
DM		 54 if (!$volid || $volid eq 'none') {
55 # nothing to check
f5782fd0
DM		 56 } elsif ($isCDROM && ($volid eq 'cdrom')) {
57 $rpcenv->check($authuser, "/", ['Sys.Console']);
09d0ee64 58 } elsif (!$isCDROM && ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/)) {
a0d1b1a2
DM		 59 my ($storeid, $size) = ($2 || $default_storage, $3);
60 die "no storage ID specified (and no default storage)\n" if !$storeid;
fcbb753e 61 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
a0d1b1a2 62 } else {
8b192abf 63 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
a0d1b1a2
DM		 64 }
65 });
ae57f6b3 66};
a0d1b1a2 67
9418baad 68my $check_storage_access_clone = sub {
81f043eb 69 my ($rpcenv, $authuser, $storecfg, $conf, $storage) = @_;
6116f729 70
55173c6b
DM		 71 my $sharedvm = 1;
72
6116f729
DM		 73 PVE::QemuServer::foreach_drive($conf, sub {
74 my ($ds, $drive) = @_;
75
76 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
77
78 my $volid = $drive->{file};
79
80 return if !$volid || $volid eq 'none';
81
82 if ($isCDROM) {
83 if ($volid eq 'cdrom') {
84 $rpcenv->check($authuser, "/", ['Sys.Console']);
85 } else {
75466c4f 86 # we simply allow access
55173c6b
DM		 87 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid);
88 my $scfg = PVE::Storage::storage_config($storecfg, $sid);
89 $sharedvm = 0 if !$scfg->{shared};
90
6116f729
DM		 91 }
92 } else {
55173c6b
DM		 93 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid);
94 my $scfg = PVE::Storage::storage_config($storecfg, $sid);
95 $sharedvm = 0 if !$scfg->{shared};
96
81f043eb 97 $sid = $storage if $storage;
6116f729
DM		 98 $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
99 }
100 });
55173c6b
DM		 101
102 return $sharedvm;
6116f729
DM		 103};
104
ae57f6b3
DM		 105# Note: $pool is only needed when creating a VM, because pool permissions
106# are automatically inherited if VM already exists inside a pool.
107my $create_disks = sub {
108 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $settings, $default_storage) = @_;
a0d1b1a2
DM		 109
110 my $vollist = [];
a0d1b1a2 111
ae57f6b3
DM		 112 my $res = {};
113 PVE::QemuServer::foreach_drive($settings, sub {
114 my ($ds, $disk) = @_;
115
116 my $volid = $disk->{file};
117
f5782fd0 118 if (!$volid || $volid eq 'none' || $volid eq 'cdrom') {
628e9a2b
AD		 119 delete $disk->{size};
120 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
09d0ee64 121 } elsif ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/) {
ae57f6b3
DM		 122 my ($storeid, $size) = ($2 || $default_storage, $3);
123 die "no storage ID specified (and no default storage)\n" if !$storeid;
124 my $defformat = PVE::Storage::storage_default_format($storecfg, $storeid);
125 my $fmt = $disk->{format} || $defformat;
1a35631a
DC		 126
127 my $volid;
128 if ($ds eq 'efidisk0') {
129 # handle efidisk
130 my $ovmfvars = '/usr/share/kvm/OVMF_VARS-pure-efi.fd';
131 die "uefi vars image not found\n" if ! -f $ovmfvars;
132 $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
133 $fmt, undef, 128);
134 $disk->{file} = $volid;
135 $disk->{size} = 128*1024;
136 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
137 my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
138 my $qemufmt = PVE::QemuServer::qemu_img_format($scfg, $volname);
139 my $path = PVE::Storage::path($storecfg, $volid);
02daf96a 140 my $efidiskcmd = ['/usr/bin/qemu-img', 'convert', '-n', '-f', 'raw', '-O', $qemufmt];
1a35631a
DC		 141 push @$efidiskcmd, $ovmfvars;
142 push @$efidiskcmd, $path;
02daf96a
DC		 143
144 PVE::Storage::activate_volumes($storecfg, [$volid]);
145
1a35631a
DC		 146 eval { PVE::Tools::run_command($efidiskcmd); };
147 my $err = $@;
148 die "Copying of EFI Vars image failed: $err" if $err;
149 } else {
150 $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
151 $fmt, undef, $size*1024*1024);
152 $disk->{file} = $volid;
153 $disk->{size} = $size*1024*1024*1024;
154 }
a0d1b1a2 155 push @$vollist, $volid;
ae57f6b3
DM		 156 delete $disk->{format}; # no longer needed
157 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
158 } else {
eabe0da0 159
c9928b3d 160 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
75466c4f 161
7043d946 162 my $volid_is_new = 1;
35cb731c 163
7043d946
DM		 164 if ($conf->{$ds}) {
165 my $olddrive = PVE::QemuServer::parse_drive($ds, $conf->{$ds});
166 $volid_is_new = undef if $olddrive->{file} && $olddrive->{file} eq $volid;
eabe0da0 167 }
75466c4f 168
d52b8b77 169 if ($volid_is_new) {
09a89895 170
7043d946
DM		 171 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
172
09a89895 173 PVE::Storage::activate_volumes($storecfg, [ $volid ]) if $storeid;
d52b8b77
DM		 174
175 my $size = PVE::Storage::volume_size_info($storecfg, $volid);
176
177 die "volume $volid does not exists\n" if !$size;
178
179 $disk->{size} = $size;
09a89895 180 }
24afaca0 181
24afaca0 182 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
a0d1b1a2 183 }
ae57f6b3 184 });
a0d1b1a2
DM		 185
186 # free allocated images on error
187 if (my $err = $@) {
188 syslog('err', "VM $vmid creating disks failed");
189 foreach my $volid (@$vollist) {
190 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
191 warn $@ if $@;
192 }
193 die $err;
194 }
195
196 # modify vm config if everything went well
ae57f6b3
DM		 197 foreach my $ds (keys %$res) {
198 $conf->{$ds} = $res->{$ds};
a0d1b1a2
DM		 199 }
200
201 return $vollist;
202};
203
58cb690b
DC		 204my $cpuoptions = {
205 'cores' => 1,
206 'cpu' => 1,
207 'cpulimit' => 1,
208 'cpuunits' => 1,
209 'numa' => 1,
210 'smp' => 1,
211 'sockets' => 1,
84b31f48 212 'vcpus' => 1,
58cb690b
DC		 213};
214
215my $memoryoptions = {
216 'memory' => 1,
217 'balloon' => 1,
218 'shares' => 1,
219};
220
221my $hwtypeoptions = {
222 'acpi' => 1,
223 'hotplug' => 1,
224 'kvm' => 1,
225 'machine' => 1,
226 'scsihw' => 1,
227 'smbios1' => 1,
228 'tablet' => 1,
229 'vga' => 1,
230 'watchdog' => 1,
231};
232
6bcacc21 233my $generaloptions = {
58cb690b
DC		 234 'agent' => 1,
235 'autostart' => 1,
236 'bios' => 1,
237 'description' => 1,
238 'keyboard' => 1,
239 'localtime' => 1,
240 'migrate_downtime' => 1,
241 'migrate_speed' => 1,
242 'name' => 1,
243 'onboot' => 1,
244 'ostype' => 1,
245 'protection' => 1,
246 'reboot' => 1,
247 'startdate' => 1,
248 'startup' => 1,
249 'tdf' => 1,
250 'template' => 1,
251};
252
253my $vmpoweroptions = {
254 'freeze' => 1,
255};
256
257my $diskoptions = {
258 'boot' => 1,
259 'bootdisk' => 1,
260};
261
a0d1b1a2 262my $check_vm_modify_config_perm = sub {
ae57f6b3 263 my ($rpcenv, $authuser, $vmid, $pool, $key_list) = @_;
a0d1b1a2 264
6e5c4da7 265 return 1 if $authuser eq 'root@pam';
a0d1b1a2 266
ae57f6b3 267 foreach my $opt (@$key_list) {
a0d1b1a2 268 # disk checks need to be done somewhere else
74479ee9 269 next if PVE::QemuServer::is_valid_drivename($opt);
58cb690b 270 next if $opt eq 'cdrom';
63d269d7 271 next if $opt =~ m/^unused\d+$/;
a0d1b1a2 272
6bcacc21 273 if ($cpuoptions->{$opt} || $opt =~ m/^numa\d+$/) {
a0d1b1a2 274 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.CPU']);
58cb690b 275 } elsif ($memoryoptions->{$opt}) {
a0d1b1a2 276 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Memory']);
58cb690b 277 } elsif ($hwtypeoptions->{$opt}) {
a0d1b1a2 278 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.HWType']);
6bcacc21 279 } elsif ($generaloptions->{$opt}) {
58cb690b
DC		 280 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Options']);
281 # special case for startup since it changes host behaviour
282 if ($opt eq 'startup') {
283 $rpcenv->check_full($authuser, "/", ['Sys.Modify']);
284 }
285 } elsif ($vmpoweroptions->{$opt}) {
286 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.PowerMgmt']);
287 } elsif ($diskoptions->{$opt}) {
288 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
a0d1b1a2
DM		 289 } elsif ($opt =~ m/^net\d+$/) {
290 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']);
291 } else {
58cb690b
DC		 292 # catches usb\d+, hostpci\d+, args, lock, etc.
293 # new options will be checked here
294 die "only root can set '$opt' config\n";
a0d1b1a2
DM		 295 }
296 }
297
298 return 1;
299};
300
1e3baf05 301__PACKAGE__->register_method({
afdb31d5
DM		 302 name => 'vmlist',
303 path => '',
1e3baf05
DM		 304 method => 'GET',
305 description => "Virtual machine index (per node).",
a0d1b1a2
DM		 306 permissions => {
307 description => "Only list VMs where you have VM.Audit permissons on /vms/<vmid>.",
308 user => 'all',
309 },
1e3baf05
DM		 310 proxyto => 'node',
311 protected => 1, # qemu pid files are only readable by root
312 parameters => {
313 additionalProperties => 0,
314 properties => {
315 node => get_standard_option('pve-node'),
12612b09
WB		 316 full => {
317 type => 'boolean',
318 optional => 1,
319 description => "Determine the full status of active VMs.",
320 },
1e3baf05
DM		 321 },
322 },
323 returns => {
324 type => 'array',
325 items => {
326 type => "object",
327 properties => {},
328 },
329 links => [ { rel => 'child', href => "{vmid}" } ],
330 },
331 code => sub {
332 my ($param) = @_;
333
a0d1b1a2
DM		 334 my $rpcenv = PVE::RPCEnvironment::get();
335 my $authuser = $rpcenv->get_user();
336
12612b09 337 my $vmstatus = PVE::QemuServer::vmstatus(undef, $param->{full});
1e3baf05 338
a0d1b1a2
DM		 339 my $res = [];
340 foreach my $vmid (keys %$vmstatus) {
341 next if !$rpcenv->check($authuser, "/vms/$vmid", [ 'VM.Audit' ], 1);
342
343 my $data = $vmstatus->{$vmid};
184955dc 344 $data->{vmid} = int($vmid);
a0d1b1a2
DM		 345 push @$res, $data;
346 }
1e3baf05 347
a0d1b1a2 348 return $res;
1e3baf05
DM		 349 }});
350
d703d4c0 351
d703d4c0 352
1e3baf05 353__PACKAGE__->register_method({
afdb31d5
DM		 354 name => 'create_vm',
355 path => '',
1e3baf05 356 method => 'POST',
3e16d5fc 357 description => "Create or restore a virtual machine.",
a0d1b1a2 358 permissions => {
f9bfceef
DM		 359 description => "You need 'VM.Allocate' permissions on /vms/{vmid} or on the VM pool /pool/{pool}. " .
360 "For restore (option 'archive'), it is enough if the user has 'VM.Backup' permission and the VM already exists. " .
361 "If you create disks you need 'Datastore.AllocateSpace' on any used storage.",
362 user => 'all', # check inside
a0d1b1a2 363 },
1e3baf05
DM		 364 protected => 1,
365 proxyto => 'node',
366 parameters => {
367 additionalProperties => 0,
368 properties => PVE::QemuServer::json_config_properties(
369 {
370 node => get_standard_option('pve-node'),
65e866e5 371 vmid => get_standard_option('pve-vmid', { completion => \&PVE::Cluster::complete_next_vmid }),
3e16d5fc
DM		 372 archive => {
373 description => "The backup file.",
374 type => 'string',
375 optional => 1,
376 maxLength => 255,
65e866e5 377 completion => \&PVE::QemuServer::complete_backup_archives,
3e16d5fc
DM		 378 },
379 storage => get_standard_option('pve-storage-id', {
380 description => "Default storage.",
381 optional => 1,
335af808 382 completion => \&PVE::QemuServer::complete_storage,
3e16d5fc
DM		 383 }),
384 force => {
afdb31d5 385 optional => 1,
3e16d5fc
DM		 386 type => 'boolean',
387 description => "Allow to overwrite existing VM.",
51586c3a
DM		 388 requires => 'archive',
389 },
390 unique => {
afdb31d5 391 optional => 1,
51586c3a
DM		 392 type => 'boolean',
393 description => "Assign a unique random ethernet address.",
394 requires => 'archive',
3e16d5fc 395 },
75466c4f 396 pool => {
a0d1b1a2
DM		 397 optional => 1,
398 type => 'string', format => 'pve-poolid',
399 description => "Add the VM to the specified pool.",
400 },
1e3baf05
DM		 401 }),
402 },
afdb31d5 403 returns => {
5fdbe4f0
DM		 404 type => 'string',
405 },
1e3baf05
DM		 406 code => sub {
407 my ($param) = @_;
408
5fdbe4f0
DM		 409 my $rpcenv = PVE::RPCEnvironment::get();
410
a0d1b1a2 411 my $authuser = $rpcenv->get_user();
5fdbe4f0 412
1e3baf05
DM		 413 my $node = extract_param($param, 'node');
414
1e3baf05
DM		 415 my $vmid = extract_param($param, 'vmid');
416
3e16d5fc
DM		 417 my $archive = extract_param($param, 'archive');
418
419 my $storage = extract_param($param, 'storage');
420
51586c3a
DM		 421 my $force = extract_param($param, 'force');
422
423 my $unique = extract_param($param, 'unique');
75466c4f 424
a0d1b1a2 425 my $pool = extract_param($param, 'pool');
51586c3a 426
ffda963f 427 my $filename = PVE::QemuConfig->config_file($vmid);
afdb31d5
DM		 428
429 my $storecfg = PVE::Storage::config();
1e3baf05 430
3e16d5fc 431 PVE::Cluster::check_cfs_quorum();
1e3baf05 432
a0d1b1a2
DM		 433 if (defined($pool)) {
434 $rpcenv->check_pool_exist($pool);
75466c4f 435 }
a0d1b1a2 436
fcbb753e 437 $rpcenv->check($authuser, "/storage/$storage", ['Datastore.AllocateSpace'])
a0d1b1a2
DM		 438 if defined($storage);
439
f9bfceef
DM		 440 if ($rpcenv->check($authuser, "/vms/$vmid", ['VM.Allocate'], 1)) {
441 # OK
442 } elsif ($pool && $rpcenv->check($authuser, "/pool/$pool", ['VM.Allocate'], 1)) {
443 # OK
444 } elsif ($archive && $force && (-f $filename) &&
445 $rpcenv->check($authuser, "/vms/$vmid", ['VM.Backup'], 1)) {
446 # OK: user has VM.Backup permissions, and want to restore an existing VM
447 } else {
448 raise_perm_exc();
449 }
450
afdb31d5 451 if (!$archive) {
3e16d5fc 452 &$resolve_cdrom_alias($param);
1e3baf05 453
fcbb753e 454 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param, $storage);
ae57f6b3
DM		 455
456 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, $pool, [ keys %$param]);
457
3e16d5fc 458 foreach my $opt (keys %$param) {
74479ee9 459 if (PVE::QemuServer::is_valid_drivename($opt)) {
3e16d5fc
DM		 460 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
461 raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
afdb31d5 462
3e16d5fc
DM		 463 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
464 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
465 }
1e3baf05 466 }
3e16d5fc
DM		 467
468 PVE::QemuServer::add_random_macs($param);
51586c3a
DM		 469 } else {
470 my $keystr = join(' ', keys %$param);
bc4dcb99
DM		 471 raise_param_exc({ archive => "option conflicts with other options ($keystr)"}) if $keystr;
472
5b9d692a 473 if ($archive eq '-') {
afdb31d5 474 die "pipe requires cli environment\n"
d7810bc1 475 if $rpcenv->{type} ne 'cli';
5b9d692a 476 } else {
c9928b3d
DM		 477 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $archive);
478 $archive = PVE::Storage::abs_filesystem_path($storecfg, $archive);
971f27c4 479 }
1e3baf05
DM		 480 }
481
3e16d5fc 482 my $restorefn = sub {
4d8d55f1 483 my $vmlist = PVE::Cluster::get_vmlist();
4d8d55f1 484 if ($vmlist->{ids}->{$vmid}) {
0152058a
DM		 485 my $current_node = $vmlist->{ids}->{$vmid}->{node};
486 if ($current_node eq $node) {
ffda963f 487 my $conf = PVE::QemuConfig->load_config($vmid);
3e16d5fc 488
ffda963f 489 PVE::QemuConfig->check_protection($conf, "unable to restore VM $vmid");
3e16d5fc 490
4d8d55f1
AG		 491 die "unable to restore vm $vmid - config file already exists\n"
492 if !$force;
493
494 die "unable to restore vm $vmid - vm is running\n"
495 if PVE::QemuServer::check_running($vmid);
3a07a8a9
FG		 496
497 die "unable to restore vm $vmid - vm is a template\n"
498 if PVE::QemuConfig->is_template($conf);
499
4d8d55f1 500 } else {
0152058a 501 die "unable to restore vm $vmid - already existing on cluster node '$current_node'\n";
4d8d55f1 502 }
3e16d5fc
DM		 503 }
504
505 my $realcmd = sub {
a0d1b1a2 506 PVE::QemuServer::restore_archive($archive, $vmid, $authuser, {
51586c3a 507 storage => $storage,
a0d1b1a2 508 pool => $pool,
51586c3a 509 unique => $unique });
502d18a2 510
be517049 511 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
3e16d5fc
DM		 512 };
513
a0d1b1a2 514 return $rpcenv->fork_worker('qmrestore', $vmid, $authuser, $realcmd);
3e16d5fc 515 };
1e3baf05 516
1e3baf05
DM		 517 my $createfn = sub {
518
191435c6 519 # test after locking
5f20325f 520 PVE::Cluster::check_vmid_unused($vmid);
1e3baf05 521
5fdbe4f0 522 my $realcmd = sub {
1e3baf05 523
5fdbe4f0 524 my $vollist = [];
1e3baf05 525
1858638f
DM		 526 my $conf = $param;
527
5fdbe4f0 528 eval {
ae57f6b3 529
1858638f 530 $vollist = &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $param, $storage);
1e3baf05 531
5fdbe4f0 532 # try to be smart about bootdisk
74479ee9 533 my @disks = PVE::QemuServer::valid_drive_names();
5fdbe4f0
DM		 534 my $firstdisk;
535 foreach my $ds (reverse @disks) {
1858638f
DM		 536 next if !$conf->{$ds};
537 my $disk = PVE::QemuServer::parse_drive($ds, $conf->{$ds});
5fdbe4f0
DM		 538 next if PVE::QemuServer::drive_is_cdrom($disk);
539 $firstdisk = $ds;
540 }
1e3baf05 541
1858638f
DM		 542 if (!$conf->{bootdisk} && $firstdisk) {
543 $conf->{bootdisk} = $firstdisk;
5fdbe4f0 544 }
1e3baf05 545
47314bf5
DM		 546 # auto generate uuid if user did not specify smbios1 option
547 if (!$conf->{smbios1}) {
548 my ($uuid, $uuid_str);
549 UUID::generate($uuid);
550 UUID::unparse($uuid, $uuid_str);
551 $conf->{smbios1} = "uuid=$uuid_str";
552 }
553
ffda963f 554 PVE::QemuConfig->write_config($vmid, $conf);
ae9ca91d 555
5fdbe4f0
DM		 556 };
557 my $err = $@;
1e3baf05 558
5fdbe4f0
DM		 559 if ($err) {
560 foreach my $volid (@$vollist) {
561 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
562 warn $@ if $@;
563 }
564 die "create failed - $err";
565 }
502d18a2 566
be517049 567 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
5fdbe4f0
DM		 568 };
569
a0d1b1a2 570 return $rpcenv->fork_worker('qmcreate', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 571 };
572
ffda963f 573 return PVE::QemuConfig->lock_config_full($vmid, 1, $archive ? $restorefn : $createfn);
1e3baf05
DM		 574 }});
575
576__PACKAGE__->register_method({
577 name => 'vmdiridx',
afdb31d5 578 path => '{vmid}',
1e3baf05
DM		 579 method => 'GET',
580 proxyto => 'node',
581 description => "Directory index",
a0d1b1a2
DM		 582 permissions => {
583 user => 'all',
584 },
1e3baf05
DM		 585 parameters => {
586 additionalProperties => 0,
587 properties => {
588 node => get_standard_option('pve-node'),
589 vmid => get_standard_option('pve-vmid'),
590 },
591 },
592 returns => {
593 type => 'array',
594 items => {
595 type => "object",
596 properties => {
597 subdir => { type => 'string' },
598 },
599 },
600 links => [ { rel => 'child', href => "{subdir}" } ],
601 },
602 code => sub {
603 my ($param) = @_;
604
605 my $res = [
606 { subdir => 'config' },
df2a2dbb 607 { subdir => 'pending' },
1e3baf05
DM		 608 { subdir => 'status' },
609 { subdir => 'unlink' },
610 { subdir => 'vncproxy' },
3ea94c60 611 { subdir => 'migrate' },
2f48a4f5 612 { subdir => 'resize' },
586bfa78 613 { subdir => 'move' },
1e3baf05
DM		 614 { subdir => 'rrd' },
615 { subdir => 'rrddata' },
91c94f0a 616 { subdir => 'monitor' },
7e7d7b61 617 { subdir => 'snapshot' },
288eeea8 618 { subdir => 'spiceproxy' },
7aa608d6 619 { subdir => 'sendkey' },
228a998b 620 { subdir => 'firewall' },
1e3baf05 621 ];
afdb31d5 622
1e3baf05
DM		 623 return $res;
624 }});
625
228a998b 626__PACKAGE__->register_method ({
f34ebd52 627 subclass => "PVE::API2::Firewall::VM",
228a998b
DM		 628 path => '{vmid}/firewall',
629});
630
1e3baf05 631__PACKAGE__->register_method({
afdb31d5
DM		 632 name => 'rrd',
633 path => '{vmid}/rrd',
1e3baf05
DM		 634 method => 'GET',
635 protected => 1, # fixme: can we avoid that?
636 permissions => {
378b359e 637 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 638 },
639 description => "Read VM RRD statistics (returns PNG)",
640 parameters => {
641 additionalProperties => 0,
642 properties => {
643 node => get_standard_option('pve-node'),
644 vmid => get_standard_option('pve-vmid'),
645 timeframe => {
646 description => "Specify the time frame you are interested in.",
647 type => 'string',
648 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
649 },
650 ds => {
651 description => "The list of datasources you want to display.",
652 type => 'string', format => 'pve-configid-list',
653 },
654 cf => {
655 description => "The RRD consolidation function",
656 type => 'string',
657 enum => [ 'AVERAGE', 'MAX' ],
658 optional => 1,
659 },
660 },
661 },
662 returns => {
663 type => "object",
664 properties => {
665 filename => { type => 'string' },
666 },
667 },
668 code => sub {
669 my ($param) = @_;
670
671 return PVE::Cluster::create_rrd_graph(
afdb31d5 672 "pve2-vm/$param->{vmid}", $param->{timeframe},
1e3baf05 673 $param->{ds}, $param->{cf});
afdb31d5 674
1e3baf05
DM		 675 }});
676
677__PACKAGE__->register_method({
afdb31d5
DM		 678 name => 'rrddata',
679 path => '{vmid}/rrddata',
1e3baf05
DM		 680 method => 'GET',
681 protected => 1, # fixme: can we avoid that?
682 permissions => {
378b359e 683 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 684 },
685 description => "Read VM RRD statistics",
686 parameters => {
687 additionalProperties => 0,
688 properties => {
689 node => get_standard_option('pve-node'),
690 vmid => get_standard_option('pve-vmid'),
691 timeframe => {
692 description => "Specify the time frame you are interested in.",
693 type => 'string',
694 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
695 },
696 cf => {
697 description => "The RRD consolidation function",
698 type => 'string',
699 enum => [ 'AVERAGE', 'MAX' ],
700 optional => 1,
701 },
702 },
703 },
704 returns => {
705 type => "array",
706 items => {
707 type => "object",
708 properties => {},
709 },
710 },
711 code => sub {
712 my ($param) = @_;
713
714 return PVE::Cluster::create_rrd_data(
715 "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{cf});
716 }});
717
718
719__PACKAGE__->register_method({
afdb31d5
DM		 720 name => 'vm_config',
721 path => '{vmid}/config',
1e3baf05
DM		 722 method => 'GET',
723 proxyto => 'node',
1e7f2726 724 description => "Get current virtual machine configuration. This does not include pending configuration changes (see 'pending' API).",
a0d1b1a2
DM		 725 permissions => {
726 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
727 },
1e3baf05
DM		 728 parameters => {
729 additionalProperties => 0,
730 properties => {
731 node => get_standard_option('pve-node'),
335af808 732 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
6d89b548
DM		 733 current => {
734 description => "Get current values (instead of pending values).",
735 optional => 1,
736 default => 0,
737 type => 'boolean',
738 },
1e3baf05
DM		 739 },
740 },
afdb31d5 741 returns => {
1e3baf05 742 type => "object",
554ac7e7
DM		 743 properties => {
744 digest => {
745 type => 'string',
746 description => 'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
747 }
748 },
1e3baf05
DM		 749 },
750 code => sub {
751 my ($param) = @_;
752
ffda963f 753 my $conf = PVE::QemuConfig->load_config($param->{vmid});
1e3baf05 754
22c377f0 755 delete $conf->{snapshots};
6d89b548
DM		 756
757 if (!$param->{current}) {
025e1d90 758 foreach my $opt (keys %{$conf->{pending}}) {
6d89b548
DM		 759 next if $opt eq 'delete';
760 my $value = $conf->{pending}->{$opt};
761 next if ref($value); # just to be sure
762 $conf->{$opt} = $value;
763 }
1bc483f6
WB		 764 my $pending_delete_hash = PVE::QemuServer::split_flagged_list($conf->{pending}->{delete});
765 foreach my $opt (keys %$pending_delete_hash) {
6d89b548
DM		 766 delete $conf->{$opt} if $conf->{$opt};
767 }
768 }
769
1e7f2726 770 delete $conf->{pending};
22c377f0 771
1e3baf05
DM		 772 return $conf;
773 }});
774
1e7f2726
DM		 775__PACKAGE__->register_method({
776 name => 'vm_pending',
777 path => '{vmid}/pending',
778 method => 'GET',
779 proxyto => 'node',
780 description => "Get virtual machine configuration, including pending changes.",
781 permissions => {
782 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
783 },
784 parameters => {
785 additionalProperties => 0,
786 properties => {
787 node => get_standard_option('pve-node'),
335af808 788 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
1e7f2726
DM		 789 },
790 },
791 returns => {
792 type => "array",
793 items => {
794 type => "object",
795 properties => {
796 key => {
797 description => "Configuration option name.",
798 type => 'string',
799 },
800 value => {
801 description => "Current value.",
802 type => 'string',
803 optional => 1,
804 },
805 pending => {
806 description => "Pending value.",
807 type => 'string',
808 optional => 1,
809 },
810 delete => {
1bc483f6
WB		 811 description => "Indicates a pending delete request if present and not 0. " .
812 "The value 2 indicates a force-delete request.",
813 type => 'integer',
814 minimum => 0,
815 maximum => 2,
1e7f2726
DM		 816 optional => 1,
817 },
818 },
819 },
820 },
821 code => sub {
822 my ($param) = @_;
823
ffda963f 824 my $conf = PVE::QemuConfig->load_config($param->{vmid});
1e7f2726 825
1bc483f6 826 my $pending_delete_hash = PVE::QemuServer::split_flagged_list($conf->{pending}->{delete});
1e7f2726
DM		 827
828 my $res = [];
829
025e1d90 830 foreach my $opt (keys %$conf) {
1e7f2726
DM		 831 next if ref($conf->{$opt});
832 my $item = { key => $opt };
833 $item->{value} = $conf->{$opt} if defined($conf->{$opt});
834 $item->{pending} = $conf->{pending}->{$opt} if defined($conf->{pending}->{$opt});
1bc483f6 835 $item->{delete} = ($pending_delete_hash->{$opt} ? 2 : 1) if exists $pending_delete_hash->{$opt};
1e7f2726
DM		 836 push @$res, $item;
837 }
838
025e1d90 839 foreach my $opt (keys %{$conf->{pending}}) {
1e7f2726
DM		 840 next if $opt eq 'delete';
841 next if ref($conf->{pending}->{$opt}); # just to be sure
0e54e1c8 842 next if defined($conf->{$opt});
1e7f2726
DM		 843 my $item = { key => $opt };
844 $item->{pending} = $conf->{pending}->{$opt};
845 push @$res, $item;
846 }
847
1bc483f6 848 while (my ($opt, $force) = each %$pending_delete_hash) {
1e7f2726
DM		 849 next if $conf->{pending}->{$opt}; # just to be sure
850 next if $conf->{$opt};
1bc483f6 851 my $item = { key => $opt, delete => ($force ? 2 : 1)};
1e7f2726
DM		 852 push @$res, $item;
853 }
854
855 return $res;
856 }});
857
5555edea
DM		 858# POST/PUT {vmid}/config implementation
859#
860# The original API used PUT (idempotent) an we assumed that all operations
861# are fast. But it turned out that almost any configuration change can
862# involve hot-plug actions, or disk alloc/free. Such actions can take long
863# time to complete and have side effects (not idempotent).
864#
7043d946 865# The new implementation uses POST and forks a worker process. We added
5555edea 866# a new option 'background_delay'. If specified we wait up to
7043d946 867# 'background_delay' second for the worker task to complete. It returns null
5555edea 868# if the task is finished within that time, else we return the UPID.
7043d946 869
5555edea
DM		 870my $update_vm_api = sub {
871 my ($param, $sync) = @_;
a0d1b1a2 872
5555edea 873 my $rpcenv = PVE::RPCEnvironment::get();
1e3baf05 874
5555edea 875 my $authuser = $rpcenv->get_user();
1e3baf05 876
5555edea 877 my $node = extract_param($param, 'node');
1e3baf05 878
5555edea 879 my $vmid = extract_param($param, 'vmid');
1e3baf05 880
5555edea 881 my $digest = extract_param($param, 'digest');
1e3baf05 882
5555edea 883 my $background_delay = extract_param($param, 'background_delay');
1e3baf05 884
5555edea
DM		 885 my @paramarr = (); # used for log message
886 foreach my $key (keys %$param) {
c13e17d0 887 push @paramarr, "-$key", $param->{$key};
5555edea 888 }
0532bc63 889
5555edea
DM		 890 my $skiplock = extract_param($param, 'skiplock');
891 raise_param_exc({ skiplock => "Only root may use this option." })
892 if $skiplock && $authuser ne 'root@pam';
1e3baf05 893
5555edea 894 my $delete_str = extract_param($param, 'delete');
0532bc63 895
d3df8cf3
DM		 896 my $revert_str = extract_param($param, 'revert');
897
5555edea 898 my $force = extract_param($param, 'force');
1e68cb19 899
d3df8cf3 900 die "no options specified\n" if !$delete_str && !$revert_str && !scalar(keys %$param);
7bfdeb5f 901
5555edea 902 my $storecfg = PVE::Storage::config();
1e68cb19 903
5555edea 904 my $defaults = PVE::QemuServer::load_defaults();
1e68cb19 905
5555edea 906 &$resolve_cdrom_alias($param);
0532bc63 907
5555edea 908 # now try to verify all parameters
ae57f6b3 909
d3df8cf3
DM		 910 my $revert = {};
911 foreach my $opt (PVE::Tools::split_list($revert_str)) {
912 if (!PVE::QemuServer::option_exists($opt)) {
913 raise_param_exc({ revert => "unknown option '$opt'" });
914 }
915
916 raise_param_exc({ delete => "you can't use '-$opt' and " .
917 "-revert $opt' at the same time" })
918 if defined($param->{$opt});
919
920 $revert->{$opt} = 1;
921 }
922
5555edea
DM		 923 my @delete = ();
924 foreach my $opt (PVE::Tools::split_list($delete_str)) {
925 $opt = 'ide2' if $opt eq 'cdrom';
d3df8cf3 926
5555edea
DM		 927 raise_param_exc({ delete => "you can't use '-$opt' and " .
928 "-delete $opt' at the same time" })
929 if defined($param->{$opt});
7043d946 930
d3df8cf3
DM		 931 raise_param_exc({ revert => "you can't use '-delete $opt' and " .
932 "-revert $opt' at the same time" })
933 if $revert->{$opt};
934
5555edea
DM		 935 if (!PVE::QemuServer::option_exists($opt)) {
936 raise_param_exc({ delete => "unknown option '$opt'" });
0532bc63 937 }
1e3baf05 938
5555edea
DM		 939 push @delete, $opt;
940 }
941
942 foreach my $opt (keys %$param) {
74479ee9 943 if (PVE::QemuServer::is_valid_drivename($opt)) {
5555edea
DM		 944 # cleanup drive path
945 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
946 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
947 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
948 } elsif ($opt =~ m/^net(\d+)$/) {
949 # add macaddr
950 my $net = PVE::QemuServer::parse_net($param->{$opt});
951 $param->{$opt} = PVE::QemuServer::print_net($net);
1e68cb19 952 }
5555edea 953 }
1e3baf05 954
5555edea 955 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [@delete]);
ae57f6b3 956
5555edea 957 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [keys %$param]);
ae57f6b3 958
5555edea 959 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param);
1e3baf05 960
5555edea 961 my $updatefn = sub {
1e3baf05 962
ffda963f 963 my $conf = PVE::QemuConfig->load_config($vmid);
1e3baf05 964
5555edea
DM		 965 die "checksum missmatch (file change by other user?)\n"
966 if $digest && $digest ne $conf->{digest};
967
ffda963f 968 PVE::QemuConfig->check_lock($conf) if !$skiplock;
7043d946 969
d3df8cf3
DM		 970 foreach my $opt (keys %$revert) {
971 if (defined($conf->{$opt})) {
972 $param->{$opt} = $conf->{$opt};
973 } elsif (defined($conf->{pending}->{$opt})) {
974 push @delete, $opt;
975 }
976 }
977
5555edea 978 if ($param->{memory} || defined($param->{balloon})) {
6ca8b698
DM		 979 my $maxmem = $param->{memory} || $conf->{pending}->{memory} || $conf->{memory} || $defaults->{memory};
980 my $balloon = defined($param->{balloon}) ? $param->{balloon} : $conf->{pending}->{balloon} || $conf->{balloon};
7043d946 981
5555edea
DM		 982 die "balloon value too large (must be smaller than assigned memory)\n"
983 if $balloon && $balloon > $maxmem;
984 }
1e3baf05 985
5555edea 986 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: " . join (' ', @paramarr));
1e3baf05 987
5555edea 988 my $worker = sub {
7bfdeb5f 989
5555edea 990 print "update VM $vmid: " . join (' ', @paramarr) . "\n";
c2a64aa7 991
202d1f45
DM		 992 # write updates to pending section
993
3a11fadb
DM		 994 my $modified = {}; # record what $option we modify
995
202d1f45 996 foreach my $opt (@delete) {
3a11fadb 997 $modified->{$opt} = 1;
ffda963f 998 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
202d1f45 999 if ($opt =~ m/^unused/) {
202d1f45 1000 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
ffda963f 1001 PVE::QemuConfig->check_protection($conf, "can't remove unused disk '$drive->{file}'");
4d8d55f1 1002 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
3dc38fbb
WB		 1003 if (PVE::QemuServer::try_deallocate_drive($storecfg, $vmid, $conf, $opt, $drive, $rpcenv, $authuser)) {
1004 delete $conf->{$opt};
ffda963f 1005 PVE::QemuConfig->write_config($vmid, $conf);
202d1f45 1006 }
74479ee9 1007 } elsif (PVE::QemuServer::is_valid_drivename($opt)) {
ffda963f 1008 PVE::QemuConfig->check_protection($conf, "can't remove drive '$opt'");
202d1f45 1009 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
055d554d 1010 PVE::QemuServer::vmconfig_register_unused_drive($storecfg, $vmid, $conf, PVE::QemuServer::parse_drive($opt, $conf->{pending}->{$opt}))
202d1f45 1011 if defined($conf->{pending}->{$opt});
3dc38fbb 1012 PVE::QemuServer::vmconfig_delete_pending_option($conf, $opt, $force);
ffda963f 1013 PVE::QemuConfig->write_config($vmid, $conf);
202d1f45 1014 } else {
3dc38fbb 1015 PVE::QemuServer::vmconfig_delete_pending_option($conf, $opt, $force);
ffda963f 1016 PVE::QemuConfig->write_config($vmid, $conf);
202d1f45 1017 }
5d39a182 1018 }
1e3baf05 1019
202d1f45 1020 foreach my $opt (keys %$param) { # add/change
3a11fadb 1021 $modified->{$opt} = 1;
ffda963f 1022 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
202d1f45
DM		 1023 next if defined($conf->{pending}->{$opt}) && ($param->{$opt} eq $conf->{pending}->{$opt}); # skip if nothing changed
1024
74479ee9 1025 if (PVE::QemuServer::is_valid_drivename($opt)) {
202d1f45
DM		 1026 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
1027 if (PVE::QemuServer::drive_is_cdrom($drive)) { # CDROM
1028 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
1029 } else {
1030 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
1031 }
055d554d 1032 PVE::QemuServer::vmconfig_register_unused_drive($storecfg, $vmid, $conf, PVE::QemuServer::parse_drive($opt, $conf->{pending}->{$opt}))
202d1f45
DM		 1033 if defined($conf->{pending}->{$opt});
1034
1035 &$create_disks($rpcenv, $authuser, $conf->{pending}, $storecfg, $vmid, undef, {$opt => $param->{$opt}});
1036 } else {
1037 $conf->{pending}->{$opt} = $param->{$opt};
1038 }
055d554d 1039 PVE::QemuServer::vmconfig_undelete_pending_option($conf, $opt);
ffda963f 1040 PVE::QemuConfig->write_config($vmid, $conf);
202d1f45
DM		 1041 }
1042
1043 # remove pending changes when nothing changed
ffda963f 1044 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
c750e90a 1045 my $changes = PVE::QemuServer::vmconfig_cleanup_pending($conf);
ffda963f 1046 PVE::QemuConfig->write_config($vmid, $conf) if $changes;
202d1f45
DM		 1047
1048 return if !scalar(keys %{$conf->{pending}});
1049
7bfdeb5f 1050 my $running = PVE::QemuServer::check_running($vmid);
39001640
DM		 1051
1052 # apply pending changes
1053
ffda963f 1054 $conf = PVE::QemuConfig->load_config($vmid); # update/reload
39001640 1055
3a11fadb
DM		 1056 if ($running) {
1057 my $errors = {};
1058 PVE::QemuServer::vmconfig_hotplug_pending($vmid, $conf, $storecfg, $modified, $errors);
1059 raise_param_exc($errors) if scalar(keys %$errors);
1060 } else {
1061 PVE::QemuServer::vmconfig_apply_pending($vmid, $conf, $storecfg, $running);
1062 }
1e68cb19 1063
915d3481 1064 return;
5d39a182
DM		 1065 };
1066
5555edea
DM		 1067 if ($sync) {
1068 &$worker();
1069 return undef;
1070 } else {
1071 my $upid = $rpcenv->fork_worker('qmconfig', $vmid, $authuser, $worker);
fcdb0117 1072
5555edea
DM		 1073 if ($background_delay) {
1074
1075 # Note: It would be better to do that in the Event based HTTPServer
7043d946 1076 # to avoid blocking call to sleep.
5555edea
DM		 1077
1078 my $end_time = time() + $background_delay;
1079
1080 my $task = PVE::Tools::upid_decode($upid);
1081
1082 my $running = 1;
1083 while (time() < $end_time) {
1084 $running = PVE::ProcFSTools::check_process_running($task->{pid}, $task->{pstart});
1085 last if !$running;
1086 sleep(1); # this gets interrupted when child process ends
1087 }
1088
1089 if (!$running) {
1090 my $status = PVE::Tools::upid_read_status($upid);
1091 return undef if $status eq 'OK';
1092 die $status;
1093 }
7043d946 1094 }
5555edea
DM		 1095
1096 return $upid;
1097 }
1098 };
1099
ffda963f 1100 return PVE::QemuConfig->lock_config($vmid, $updatefn);
5555edea
DM		 1101};
1102
1103my $vm_config_perm_list = [
1104 'VM.Config.Disk',
1105 'VM.Config.CDROM',
1106 'VM.Config.CPU',
1107 'VM.Config.Memory',
1108 'VM.Config.Network',
1109 'VM.Config.HWType',
1110 'VM.Config.Options',
1111 ];
1112
1113__PACKAGE__->register_method({
1114 name => 'update_vm_async',
1115 path => '{vmid}/config',
1116 method => 'POST',
1117 protected => 1,
1118 proxyto => 'node',
1119 description => "Set virtual machine options (asynchrounous API).",
1120 permissions => {
1121 check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
1122 },
1123 parameters => {
1124 additionalProperties => 0,
1125 properties => PVE::QemuServer::json_config_properties(
1126 {
1127 node => get_standard_option('pve-node'),
1128 vmid => get_standard_option('pve-vmid'),
1129 skiplock => get_standard_option('skiplock'),
1130 delete => {
1131 type => 'string', format => 'pve-configid-list',
1132 description => "A list of settings you want to delete.",
1133 optional => 1,
1134 },
4c8365fa
DM		 1135 revert => {
1136 type => 'string', format => 'pve-configid-list',
1137 description => "Revert a pending change.",
1138 optional => 1,
1139 },
5555edea
DM		 1140 force => {
1141 type => 'boolean',
1142 description => $opt_force_description,
1143 optional => 1,
1144 requires => 'delete',
1145 },
1146 digest => {
1147 type => 'string',
1148 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
1149 maxLength => 40,
1150 optional => 1,
1151 },
1152 background_delay => {
1153 type => 'integer',
1154 description => "Time to wait for the task to finish. We return 'null' if the task finish within that time.",
1155 minimum => 1,
1156 maximum => 30,
1157 optional => 1,
1158 },
1159 }),
1160 },
1161 returns => {
1162 type => 'string',
1163 optional => 1,
1164 },
1165 code => $update_vm_api,
1166});
1167
1168__PACKAGE__->register_method({
1169 name => 'update_vm',
1170 path => '{vmid}/config',
1171 method => 'PUT',
1172 protected => 1,
1173 proxyto => 'node',
1174 description => "Set virtual machine options (synchrounous API) - You should consider using the POST method instead for any actions involving hotplug or storage allocation.",
1175 permissions => {
1176 check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
1177 },
1178 parameters => {
1179 additionalProperties => 0,
1180 properties => PVE::QemuServer::json_config_properties(
1181 {
1182 node => get_standard_option('pve-node'),
335af808 1183 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
5555edea
DM		 1184 skiplock => get_standard_option('skiplock'),
1185 delete => {
1186 type => 'string', format => 'pve-configid-list',
1187 description => "A list of settings you want to delete.",
1188 optional => 1,
1189 },
4c8365fa
DM		 1190 revert => {
1191 type => 'string', format => 'pve-configid-list',
1192 description => "Revert a pending change.",
1193 optional => 1,
1194 },
5555edea
DM		 1195 force => {
1196 type => 'boolean',
1197 description => $opt_force_description,
1198 optional => 1,
1199 requires => 'delete',
1200 },
1201 digest => {
1202 type => 'string',
1203 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
1204 maxLength => 40,
1205 optional => 1,
1206 },
1207 }),
1208 },
1209 returns => { type => 'null' },
1210 code => sub {
1211 my ($param) = @_;
1212 &$update_vm_api($param, 1);
1e3baf05 1213 return undef;
5555edea
DM		 1214 }
1215});
1e3baf05
DM		 1216
1217
1218__PACKAGE__->register_method({
afdb31d5
DM		 1219 name => 'destroy_vm',
1220 path => '{vmid}',
1e3baf05
DM		 1221 method => 'DELETE',
1222 protected => 1,
1223 proxyto => 'node',
1224 description => "Destroy the vm (also delete all used/owned volumes).",
a0d1b1a2
DM		 1225 permissions => {
1226 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
1227 },
1e3baf05
DM		 1228 parameters => {
1229 additionalProperties => 0,
1230 properties => {
1231 node => get_standard_option('pve-node'),
335af808 1232 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid_stopped }),
3ea94c60 1233 skiplock => get_standard_option('skiplock'),
1e3baf05
DM		 1234 },
1235 },
afdb31d5 1236 returns => {
5fdbe4f0
DM		 1237 type => 'string',
1238 },
1e3baf05
DM		 1239 code => sub {
1240 my ($param) = @_;
1241
1242 my $rpcenv = PVE::RPCEnvironment::get();
1243
a0d1b1a2 1244 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1245
1246 my $vmid = $param->{vmid};
1247
1248 my $skiplock = $param->{skiplock};
afdb31d5 1249 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1250 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1251
5fdbe4f0 1252 # test if VM exists
ffda963f 1253 my $conf = PVE::QemuConfig->load_config($vmid);
5fdbe4f0 1254
afdb31d5 1255 my $storecfg = PVE::Storage::config();
1e3baf05 1256
ffda963f 1257 PVE::QemuConfig->check_protection($conf, "can't remove VM $vmid");
cb0e4540 1258
952e3ac3
DM		 1259 die "unable to remove VM $vmid - used in HA resources\n"
1260 if PVE::HA::Config::vm_is_ha_managed($vmid);
e9f2f8e5 1261
db593da2
DM		 1262 # early tests (repeat after locking)
1263 die "VM $vmid is running - destroy failed\n"
1264 if PVE::QemuServer::check_running($vmid);
1265
5fdbe4f0 1266 my $realcmd = sub {
ff1a2432
DM		 1267 my $upid = shift;
1268
1269 syslog('info', "destroy VM $vmid: $upid\n");
1270
5fdbe4f0 1271 PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock);
502d18a2 1272
37f43805 1273 PVE::AccessControl::remove_vm_access($vmid);
e9abcde6
AG		 1274
1275 PVE::Firewall::remove_vmfw_conf($vmid);
5fdbe4f0 1276 };
1e3baf05 1277
a0d1b1a2 1278 return $rpcenv->fork_worker('qmdestroy', $vmid, $authuser, $realcmd);
1e3baf05
DM		 1279 }});
1280
1281__PACKAGE__->register_method({
afdb31d5
DM		 1282 name => 'unlink',
1283 path => '{vmid}/unlink',
1e3baf05
DM		 1284 method => 'PUT',
1285 protected => 1,
1286 proxyto => 'node',
1287 description => "Unlink/delete disk images.",
a0d1b1a2
DM		 1288 permissions => {
1289 check => [ 'perm', '/vms/{vmid}', ['VM.Config.Disk']],
1290 },
1e3baf05
DM		 1291 parameters => {
1292 additionalProperties => 0,
1293 properties => {
1294 node => get_standard_option('pve-node'),
335af808 1295 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
1e3baf05
DM		 1296 idlist => {
1297 type => 'string', format => 'pve-configid-list',
1298 description => "A list of disk IDs you want to delete.",
1299 },
1300 force => {
1301 type => 'boolean',
1302 description => $opt_force_description,
1303 optional => 1,
1304 },
1305 },
1306 },
1307 returns => { type => 'null'},
1308 code => sub {
1309 my ($param) = @_;
1310
1311 $param->{delete} = extract_param($param, 'idlist');
1312
1313 __PACKAGE__->update_vm($param);
1314
1315 return undef;
1316 }});
1317
1318my $sslcert;
1319
1320__PACKAGE__->register_method({
afdb31d5
DM		 1321 name => 'vncproxy',
1322 path => '{vmid}/vncproxy',
1e3baf05
DM		 1323 method => 'POST',
1324 protected => 1,
1325 permissions => {
378b359e 1326 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1e3baf05
DM		 1327 },
1328 description => "Creates a TCP VNC proxy connections.",
1329 parameters => {
1330 additionalProperties => 0,
1331 properties => {
1332 node => get_standard_option('pve-node'),
1333 vmid => get_standard_option('pve-vmid'),
b4d5c000
SP		 1334 websocket => {
1335 optional => 1,
1336 type => 'boolean',
1337 description => "starts websockify instead of vncproxy",
1338 },
1e3baf05
DM		 1339 },
1340 },
afdb31d5 1341 returns => {
1e3baf05
DM		 1342 additionalProperties => 0,
1343 properties => {
1344 user => { type => 'string' },
1345 ticket => { type => 'string' },
1346 cert => { type => 'string' },
1347 port => { type => 'integer' },
1348 upid => { type => 'string' },
1349 },
1350 },
1351 code => sub {
1352 my ($param) = @_;
1353
1354 my $rpcenv = PVE::RPCEnvironment::get();
1355
a0d1b1a2 1356 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1357
1358 my $vmid = $param->{vmid};
1359 my $node = $param->{node};
983d4582 1360 my $websocket = $param->{websocket};
1e3baf05 1361
ffda963f 1362 my $conf = PVE::QemuConfig->load_config($vmid, $node); # check if VM exists
ef5e2be2 1363
b6f39da2
DM		 1364 my $authpath = "/vms/$vmid";
1365
a0d1b1a2 1366 my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath);
b6f39da2 1367
1e3baf05
DM		 1368 $sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192)
1369 if !$sslcert;
1370
af0eba7e 1371 my ($remip, $family);
ef5e2be2 1372 my $remcmd = [];
afdb31d5 1373
4f1be36c 1374 if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
af0eba7e 1375 ($remip, $family) = PVE::Cluster::remote_node_ip($node);
b4d5c000 1376 # NOTE: kvm VNC traffic is already TLS encrypted or is known unsecure
ef5e2be2 1377 $remcmd = ['/usr/bin/ssh', '-T', '-o', 'BatchMode=yes', $remip];
af0eba7e
WB		 1378 } else {
1379 $family = PVE::Tools::get_host_address_family($node);
1e3baf05
DM		 1380 }
1381
af0eba7e
WB		 1382 my $port = PVE::Tools::next_vnc_port($family);
1383
afdb31d5 1384 my $timeout = 10;
1e3baf05
DM		 1385
1386 my $realcmd = sub {
1387 my $upid = shift;
1388
1389 syslog('info', "starting vnc proxy $upid\n");
1390
ef5e2be2 1391 my $cmd;
1e3baf05 1392
2dc23d72 1393 if ($conf->{vga} && ($conf->{vga} =~ m/^serial\d+$/)) {
ef5e2be2 1394
983d4582 1395 die "Websocket mode is not supported in vga serial mode!" if $websocket;
b4d5c000 1396
ef5e2be2
DM		 1397 my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga} ];
1398 #my $termcmd = "/usr/bin/qm terminal -iface $conf->{vga}";
1399 $cmd = ['/usr/bin/vncterm', '-rfbport', $port,
fa8ea931 1400 '-timeout', $timeout, '-authpath', $authpath,
ef5e2be2
DM		 1401 '-perm', 'Sys.Console', '-c', @$remcmd, @$termcmd];
1402 } else {
1e3baf05 1403
3e7567e0
DM		 1404 $ENV{LC_PVE_TICKET} = $ticket if $websocket; # set ticket with "qm vncproxy"
1405
ef5e2be2
DM		 1406 my $qmcmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
1407
1408 my $qmstr = join(' ', @$qmcmd);
1409
1410 # also redirect stderr (else we get RFB protocol errors)
d483fa01 1411 $cmd = ['/bin/nc6', '-l', '-p', $port, '-w', $timeout, '-e', "$qmstr 2>/dev/null"];
ef5e2be2 1412 }
1e3baf05 1413
be62c45c 1414 PVE::Tools::run_command($cmd);
1e3baf05
DM		 1415
1416 return;
1417 };
1418
a0d1b1a2 1419 my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd);
1e3baf05 1420
3da85107
DM		 1421 PVE::Tools::wait_for_vnc_port($port);
1422
1e3baf05 1423 return {
a0d1b1a2 1424 user => $authuser,
1e3baf05 1425 ticket => $ticket,
afdb31d5
DM		 1426 port => $port,
1427 upid => $upid,
1428 cert => $sslcert,
1e3baf05
DM		 1429 };
1430 }});
1431
3e7567e0
DM		 1432__PACKAGE__->register_method({
1433 name => 'vncwebsocket',
1434 path => '{vmid}/vncwebsocket',
1435 method => 'GET',
3e7567e0 1436 permissions => {
c422ce93 1437 description => "You also need to pass a valid ticket (vncticket).",
3e7567e0
DM		 1438 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1439 },
4d00f52f 1440 description => "Opens a weksocket for VNC traffic.",
3e7567e0
DM		 1441 parameters => {
1442 additionalProperties => 0,
1443 properties => {
1444 node => get_standard_option('pve-node'),
1445 vmid => get_standard_option('pve-vmid'),
c422ce93
DM		 1446 vncticket => {
1447 description => "Ticket from previous call to vncproxy.",
1448 type => 'string',
1449 maxLength => 512,
1450 },
3e7567e0
DM		 1451 port => {
1452 description => "Port number returned by previous vncproxy call.",
1453 type => 'integer',
1454 minimum => 5900,
1455 maximum => 5999,
1456 },
1457 },
1458 },
1459 returns => {
1460 type => "object",
1461 properties => {
1462 port => { type => 'string' },
1463 },
1464 },
1465 code => sub {
1466 my ($param) = @_;
1467
1468 my $rpcenv = PVE::RPCEnvironment::get();
1469
1470 my $authuser = $rpcenv->get_user();
1471
1472 my $vmid = $param->{vmid};
1473 my $node = $param->{node};
1474
c422ce93
DM		 1475 my $authpath = "/vms/$vmid";
1476
1477 PVE::AccessControl::verify_vnc_ticket($param->{vncticket}, $authuser, $authpath);
1478
ffda963f 1479 my $conf = PVE::QemuConfig->load_config($vmid, $node); # VM exists ?
3e7567e0
DM		 1480
1481 # Note: VNC ports are acessible from outside, so we do not gain any
1482 # security if we verify that $param->{port} belongs to VM $vmid. This
1483 # check is done by verifying the VNC ticket (inside VNC protocol).
1484
1485 my $port = $param->{port};
f34ebd52 1486
3e7567e0
DM		 1487 return { port => $port };
1488 }});
1489
288eeea8
DM		 1490__PACKAGE__->register_method({
1491 name => 'spiceproxy',
1492 path => '{vmid}/spiceproxy',
78252ce7 1493 method => 'POST',
288eeea8 1494 protected => 1,
78252ce7 1495 proxyto => 'node',
288eeea8
DM		 1496 permissions => {
1497 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1498 },
1499 description => "Returns a SPICE configuration to connect to the VM.",
1500 parameters => {
1501 additionalProperties => 0,
1502 properties => {
1503 node => get_standard_option('pve-node'),
1504 vmid => get_standard_option('pve-vmid'),
dd25eecf 1505 proxy => get_standard_option('spice-proxy', { optional => 1 }),
288eeea8
DM		 1506 },
1507 },
dd25eecf 1508 returns => get_standard_option('remote-viewer-config'),
288eeea8
DM		 1509 code => sub {
1510 my ($param) = @_;
1511
1512 my $rpcenv = PVE::RPCEnvironment::get();
1513
1514 my $authuser = $rpcenv->get_user();
1515
1516 my $vmid = $param->{vmid};
1517 my $node = $param->{node};
fb6c7260 1518 my $proxy = $param->{proxy};
288eeea8 1519
ffda963f 1520 my $conf = PVE::QemuConfig->load_config($vmid, $node);
7f9e28e4
TL		 1521 my $title = "VM $vmid";
1522 $title .= " - ". $conf->{name} if $conf->{name};
288eeea8 1523
943340a6 1524 my $port = PVE::QemuServer::spice_port($vmid);
dd25eecf 1525
f34ebd52 1526 my ($ticket, undef, $remote_viewer_config) =
dd25eecf 1527 PVE::AccessControl::remote_viewer_config($authuser, $vmid, $node, $proxy, $title, $port);
f34ebd52 1528
288eeea8
DM		 1529 PVE::QemuServer::vm_mon_cmd($vmid, "set_password", protocol => 'spice', password => $ticket);
1530 PVE::QemuServer::vm_mon_cmd($vmid, "expire_password", protocol => 'spice', time => "+30");
f34ebd52 1531
dd25eecf 1532 return $remote_viewer_config;
288eeea8
DM		 1533 }});
1534
5fdbe4f0
DM		 1535__PACKAGE__->register_method({
1536 name => 'vmcmdidx',
afdb31d5 1537 path => '{vmid}/status',
5fdbe4f0
DM		 1538 method => 'GET',
1539 proxyto => 'node',
1540 description => "Directory index",
a0d1b1a2
DM		 1541 permissions => {
1542 user => 'all',
1543 },
5fdbe4f0
DM		 1544 parameters => {
1545 additionalProperties => 0,
1546 properties => {
1547 node => get_standard_option('pve-node'),
1548 vmid => get_standard_option('pve-vmid'),
1549 },
1550 },
1551 returns => {
1552 type => 'array',
1553 items => {
1554 type => "object",
1555 properties => {
1556 subdir => { type => 'string' },
1557 },
1558 },
1559 links => [ { rel => 'child', href => "{subdir}" } ],
1560 },
1561 code => sub {
1562 my ($param) = @_;
1563
1564 # test if VM exists
ffda963f 1565 my $conf = PVE::QemuConfig->load_config($param->{vmid});
5fdbe4f0
DM		 1566
1567 my $res = [
1568 { subdir => 'current' },
1569 { subdir => 'start' },
1570 { subdir => 'stop' },
1571 ];
afdb31d5 1572
5fdbe4f0
DM		 1573 return $res;
1574 }});
1575
1e3baf05 1576__PACKAGE__->register_method({
afdb31d5 1577 name => 'vm_status',
5fdbe4f0 1578 path => '{vmid}/status/current',
1e3baf05
DM		 1579 method => 'GET',
1580 proxyto => 'node',
1581 protected => 1, # qemu pid files are only readable by root
1582 description => "Get virtual machine status.",
a0d1b1a2
DM		 1583 permissions => {
1584 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1585 },
1e3baf05
DM		 1586 parameters => {
1587 additionalProperties => 0,
1588 properties => {
1589 node => get_standard_option('pve-node'),
1590 vmid => get_standard_option('pve-vmid'),
1591 },
1592 },
1593 returns => { type => 'object' },
1594 code => sub {
1595 my ($param) = @_;
1596
1597 # test if VM exists
ffda963f 1598 my $conf = PVE::QemuConfig->load_config($param->{vmid});
1e3baf05 1599
03a33f30 1600 my $vmstatus = PVE::QemuServer::vmstatus($param->{vmid}, 1);
8610701a 1601 my $status = $vmstatus->{$param->{vmid}};
1e3baf05 1602
4d2a734e 1603 $status->{ha} = PVE::HA::Config::get_service_status("vm:$param->{vmid}");
8610701a 1604
86b8228b 1605 $status->{spice} = 1 if PVE::QemuServer::vga_conf_has_spice($conf->{vga});
46246f04 1606
8610701a 1607 return $status;
1e3baf05
DM		 1608 }});
1609
1610__PACKAGE__->register_method({
afdb31d5 1611 name => 'vm_start',
5fdbe4f0
DM		 1612 path => '{vmid}/status/start',
1613 method => 'POST',
1e3baf05
DM		 1614 protected => 1,
1615 proxyto => 'node',
5fdbe4f0 1616 description => "Start virtual machine.",
a0d1b1a2
DM		 1617 permissions => {
1618 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1619 },
1e3baf05
DM		 1620 parameters => {
1621 additionalProperties => 0,
1622 properties => {
1623 node => get_standard_option('pve-node'),
ab5904f7
TL		 1624 vmid => get_standard_option('pve-vmid',
1625 { completion => \&PVE::QemuServer::complete_vmid_stopped }),
3ea94c60
DM		 1626 skiplock => get_standard_option('skiplock'),
1627 stateuri => get_standard_option('pve-qm-stateuri'),
7e8dcf2c 1628 migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
952958bc 1629 machine => get_standard_option('pve-qm-machine'),
1e3baf05
DM		 1630 },
1631 },
afdb31d5 1632 returns => {
5fdbe4f0
DM		 1633 type => 'string',
1634 },
1e3baf05
DM		 1635 code => sub {
1636 my ($param) = @_;
1637
1638 my $rpcenv = PVE::RPCEnvironment::get();
1639
a0d1b1a2 1640 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1641
1642 my $node = extract_param($param, 'node');
1643
1e3baf05
DM		 1644 my $vmid = extract_param($param, 'vmid');
1645
952958bc
DM		 1646 my $machine = extract_param($param, 'machine');
1647
3ea94c60 1648 my $stateuri = extract_param($param, 'stateuri');
afdb31d5 1649 raise_param_exc({ stateuri => "Only root may use this option." })
a0d1b1a2 1650 if $stateuri && $authuser ne 'root@pam';
3ea94c60 1651
1e3baf05 1652 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1653 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1654 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1655
7e8dcf2c
AD		 1656 my $migratedfrom = extract_param($param, 'migratedfrom');
1657 raise_param_exc({ migratedfrom => "Only root may use this option." })
1658 if $migratedfrom && $authuser ne 'root@pam';
1659
7c14dcae
DM		 1660 # read spice ticket from STDIN
1661 my $spice_ticket;
1662 if ($stateuri && ($stateuri eq 'tcp') && $migratedfrom && ($rpcenv->{type} eq 'cli')) {
a64d6146 1663 if (defined(my $line = <>)) {
760fb3c8
DM		 1664 chomp $line;
1665 $spice_ticket = $line;
1666 }
7c14dcae
DM		 1667 }
1668
98cbd0f4
WB		 1669 PVE::Cluster::check_cfs_quorum();
1670
afdb31d5 1671 my $storecfg = PVE::Storage::config();
5fdbe4f0 1672
2003f0f8 1673 if (PVE::HA::Config::vm_is_ha_managed($vmid) && !$stateuri &&
cce37749 1674 $rpcenv->{type} ne 'ha') {
5fdbe4f0 1675
88fc87b4
DM		 1676 my $hacmd = sub {
1677 my $upid = shift;
5fdbe4f0 1678
c44291cd 1679 my $service = "vm:$vmid";
5fdbe4f0 1680
2003f0f8 1681 my $cmd = ['ha-manager', 'enable', $service];
88fc87b4
DM		 1682
1683 print "Executing HA start for VM $vmid\n";
1684
1685 PVE::Tools::run_command($cmd);
1686
1687 return;
1688 };
1689
1690 return $rpcenv->fork_worker('hastart', $vmid, $authuser, $hacmd);
1691
1692 } else {
1693
1694 my $realcmd = sub {
1695 my $upid = shift;
1696
1697 syslog('info', "start VM $vmid: $upid\n");
1698
fa8ea931 1699 PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock, $migratedfrom, undef,
7c14dcae 1700 $machine, $spice_ticket);
88fc87b4
DM		 1701
1702 return;
1703 };
5fdbe4f0 1704
88fc87b4
DM		 1705 return $rpcenv->fork_worker('qmstart', $vmid, $authuser, $realcmd);
1706 }
5fdbe4f0
DM		 1707 }});
1708
1709__PACKAGE__->register_method({
afdb31d5 1710 name => 'vm_stop',
5fdbe4f0
DM		 1711 path => '{vmid}/status/stop',
1712 method => 'POST',
1713 protected => 1,
1714 proxyto => 'node',
346130b2 1715 description => "Stop virtual machine. The qemu process will exit immediately. This" .
d6c747ff 1716 "is akin to pulling the power plug of a running computer and may damage the VM data",
a0d1b1a2
DM		 1717 permissions => {
1718 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1719 },
5fdbe4f0
DM		 1720 parameters => {
1721 additionalProperties => 0,
1722 properties => {
1723 node => get_standard_option('pve-node'),
ab5904f7
TL		 1724 vmid => get_standard_option('pve-vmid',
1725 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0 1726 skiplock => get_standard_option('skiplock'),
debe8882 1727 migratedfrom => get_standard_option('pve-node', { optional => 1 }),
c6bb9502
DM		 1728 timeout => {
1729 description => "Wait maximal timeout seconds.",
1730 type => 'integer',
1731 minimum => 0,
1732 optional => 1,
254575e9
DM		 1733 },
1734 keepActive => {
94a17e1d 1735 description => "Do not deactivate storage volumes.",
254575e9
DM		 1736 type => 'boolean',
1737 optional => 1,
1738 default => 0,
c6bb9502 1739 }
5fdbe4f0
DM		 1740 },
1741 },
afdb31d5 1742 returns => {
5fdbe4f0
DM		 1743 type => 'string',
1744 },
1745 code => sub {
1746 my ($param) = @_;
1747
1748 my $rpcenv = PVE::RPCEnvironment::get();
1749
a0d1b1a2 1750 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1751
1752 my $node = extract_param($param, 'node');
1753
1754 my $vmid = extract_param($param, 'vmid');
1755
1756 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1757 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1758 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1759
254575e9 1760 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1761 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1762 if $keepActive && $authuser ne 'root@pam';
254575e9 1763
af30308f
DM		 1764 my $migratedfrom = extract_param($param, 'migratedfrom');
1765 raise_param_exc({ migratedfrom => "Only root may use this option." })
1766 if $migratedfrom && $authuser ne 'root@pam';
1767
1768
ff1a2432
DM		 1769 my $storecfg = PVE::Storage::config();
1770
2003f0f8 1771 if (PVE::HA::Config::vm_is_ha_managed($vmid) && ($rpcenv->{type} ne 'ha') && !defined($migratedfrom)) {
5fdbe4f0 1772
88fc87b4
DM		 1773 my $hacmd = sub {
1774 my $upid = shift;
5fdbe4f0 1775
c44291cd 1776 my $service = "vm:$vmid";
c6bb9502 1777
2003f0f8 1778 my $cmd = ['ha-manager', 'disable', $service];
88fc87b4
DM		 1779
1780 print "Executing HA stop for VM $vmid\n";
1781
1782 PVE::Tools::run_command($cmd);
5fdbe4f0 1783
88fc87b4
DM		 1784 return;
1785 };
1786
1787 return $rpcenv->fork_worker('hastop', $vmid, $authuser, $hacmd);
1788
1789 } else {
1790 my $realcmd = sub {
1791 my $upid = shift;
1792
1793 syslog('info', "stop VM $vmid: $upid\n");
1794
1795 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0,
af30308f 1796 $param->{timeout}, 0, 1, $keepActive, $migratedfrom);
88fc87b4
DM		 1797
1798 return;
1799 };
1800
1801 return $rpcenv->fork_worker('qmstop', $vmid, $authuser, $realcmd);
1802 }
5fdbe4f0
DM		 1803 }});
1804
1805__PACKAGE__->register_method({
afdb31d5 1806 name => 'vm_reset',
5fdbe4f0
DM		 1807 path => '{vmid}/status/reset',
1808 method => 'POST',
1809 protected => 1,
1810 proxyto => 'node',
1811 description => "Reset virtual machine.",
a0d1b1a2
DM		 1812 permissions => {
1813 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1814 },
5fdbe4f0
DM		 1815 parameters => {
1816 additionalProperties => 0,
1817 properties => {
1818 node => get_standard_option('pve-node'),
ab5904f7
TL		 1819 vmid => get_standard_option('pve-vmid',
1820 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0
DM		 1821 skiplock => get_standard_option('skiplock'),
1822 },
1823 },
afdb31d5 1824 returns => {
5fdbe4f0
DM		 1825 type => 'string',
1826 },
1827 code => sub {
1828 my ($param) = @_;
1829
1830 my $rpcenv = PVE::RPCEnvironment::get();
1831
a0d1b1a2 1832 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1833
1834 my $node = extract_param($param, 'node');
1835
1836 my $vmid = extract_param($param, 'vmid');
1837
1838 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1839 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1840 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1841
ff1a2432
DM		 1842 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1843
5fdbe4f0
DM		 1844 my $realcmd = sub {
1845 my $upid = shift;
1846
1e3baf05 1847 PVE::QemuServer::vm_reset($vmid, $skiplock);
5fdbe4f0
DM		 1848
1849 return;
1850 };
1851
a0d1b1a2 1852 return $rpcenv->fork_worker('qmreset', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1853 }});
1854
1855__PACKAGE__->register_method({
afdb31d5 1856 name => 'vm_shutdown',
5fdbe4f0
DM		 1857 path => '{vmid}/status/shutdown',
1858 method => 'POST',
1859 protected => 1,
1860 proxyto => 'node',
d6c747ff
EK		 1861 description => "Shutdown virtual machine. This is similar to pressing the power button on a physical machine." .
1862 "This will send an ACPI event for the guest OS, which should then proceed to a clean shutdown.",
a0d1b1a2
DM		 1863 permissions => {
1864 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1865 },
5fdbe4f0
DM		 1866 parameters => {
1867 additionalProperties => 0,
1868 properties => {
1869 node => get_standard_option('pve-node'),
ab5904f7
TL		 1870 vmid => get_standard_option('pve-vmid',
1871 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0 1872 skiplock => get_standard_option('skiplock'),
c6bb9502
DM		 1873 timeout => {
1874 description => "Wait maximal timeout seconds.",
1875 type => 'integer',
1876 minimum => 0,
1877 optional => 1,
9269013a
DM		 1878 },
1879 forceStop => {
1880 description => "Make sure the VM stops.",
1881 type => 'boolean',
1882 optional => 1,
1883 default => 0,
254575e9
DM		 1884 },
1885 keepActive => {
94a17e1d 1886 description => "Do not deactivate storage volumes.",
254575e9
DM		 1887 type => 'boolean',
1888 optional => 1,
1889 default => 0,
c6bb9502 1890 }
5fdbe4f0
DM		 1891 },
1892 },
afdb31d5 1893 returns => {
5fdbe4f0
DM		 1894 type => 'string',
1895 },
1896 code => sub {
1897 my ($param) = @_;
1898
1899 my $rpcenv = PVE::RPCEnvironment::get();
1900
a0d1b1a2 1901 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1902
1903 my $node = extract_param($param, 'node');
1904
1905 my $vmid = extract_param($param, 'vmid');
1906
1907 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1908 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1909 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1910
254575e9 1911 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1912 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1913 if $keepActive && $authuser ne 'root@pam';
254575e9 1914
02d07cf5
DM		 1915 my $storecfg = PVE::Storage::config();
1916
89897367
DC		 1917 my $shutdown = 1;
1918
1919 # if vm is paused, do not shutdown (but stop if forceStop = 1)
1920 # otherwise, we will infer a shutdown command, but run into the timeout,
1921 # then when the vm is resumed, it will instantly shutdown
1922 #
1923 # checking the qmp status here to get feedback to the gui/cli/api
1924 # and the status query should not take too long
1925 my $qmpstatus;
1926 eval {
1927 $qmpstatus = PVE::QemuServer::vm_qmp_command($vmid, { execute => "query-status" }, 0);
1928 };
1929 my $err = $@ if $@;
1930
1931 if (!$err && $qmpstatus->{status} eq "paused") {
1932 if ($param->{forceStop}) {
1933 warn "VM is paused - stop instead of shutdown\n";
1934 $shutdown = 0;
1935 } else {
1936 die "VM is paused - cannot shutdown\n";
1937 }
1938 }
1939
5fdbe4f0
DM		 1940 my $realcmd = sub {
1941 my $upid = shift;
1942
1943 syslog('info', "shutdown VM $vmid: $upid\n");
1944
afdb31d5 1945 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
89897367 1946 $shutdown, $param->{forceStop}, $keepActive);
c6bb9502 1947
5fdbe4f0
DM		 1948 return;
1949 };
1950
a0d1b1a2 1951 return $rpcenv->fork_worker('qmshutdown', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1952 }});
1953
1954__PACKAGE__->register_method({
afdb31d5 1955 name => 'vm_suspend',
5fdbe4f0
DM		 1956 path => '{vmid}/status/suspend',
1957 method => 'POST',
1958 protected => 1,
1959 proxyto => 'node',
1960 description => "Suspend virtual machine.",
a0d1b1a2
DM		 1961 permissions => {
1962 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1963 },
5fdbe4f0
DM		 1964 parameters => {
1965 additionalProperties => 0,
1966 properties => {
1967 node => get_standard_option('pve-node'),
ab5904f7
TL		 1968 vmid => get_standard_option('pve-vmid',
1969 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0
DM		 1970 skiplock => get_standard_option('skiplock'),
1971 },
1972 },
afdb31d5 1973 returns => {
5fdbe4f0
DM		 1974 type => 'string',
1975 },
1976 code => sub {
1977 my ($param) = @_;
1978
1979 my $rpcenv = PVE::RPCEnvironment::get();
1980
a0d1b1a2 1981 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1982
1983 my $node = extract_param($param, 'node');
1984
1985 my $vmid = extract_param($param, 'vmid');
1986
1987 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1988 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1989 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1990
ff1a2432
DM		 1991 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1992
5fdbe4f0
DM		 1993 my $realcmd = sub {
1994 my $upid = shift;
1995
1996 syslog('info', "suspend VM $vmid: $upid\n");
1997
1e3baf05 1998 PVE::QemuServer::vm_suspend($vmid, $skiplock);
5fdbe4f0
DM		 1999
2000 return;
2001 };
2002
a0d1b1a2 2003 return $rpcenv->fork_worker('qmsuspend', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 2004 }});
2005
2006__PACKAGE__->register_method({
afdb31d5 2007 name => 'vm_resume',
5fdbe4f0
DM		 2008 path => '{vmid}/status/resume',
2009 method => 'POST',
2010 protected => 1,
2011 proxyto => 'node',
2012 description => "Resume virtual machine.",
a0d1b1a2
DM		 2013 permissions => {
2014 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
2015 },
5fdbe4f0
DM		 2016 parameters => {
2017 additionalProperties => 0,
2018 properties => {
2019 node => get_standard_option('pve-node'),
ab5904f7
TL		 2020 vmid => get_standard_option('pve-vmid',
2021 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0 2022 skiplock => get_standard_option('skiplock'),
289e0b85
AD		 2023 nocheck => { type => 'boolean', optional => 1 },
2024
5fdbe4f0
DM		 2025 },
2026 },
afdb31d5 2027 returns => {
5fdbe4f0
DM		 2028 type => 'string',
2029 },
2030 code => sub {
2031 my ($param) = @_;
2032
2033 my $rpcenv = PVE::RPCEnvironment::get();
2034
a0d1b1a2 2035 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 2036
2037 my $node = extract_param($param, 'node');
2038
2039 my $vmid = extract_param($param, 'vmid');
2040
2041 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 2042 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 2043 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 2044
289e0b85
AD		 2045 my $nocheck = extract_param($param, 'nocheck');
2046
2047 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid, $nocheck);
ff1a2432 2048
5fdbe4f0
DM		 2049 my $realcmd = sub {
2050 my $upid = shift;
2051
2052 syslog('info', "resume VM $vmid: $upid\n");
2053
289e0b85 2054 PVE::QemuServer::vm_resume($vmid, $skiplock, $nocheck);
1e3baf05 2055
5fdbe4f0
DM		 2056 return;
2057 };
2058
a0d1b1a2 2059 return $rpcenv->fork_worker('qmresume', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 2060 }});
2061
2062__PACKAGE__->register_method({
afdb31d5 2063 name => 'vm_sendkey',
5fdbe4f0
DM		 2064 path => '{vmid}/sendkey',
2065 method => 'PUT',
2066 protected => 1,
2067 proxyto => 'node',
2068 description => "Send key event to virtual machine.",
a0d1b1a2
DM		 2069 permissions => {
2070 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
2071 },
5fdbe4f0
DM		 2072 parameters => {
2073 additionalProperties => 0,
2074 properties => {
2075 node => get_standard_option('pve-node'),
ab5904f7
TL		 2076 vmid => get_standard_option('pve-vmid',
2077 { completion => \&PVE::QemuServer::complete_vmid_running }),
5fdbe4f0
DM		 2078 skiplock => get_standard_option('skiplock'),
2079 key => {
2080 description => "The key (qemu monitor encoding).",
2081 type => 'string'
2082 }
2083 },
2084 },
2085 returns => { type => 'null'},
2086 code => sub {
2087 my ($param) = @_;
2088
2089 my $rpcenv = PVE::RPCEnvironment::get();
2090
a0d1b1a2 2091 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 2092
2093 my $node = extract_param($param, 'node');
2094
2095 my $vmid = extract_param($param, 'vmid');
2096
2097 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 2098 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 2099 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0
DM		 2100
2101 PVE::QemuServer::vm_sendkey($vmid, $skiplock, $param->{key});
2102
2103 return;
1e3baf05
DM		 2104 }});
2105
1ac0d2ee
AD		 2106__PACKAGE__->register_method({
2107 name => 'vm_feature',
2108 path => '{vmid}/feature',
2109 method => 'GET',
2110 proxyto => 'node',
75466c4f 2111 protected => 1,
1ac0d2ee
AD		 2112 description => "Check if feature for virtual machine is available.",
2113 permissions => {
2114 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
2115 },
2116 parameters => {
2117 additionalProperties => 0,
2118 properties => {
2119 node => get_standard_option('pve-node'),
2120 vmid => get_standard_option('pve-vmid'),
2121 feature => {
2122 description => "Feature to check.",
2123 type => 'string',
7758ce86 2124 enum => [ 'snapshot', 'clone', 'copy' ],
1ac0d2ee
AD		 2125 },
2126 snapname => get_standard_option('pve-snapshot-name', {
2127 optional => 1,
2128 }),
2129 },
1ac0d2ee
AD		 2130 },
2131 returns => {
719893a9
DM		 2132 type => "object",
2133 properties => {
2134 hasFeature => { type => 'boolean' },
7043d946 2135 nodes => {
719893a9
DM		 2136 type => 'array',
2137 items => { type => 'string' },
2138 }
2139 },
1ac0d2ee
AD		 2140 },
2141 code => sub {
2142 my ($param) = @_;
2143
2144 my $node = extract_param($param, 'node');
2145
2146 my $vmid = extract_param($param, 'vmid');
2147
2148 my $snapname = extract_param($param, 'snapname');
2149
2150 my $feature = extract_param($param, 'feature');
2151
2152 my $running = PVE::QemuServer::check_running($vmid);
2153
ffda963f 2154 my $conf = PVE::QemuConfig->load_config($vmid);
1ac0d2ee
AD		 2155
2156 if($snapname){
2157 my $snap = $conf->{snapshots}->{$snapname};
2158 die "snapshot '$snapname' does not exist\n" if !defined($snap);
2159 $conf = $snap;
2160 }
2161 my $storecfg = PVE::Storage::config();
2162
719893a9 2163 my $nodelist = PVE::QemuServer::shared_nodes($conf, $storecfg);
b2c9558d 2164 my $hasFeature = PVE::QemuConfig->has_feature($feature, $conf, $storecfg, $snapname, $running);
7043d946 2165
719893a9
DM		 2166 return {
2167 hasFeature => $hasFeature,
2168 nodes => [ keys %$nodelist ],
7043d946 2169 };
1ac0d2ee
AD		 2170 }});
2171
6116f729 2172__PACKAGE__->register_method({
9418baad
DM		 2173 name => 'clone_vm',
2174 path => '{vmid}/clone',
6116f729
DM		 2175 method => 'POST',
2176 protected => 1,
2177 proxyto => 'node',
37329185 2178 description => "Create a copy of virtual machine/template.",
6116f729 2179 permissions => {
9418baad 2180 description => "You need 'VM.Clone' permissions on /vms/{vmid}, and 'VM.Allocate' permissions " .
6116f729
DM		 2181 "on /vms/{newid} (or on the VM pool /pool/{pool}). You also need " .
2182 "'Datastore.AllocateSpace' on any used storage.",
75466c4f
DM		 2183 check =>
2184 [ 'and',
9418baad 2185 ['perm', '/vms/{vmid}', [ 'VM.Clone' ]],
75466c4f 2186 [ 'or',
6116f729
DM		 2187 [ 'perm', '/vms/{newid}', ['VM.Allocate']],
2188 [ 'perm', '/pool/{pool}', ['VM.Allocate'], require_param => 'pool'],
2189 ],
2190 ]
2191 },
2192 parameters => {
2193 additionalProperties => 0,
2194 properties => {
6116f729 2195 node => get_standard_option('pve-node'),
335af808 2196 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
9418baad 2197 newid => get_standard_option('pve-vmid', { description => 'VMID for the clone.' }),
a60ab1a6
DM		 2198 name => {
2199 optional => 1,
2200 type => 'string', format => 'dns-name',
2201 description => "Set a name for the new VM.",
2202 },
2203 description => {
2204 optional => 1,
2205 type => 'string',
2206 description => "Description for the new VM.",
2207 },
75466c4f 2208 pool => {
6116f729
DM		 2209 optional => 1,
2210 type => 'string', format => 'pve-poolid',
2211 description => "Add the new VM to the specified pool.",
2212 },
9076d880 2213 snapname => get_standard_option('pve-snapshot-name', {
9076d880
DM		 2214 optional => 1,
2215 }),
81f043eb 2216 storage => get_standard_option('pve-storage-id', {
9418baad 2217 description => "Target storage for full clone.",
4e4f83fe 2218 requires => 'full',
81f043eb
AD		 2219 optional => 1,
2220 }),
55173c6b 2221 'format' => {
42a19c87
AD		 2222 description => "Target format for file storage.",
2223 requires => 'full',
2224 type => 'string',
2225 optional => 1,
55173c6b 2226 enum => [ 'raw', 'qcow2', 'vmdk'],
42a19c87 2227 },
6116f729
DM		 2228 full => {
2229 optional => 1,
55173c6b
DM		 2230 type => 'boolean',
2231 description => "Create a full copy of all disk. This is always done when " .
9418baad 2232 "you clone a normal VM. For VM templates, we try to create a linked clone by default.",
6116f729
DM		 2233 default => 0,
2234 },
75466c4f 2235 target => get_standard_option('pve-node', {
55173c6b
DM		 2236 description => "Target node. Only allowed if the original VM is on shared storage.",
2237 optional => 1,
2238 }),
2239 },
6116f729
DM		 2240 },
2241 returns => {
2242 type => 'string',
2243 },
2244 code => sub {
2245 my ($param) = @_;
2246
2247 my $rpcenv = PVE::RPCEnvironment::get();
2248
55173c6b 2249 my $authuser = $rpcenv->get_user();
6116f729
DM		 2250
2251 my $node = extract_param($param, 'node');
2252
2253 my $vmid = extract_param($param, 'vmid');
2254
2255 my $newid = extract_param($param, 'newid');
2256
6116f729
DM		 2257 my $pool = extract_param($param, 'pool');
2258
2259 if (defined($pool)) {
2260 $rpcenv->check_pool_exist($pool);
2261 }
2262
55173c6b 2263 my $snapname = extract_param($param, 'snapname');
9076d880 2264
81f043eb
AD		 2265 my $storage = extract_param($param, 'storage');
2266
42a19c87
AD		 2267 my $format = extract_param($param, 'format');
2268
55173c6b
DM		 2269 my $target = extract_param($param, 'target');
2270
2271 my $localnode = PVE::INotify::nodename();
2272
751cc556 2273 undef $target if $target && ($target eq $localnode || $target eq 'localhost');
55173c6b
DM		 2274
2275 PVE::Cluster::check_node_exists($target) if $target;
2276
6116f729
DM		 2277 my $storecfg = PVE::Storage::config();
2278
4a5a2590
DM		 2279 if ($storage) {
2280 # check if storage is enabled on local node
2281 PVE::Storage::storage_check_enabled($storecfg, $storage);
2282 if ($target) {
2283 # check if storage is available on target node
2284 PVE::Storage::storage_check_node($storecfg, $storage, $target);
2285 # clone only works if target storage is shared
2286 my $scfg = PVE::Storage::storage_config($storecfg, $storage);
2287 die "can't clone to non-shared storage '$storage'\n" if !$scfg->{shared};
2288 }
2289 }
2290
55173c6b 2291 PVE::Cluster::check_cfs_quorum();
6116f729 2292
4e4f83fe
DM		 2293 my $running = PVE::QemuServer::check_running($vmid) || 0;
2294
4e4f83fe
DM		 2295 # exclusive lock if VM is running - else shared lock is enough;
2296 my $shared_lock = $running ? 0 : 1;
2297
9418baad 2298 my $clonefn = sub {
6116f729 2299
829967a9
DM		 2300 # do all tests after lock
2301 # we also try to do all tests before we fork the worker
2302
ffda963f 2303 my $conf = PVE::QemuConfig->load_config($vmid);
6116f729 2304
ffda963f 2305 PVE::QemuConfig->check_lock($conf);
6116f729 2306
4e4f83fe 2307 my $verify_running = PVE::QemuServer::check_running($vmid) || 0;
6116f729 2308
4e4f83fe 2309 die "unexpected state change\n" if $verify_running != $running;
6116f729 2310
75466c4f
DM		 2311 die "snapshot '$snapname' does not exist\n"
2312 if $snapname && !defined( $conf->{snapshots}->{$snapname});
6116f729 2313
75466c4f 2314 my $oldconf = $snapname ? $conf->{snapshots}->{$snapname} : $conf;
9076d880 2315
9418baad 2316 my $sharedvm = &$check_storage_access_clone($rpcenv, $authuser, $storecfg, $oldconf, $storage);
6116f729 2317
9418baad 2318 die "can't clone VM to node '$target' (VM uses local storage)\n" if $target && !$sharedvm;
75466c4f 2319
ffda963f 2320 my $conffile = PVE::QemuConfig->config_file($newid);
6116f729
DM		 2321
2322 die "unable to create VM $newid: config file already exists\n"
2323 if -f $conffile;
2324
9418baad 2325 my $newconf = { lock => 'clone' };
829967a9 2326 my $drives = {};
34456bf0 2327 my $fullclone = {};
829967a9
DM		 2328 my $vollist = [];
2329
2330 foreach my $opt (keys %$oldconf) {
2331 my $value = $oldconf->{$opt};
2332
2333 # do not copy snapshot related info
2334 next if $opt eq 'snapshots' || $opt eq 'parent' || $opt eq 'snaptime' ||
2335 $opt eq 'vmstate' || $opt eq 'snapstate';
2336
a78ea5df
WL		 2337 # no need to copy unused images, because VMID(owner) changes anyways
2338 next if $opt =~ m/^unused\d+$/;
2339
829967a9
DM		 2340 # always change MAC! address
2341 if ($opt =~ m/^net(\d+)$/) {
2342 my $net = PVE::QemuServer::parse_net($value);
b5b99790
WB		 2343 my $dc = PVE::Cluster::cfs_read_file('datacenter.cfg');
2344 $net->{macaddr} = PVE::Tools::random_ether_addr($dc->{mac_prefix});
829967a9 2345 $newconf->{$opt} = PVE::QemuServer::print_net($net);
74479ee9 2346 } elsif (PVE::QemuServer::is_valid_drivename($opt)) {
1f1412d1
DM		 2347 my $drive = PVE::QemuServer::parse_drive($opt, $value);
2348 die "unable to parse drive options for '$opt'\n" if !$drive;
829967a9
DM		 2349 if (PVE::QemuServer::drive_is_cdrom($drive)) {
2350 $newconf->{$opt} = $value; # simply copy configuration
2351 } else {
64ff6fe4 2352 if ($param->{full}) {
2dd53043 2353 die "Full clone feature is not available"
dba198b0 2354 if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running);
34456bf0 2355 $fullclone->{$opt} = 1;
64ff6fe4
SP		 2356 } else {
2357 # not full means clone instead of copy
2358 die "Linked clone feature is not available"
2359 if !PVE::Storage::volume_has_feature($storecfg, 'clone', $drive->{file}, $snapname, $running);
dba198b0 2360 }
829967a9
DM		 2361 $drives->{$opt} = $drive;
2362 push @$vollist, $drive->{file};
2363 }
2364 } else {
2365 # copy everything else
2366 $newconf->{$opt} = $value;
2367 }
2368 }
2369
cd11416f
DM		 2370 # auto generate a new uuid
2371 my ($uuid, $uuid_str);
2372 UUID::generate($uuid);
2373 UUID::unparse($uuid, $uuid_str);
2374 my $smbios1 = PVE::QemuServer::parse_smbios1($newconf->{smbios1} || '');
f34ebd52 2375 $smbios1->{uuid} = $uuid_str;
cd11416f
DM		 2376 $newconf->{smbios1} = PVE::QemuServer::print_smbios1($smbios1);
2377
829967a9
DM		 2378 delete $newconf->{template};
2379
2380 if ($param->{name}) {
2381 $newconf->{name} = $param->{name};
2382 } else {
c55fee03
DM		 2383 if ($oldconf->{name}) {
2384 $newconf->{name} = "Copy-of-$oldconf->{name}";
2385 } else {
2386 $newconf->{name} = "Copy-of-VM-$vmid";
2387 }
829967a9 2388 }
2dd53043 2389
829967a9
DM		 2390 if ($param->{description}) {
2391 $newconf->{description} = $param->{description};
2392 }
2393
6116f729 2394 # create empty/temp config - this fails if VM already exists on other node
9418baad 2395 PVE::Tools::file_set_contents($conffile, "# qmclone temporary file\nlock: clone\n");
6116f729
DM		 2396
2397 my $realcmd = sub {
2398 my $upid = shift;
2399
b83e0181 2400 my $newvollist = [];
6116f729 2401
b83e0181 2402 eval {
829967a9 2403 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
75466c4f 2404
eb15b9f0 2405 PVE::Storage::activate_volumes($storecfg, $vollist, $snapname);
6116f729 2406
829967a9
DM		 2407 foreach my $opt (keys %$drives) {
2408 my $drive = $drives->{$opt};
2dd53043 2409
152fe752 2410 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
34456bf0 2411 $newid, $storage, $format, $fullclone->{$opt}, $newvollist);
00b095ca 2412
152fe752 2413 $newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive);
2dd53043 2414
ffda963f 2415 PVE::QemuConfig->write_config($newid, $newconf);
829967a9 2416 }
b83e0181
DM		 2417
2418 delete $newconf->{lock};
ffda963f 2419 PVE::QemuConfig->write_config($newid, $newconf);
55173c6b
DM		 2420
2421 if ($target) {
baca276d 2422 # always deactivate volumes - avoid lvm LVs to be active on several nodes
51eefb7e 2423 PVE::Storage::deactivate_volumes($storecfg, $vollist, $snapname) if !$running;
32acc380 2424 PVE::Storage::deactivate_volumes($storecfg, $newvollist);
baca276d 2425
ffda963f 2426 my $newconffile = PVE::QemuConfig->config_file($newid, $target);
55173c6b
DM		 2427 die "Failed to move config to node '$target' - rename failed: $!\n"
2428 if !rename($conffile, $newconffile);
2429 }
d703d4c0 2430
be517049 2431 PVE::AccessControl::add_vm_to_pool($newid, $pool) if $pool;
6116f729 2432 };
75466c4f 2433 if (my $err = $@) {
6116f729
DM		 2434 unlink $conffile;
2435
b83e0181
DM		 2436 sleep 1; # some storage like rbd need to wait before release volume - really?
2437
2438 foreach my $volid (@$newvollist) {
2439 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2440 warn $@ if $@;
2441 }
9418baad 2442 die "clone failed: $err";
6116f729
DM		 2443 }
2444
2445 return;
2446 };
2447
457010cc
AG		 2448 PVE::Firewall::clone_vmfw_conf($vmid, $newid);
2449
9418baad 2450 return $rpcenv->fork_worker('qmclone', $vmid, $authuser, $realcmd);
6116f729
DM		 2451 };
2452
ffda963f 2453 return PVE::QemuConfig->lock_config_mode($vmid, 1, $shared_lock, sub {
6116f729 2454 # Aquire exclusive lock lock for $newid
ffda963f 2455 return PVE::QemuConfig->lock_config_full($newid, 1, $clonefn);
6116f729
DM		 2456 });
2457
2458 }});
2459
586bfa78 2460__PACKAGE__->register_method({
43bc02a9
DM		 2461 name => 'move_vm_disk',
2462 path => '{vmid}/move_disk',
e2cd75fa 2463 method => 'POST',
586bfa78
AD		 2464 protected => 1,
2465 proxyto => 'node',
2466 description => "Move volume to different storage.",
2467 permissions => {
e2cd75fa
DM		 2468 description => "You need 'VM.Config.Disk' permissions on /vms/{vmid}, " .
2469 "and 'Datastore.AllocateSpace' permissions on the storage.",
7043d946 2470 check =>
e2cd75fa
DM		 2471 [ 'and',
2472 ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
2473 ['perm', '/storage/{storage}', [ 'Datastore.AllocateSpace' ]],
2474 ],
586bfa78
AD		 2475 },
2476 parameters => {
2477 additionalProperties => 0,
2478 properties => {
2479 node => get_standard_option('pve-node'),
335af808 2480 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
586bfa78
AD		 2481 disk => {
2482 type => 'string',
2483 description => "The disk you want to move.",
74479ee9 2484 enum => [ PVE::QemuServer::valid_drive_names() ],
586bfa78 2485 },
335af808
DM		 2486 storage => get_standard_option('pve-storage-id', {
2487 description => "Target storage.",
2488 completion => \&PVE::QemuServer::complete_storage,
2489 }),
635c3c44 2490 'format' => {
586bfa78
AD		 2491 type => 'string',
2492 description => "Target Format.",
2493 enum => [ 'raw', 'qcow2', 'vmdk' ],
2494 optional => 1,
2495 },
70d45e33
DM		 2496 delete => {
2497 type => 'boolean',
2498 description => "Delete the original disk after successful copy. By default the original disk is kept as unused disk.",
2499 optional => 1,
2500 default => 0,
2501 },
586bfa78
AD		 2502 digest => {
2503 type => 'string',
2504 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2505 maxLength => 40,
2506 optional => 1,
2507 },
2508 },
2509 },
e2cd75fa
DM		 2510 returns => {
2511 type => 'string',
2512 description => "the task ID.",
2513 },
586bfa78
AD		 2514 code => sub {
2515 my ($param) = @_;
2516
2517 my $rpcenv = PVE::RPCEnvironment::get();
2518
2519 my $authuser = $rpcenv->get_user();
2520
2521 my $node = extract_param($param, 'node');
2522
2523 my $vmid = extract_param($param, 'vmid');
2524
2525 my $digest = extract_param($param, 'digest');
2526
2527 my $disk = extract_param($param, 'disk');
2528
2529 my $storeid = extract_param($param, 'storage');
2530
2531 my $format = extract_param($param, 'format');
2532
586bfa78
AD		 2533 my $storecfg = PVE::Storage::config();
2534
2535 my $updatefn = sub {
2536
ffda963f 2537 my $conf = PVE::QemuConfig->load_config($vmid);
586bfa78 2538
dcce9b46
FG		 2539 PVE::QemuConfig->check_lock($conf);
2540
586bfa78
AD		 2541 die "checksum missmatch (file change by other user?)\n"
2542 if $digest && $digest ne $conf->{digest};
586bfa78
AD		 2543
2544 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2545
2546 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2547
70d45e33 2548 my $old_volid = $drive->{file} || die "disk '$disk' has no associated volume\n";
586bfa78
AD		 2549
2550 die "you can't move a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2551
e2cd75fa 2552 my $oldfmt;
70d45e33 2553 my ($oldstoreid, $oldvolname) = PVE::Storage::parse_volume_id($old_volid);
586bfa78
AD		 2554 if ($oldvolname =~ m/\.(raw|qcow2|vmdk)$/){
2555 $oldfmt = $1;
2556 }
2557
7043d946 2558 die "you can't move on the same storage with same format\n" if $oldstoreid eq $storeid &&
e2cd75fa 2559 (!$format || !$oldfmt || $oldfmt eq $format);
586bfa78 2560
9dbf9b54
FG		 2561 # this only checks snapshots because $disk is passed!
2562 my $snapshotted = PVE::QemuServer::is_volume_in_use($storecfg, $conf, $disk, $old_volid);
2563 die "you can't move a disk with snapshots and delete the source\n"
2564 if $snapshotted && $param->{delete};
2565
586bfa78
AD		 2566 PVE::Cluster::log_msg('info', $authuser, "move disk VM $vmid: move --disk $disk --storage $storeid");
2567
2568 my $running = PVE::QemuServer::check_running($vmid);
e2cd75fa
DM		 2569
2570 PVE::Storage::activate_volumes($storecfg, [ $drive->{file} ]);
2571
586bfa78
AD		 2572 my $realcmd = sub {
2573
2574 my $newvollist = [];
2575
2576 eval {
2577 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
2578
9dbf9b54
FG		 2579 warn "moving disk with snapshots, snapshots will not be moved!\n"
2580 if $snapshotted;
2581
e2cd75fa
DM		 2582 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $disk, $drive, undef,
2583 $vmid, $storeid, $format, 1, $newvollist);
2584
2585 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $newdrive);
2586
8793d495 2587 PVE::QemuConfig->add_unused_volume($conf, $old_volid) if !$param->{delete};
7043d946 2588
ffda963f 2589 PVE::QemuConfig->write_config($vmid, $conf);
73272365 2590
f34ebd52 2591 eval {
73272365 2592 # try to deactivate volumes - avoid lvm LVs to be active on several nodes
f34ebd52 2593 PVE::Storage::deactivate_volumes($storecfg, [ $newdrive->{file} ])
73272365
DM		 2594 if !$running;
2595 };
2596 warn $@ if $@;
586bfa78
AD		 2597 };
2598 if (my $err = $@) {
2599
2600 foreach my $volid (@$newvollist) {
2601 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2602 warn $@ if $@;
2603 }
2604 die "storage migration failed: $err";
2605 }
70d45e33
DM		 2606
2607 if ($param->{delete}) {
a3d0bafb
FG		 2608 eval {
2609 PVE::Storage::deactivate_volumes($storecfg, [$old_volid]);
2610 PVE::Storage::vdisk_free($storecfg, $old_volid);
2611 };
2612 warn $@ if $@;
70d45e33 2613 }
586bfa78
AD		 2614 };
2615
2616 return $rpcenv->fork_worker('qmmove', $vmid, $authuser, $realcmd);
2617 };
e2cd75fa 2618
ffda963f 2619 return PVE::QemuConfig->lock_config($vmid, $updatefn);
586bfa78
AD		 2620 }});
2621
3ea94c60 2622__PACKAGE__->register_method({
afdb31d5 2623 name => 'migrate_vm',
3ea94c60
DM		 2624 path => '{vmid}/migrate',
2625 method => 'POST',
2626 protected => 1,
2627 proxyto => 'node',
2628 description => "Migrate virtual machine. Creates a new migration task.",
a0d1b1a2
DM		 2629 permissions => {
2630 check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]],
2631 },
3ea94c60
DM		 2632 parameters => {
2633 additionalProperties => 0,
2634 properties => {
2635 node => get_standard_option('pve-node'),
335af808
DM		 2636 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
2637 target => get_standard_option('pve-node', {
2638 description => "Target node.",
2639 completion => \&PVE::Cluster::complete_migration_target,
2640 }),
3ea94c60
DM		 2641 online => {
2642 type => 'boolean',
2643 description => "Use online/live migration.",
2644 optional => 1,
2645 },
2646 force => {
2647 type => 'boolean',
2648 description => "Allow to migrate VMs which use local devices. Only root may use this option.",
2649 optional => 1,
2650 },
2651 },
2652 },
afdb31d5 2653 returns => {
3ea94c60
DM		 2654 type => 'string',
2655 description => "the task ID.",
2656 },
2657 code => sub {
2658 my ($param) = @_;
2659
2660 my $rpcenv = PVE::RPCEnvironment::get();
2661
a0d1b1a2 2662 my $authuser = $rpcenv->get_user();
3ea94c60
DM		 2663
2664 my $target = extract_param($param, 'target');
2665
2666 my $localnode = PVE::INotify::nodename();
2667 raise_param_exc({ target => "target is local node."}) if $target eq $localnode;
2668
2669 PVE::Cluster::check_cfs_quorum();
2670
2671 PVE::Cluster::check_node_exists($target);
2672
2673 my $targetip = PVE::Cluster::remote_node_ip($target);
2674
2675 my $vmid = extract_param($param, 'vmid');
2676
afdb31d5 2677 raise_param_exc({ force => "Only root may use this option." })
a0d1b1a2 2678 if $param->{force} && $authuser ne 'root@pam';
3ea94c60
DM		 2679
2680 # test if VM exists
ffda963f 2681 my $conf = PVE::QemuConfig->load_config($vmid);
3ea94c60
DM		 2682
2683 # try to detect errors early
a5ed42d3 2684
ffda963f 2685 PVE::QemuConfig->check_lock($conf);
a5ed42d3 2686
3ea94c60 2687 if (PVE::QemuServer::check_running($vmid)) {
afdb31d5 2688 die "cant migrate running VM without --online\n"
3ea94c60
DM		 2689 if !$param->{online};
2690 }
2691
47152e2e 2692 my $storecfg = PVE::Storage::config();
22d646a7 2693 PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
47152e2e 2694
2003f0f8 2695 if (PVE::HA::Config::vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
3ea94c60 2696
88fc87b4
DM		 2697 my $hacmd = sub {
2698 my $upid = shift;
3ea94c60 2699
c44291cd 2700 my $service = "vm:$vmid";
88fc87b4 2701
2003f0f8 2702 my $cmd = ['ha-manager', 'migrate', $service, $target];
88fc87b4
DM		 2703
2704 print "Executing HA migrate for VM $vmid to node $target\n";
2705
2706 PVE::Tools::run_command($cmd);
2707
2708 return;
2709 };
2710
2711 return $rpcenv->fork_worker('hamigrate', $vmid, $authuser, $hacmd);
2712
2713 } else {
2714
2715 my $realcmd = sub {
2716 my $upid = shift;
2717
2718 PVE::QemuMigrate->migrate($target, $targetip, $vmid, $param);
2719 };
2720
2721 return $rpcenv->fork_worker('qmigrate', $vmid, $authuser, $realcmd);
2722 }
3ea94c60 2723
3ea94c60 2724 }});
1e3baf05 2725
91c94f0a 2726__PACKAGE__->register_method({
afdb31d5
DM		 2727 name => 'monitor',
2728 path => '{vmid}/monitor',
91c94f0a
DM		 2729 method => 'POST',
2730 protected => 1,
2731 proxyto => 'node',
2732 description => "Execute Qemu monitor commands.",
a0d1b1a2
DM		 2733 permissions => {
2734 check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
2735 },
91c94f0a
DM		 2736 parameters => {
2737 additionalProperties => 0,
2738 properties => {
2739 node => get_standard_option('pve-node'),
2740 vmid => get_standard_option('pve-vmid'),
2741 command => {
2742 type => 'string',
2743 description => "The monitor command.",
2744 }
2745 },
2746 },
2747 returns => { type => 'string'},
2748 code => sub {
2749 my ($param) = @_;
2750
2751 my $vmid = $param->{vmid};
2752
ffda963f 2753 my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists
91c94f0a
DM		 2754
2755 my $res = '';
2756 eval {
7b7c6d1b 2757 $res = PVE::QemuServer::vm_human_monitor_command($vmid, $param->{command});
91c94f0a
DM		 2758 };
2759 $res = "ERROR: $@" if $@;
2760
2761 return $res;
2762 }});
2763
0d02881c
AD		 2764__PACKAGE__->register_method({
2765 name => 'resize_vm',
614e3941 2766 path => '{vmid}/resize',
0d02881c
AD		 2767 method => 'PUT',
2768 protected => 1,
2769 proxyto => 'node',
2f48a4f5 2770 description => "Extend volume size.",
0d02881c 2771 permissions => {
3b2773f6 2772 check => ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
0d02881c
AD		 2773 },
2774 parameters => {
2775 additionalProperties => 0,
2f48a4f5
DM		 2776 properties => {
2777 node => get_standard_option('pve-node'),
335af808 2778 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
2f48a4f5
DM		 2779 skiplock => get_standard_option('skiplock'),
2780 disk => {
2781 type => 'string',
2782 description => "The disk you want to resize.",
74479ee9 2783 enum => [PVE::QemuServer::valid_drive_names()],
2f48a4f5
DM		 2784 },
2785 size => {
2786 type => 'string',
f91b2e45 2787 pattern => '\+?\d+(\.\d+)?[KMGT]?',
2f48a4f5
DM		 2788 description => "The new size. With the '+' sign the value is added to the actual size of the volume and without it, the value is taken as an absolute one. Shrinking disk size is not supported.",
2789 },
2790 digest => {
2791 type => 'string',
2792 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2793 maxLength => 40,
2794 optional => 1,
2795 },
2796 },
0d02881c
AD		 2797 },
2798 returns => { type => 'null'},
2799 code => sub {
2800 my ($param) = @_;
2801
2802 my $rpcenv = PVE::RPCEnvironment::get();
2803
2804 my $authuser = $rpcenv->get_user();
2805
2806 my $node = extract_param($param, 'node');
2807
2808 my $vmid = extract_param($param, 'vmid');
2809
2810 my $digest = extract_param($param, 'digest');
2811
2f48a4f5 2812 my $disk = extract_param($param, 'disk');
75466c4f 2813
2f48a4f5 2814 my $sizestr = extract_param($param, 'size');
0d02881c 2815
f91b2e45 2816 my $skiplock = extract_param($param, 'skiplock');
0d02881c
AD		 2817 raise_param_exc({ skiplock => "Only root may use this option." })
2818 if $skiplock && $authuser ne 'root@pam';
2819
0d02881c
AD		 2820 my $storecfg = PVE::Storage::config();
2821
0d02881c
AD		 2822 my $updatefn = sub {
2823
ffda963f 2824 my $conf = PVE::QemuConfig->load_config($vmid);
0d02881c
AD		 2825
2826 die "checksum missmatch (file change by other user?)\n"
2827 if $digest && $digest ne $conf->{digest};
ffda963f 2828 PVE::QemuConfig->check_lock($conf) if !$skiplock;
0d02881c 2829
f91b2e45
DM		 2830 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2831
2832 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2833
d662790a
WL		 2834 my (undef, undef, undef, undef, undef, undef, $format) =
2835 PVE::Storage::parse_volname($storecfg, $drive->{file});
2836
2837 die "can't resize volume: $disk if snapshot exists\n"
2838 if %{$conf->{snapshots}} && $format eq 'qcow2';
2839
f91b2e45
DM		 2840 my $volid = $drive->{file};
2841
2842 die "disk '$disk' has no associated volume\n" if !$volid;
2843
2844 die "you can't resize a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2845
2846 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
2847
2848 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
2849
b572a606 2850 PVE::Storage::activate_volumes($storecfg, [$volid]);
f91b2e45
DM		 2851 my $size = PVE::Storage::volume_size_info($storecfg, $volid, 5);
2852
2853 die "internal error" if $sizestr !~ m/^(\+)?(\d+(\.\d+)?)([KMGT])?$/;
2854 my ($ext, $newsize, $unit) = ($1, $2, $4);
2855 if ($unit) {
2856 if ($unit eq 'K') {
2857 $newsize = $newsize * 1024;
2858 } elsif ($unit eq 'M') {
2859 $newsize = $newsize * 1024 * 1024;
2860 } elsif ($unit eq 'G') {
2861 $newsize = $newsize * 1024 * 1024 * 1024;
2862 } elsif ($unit eq 'T') {
2863 $newsize = $newsize * 1024 * 1024 * 1024 * 1024;
2864 }
2865 }
2866 $newsize += $size if $ext;
2867 $newsize = int($newsize);
2868
2869 die "unable to skrink disk size\n" if $newsize < $size;
2870
2871 return if $size == $newsize;
2872
2f48a4f5 2873 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: resize --disk $disk --size $sizestr");
0d02881c 2874
f91b2e45 2875 PVE::QemuServer::qemu_block_resize($vmid, "drive-$disk", $storecfg, $volid, $newsize);
75466c4f 2876
f91b2e45
DM		 2877 $drive->{size} = $newsize;
2878 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $drive);
2879
ffda963f 2880 PVE::QemuConfig->write_config($vmid, $conf);
f91b2e45 2881 };
0d02881c 2882
ffda963f 2883 PVE::QemuConfig->lock_config($vmid, $updatefn);
0d02881c
AD		 2884 return undef;
2885 }});
2886
9dbd1ee4 2887__PACKAGE__->register_method({
7e7d7b61 2888 name => 'snapshot_list',
9dbd1ee4 2889 path => '{vmid}/snapshot',
7e7d7b61
DM		 2890 method => 'GET',
2891 description => "List all snapshots.",
2892 permissions => {
2893 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
2894 },
2895 proxyto => 'node',
2896 protected => 1, # qemu pid files are only readable by root
2897 parameters => {
2898 additionalProperties => 0,
2899 properties => {
2900 vmid => get_standard_option('pve-vmid'),
2901 node => get_standard_option('pve-node'),
2902 },
2903 },
2904 returns => {
2905 type => 'array',
2906 items => {
2907 type => "object",
2908 properties => {},
2909 },
2910 links => [ { rel => 'child', href => "{name}" } ],
2911 },
2912 code => sub {
2913 my ($param) = @_;
2914
6aa4651b
DM		 2915 my $vmid = $param->{vmid};
2916
ffda963f 2917 my $conf = PVE::QemuConfig->load_config($vmid);
7e7d7b61
DM		 2918 my $snaphash = $conf->{snapshots} || {};
2919
2920 my $res = [];
2921
2922 foreach my $name (keys %$snaphash) {
0ea6bc69 2923 my $d = $snaphash->{$name};
75466c4f
DM		 2924 my $item = {
2925 name => $name,
2926 snaptime => $d->{snaptime} || 0,
6aa4651b 2927 vmstate => $d->{vmstate} ? 1 : 0,
982c7f12
DM		 2928 description => $d->{description} || '',
2929 };
0ea6bc69 2930 $item->{parent} = $d->{parent} if $d->{parent};
3ee28e38 2931 $item->{snapstate} = $d->{snapstate} if $d->{snapstate};
0ea6bc69
DM		 2932 push @$res, $item;
2933 }
2934
6aa4651b
DM		 2935 my $running = PVE::QemuServer::check_running($vmid, 1) ? 1 : 0;
2936 my $current = { name => 'current', digest => $conf->{digest}, running => $running };
d1914468
DM		 2937 $current->{parent} = $conf->{parent} if $conf->{parent};
2938
2939 push @$res, $current;
7e7d7b61
DM		 2940
2941 return $res;
2942 }});
2943
2944__PACKAGE__->register_method({
2945 name => 'snapshot',
2946 path => '{vmid}/snapshot',
2947 method => 'POST',
9dbd1ee4
AD		 2948 protected => 1,
2949 proxyto => 'node',
2950 description => "Snapshot a VM.",
2951 permissions => {
f1baf1df 2952 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
9dbd1ee4
AD		 2953 },
2954 parameters => {
2955 additionalProperties => 0,
2956 properties => {
2957 node => get_standard_option('pve-node'),
335af808 2958 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
8abd398b 2959 snapname => get_standard_option('pve-snapshot-name'),
9dbd1ee4
AD		 2960 vmstate => {
2961 optional => 1,
2962 type => 'boolean',
2963 description => "Save the vmstate",
2964 },
782f4f75
DM		 2965 description => {
2966 optional => 1,
2967 type => 'string',
2968 description => "A textual description or comment.",
2969 },
9dbd1ee4
AD		 2970 },
2971 },
7e7d7b61
DM		 2972 returns => {
2973 type => 'string',
2974 description => "the task ID.",
2975 },
9dbd1ee4
AD		 2976 code => sub {
2977 my ($param) = @_;
2978
2979 my $rpcenv = PVE::RPCEnvironment::get();
2980
2981 my $authuser = $rpcenv->get_user();
2982
2983 my $node = extract_param($param, 'node');
2984
2985 my $vmid = extract_param($param, 'vmid');
2986
9dbd1ee4
AD		 2987 my $snapname = extract_param($param, 'snapname');
2988
d1914468
DM		 2989 die "unable to use snapshot name 'current' (reserved name)\n"
2990 if $snapname eq 'current';
2991
7e7d7b61 2992 my $realcmd = sub {
22c377f0 2993 PVE::Cluster::log_msg('info', $authuser, "snapshot VM $vmid: $snapname");
b2c9558d 2994 PVE::QemuConfig->snapshot_create($vmid, $snapname, $param->{vmstate},
af9110dd 2995 $param->{description});
7e7d7b61
DM		 2996 };
2997
2998 return $rpcenv->fork_worker('qmsnapshot', $vmid, $authuser, $realcmd);
2999 }});
3000
154ccdcd
DM		 3001__PACKAGE__->register_method({
3002 name => 'snapshot_cmd_idx',
3003 path => '{vmid}/snapshot/{snapname}',
3004 description => '',
3005 method => 'GET',
3006 permissions => {
3007 user => 'all',
3008 },
3009 parameters => {
3010 additionalProperties => 0,
3011 properties => {
3012 vmid => get_standard_option('pve-vmid'),
3013 node => get_standard_option('pve-node'),
8abd398b 3014 snapname => get_standard_option('pve-snapshot-name'),
154ccdcd
DM		 3015 },
3016 },
3017 returns => {
3018 type => 'array',
3019 items => {
3020 type => "object",
3021 properties => {},
3022 },
3023 links => [ { rel => 'child', href => "{cmd}" } ],
3024 },
3025 code => sub {
3026 my ($param) = @_;
3027
3028 my $res = [];
3029
3030 push @$res, { cmd => 'rollback' };
d788cea6 3031 push @$res, { cmd => 'config' };
154ccdcd
DM		 3032
3033 return $res;
3034 }});
3035
d788cea6
DM		 3036__PACKAGE__->register_method({
3037 name => 'update_snapshot_config',
3038 path => '{vmid}/snapshot/{snapname}/config',
3039 method => 'PUT',
3040 protected => 1,
3041 proxyto => 'node',
3042 description => "Update snapshot metadata.",
3043 permissions => {
3044 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
3045 },
3046 parameters => {
3047 additionalProperties => 0,
3048 properties => {
3049 node => get_standard_option('pve-node'),
3050 vmid => get_standard_option('pve-vmid'),
3051 snapname => get_standard_option('pve-snapshot-name'),
3052 description => {
3053 optional => 1,
3054 type => 'string',
3055 description => "A textual description or comment.",
3056 },
3057 },
3058 },
3059 returns => { type => 'null' },
3060 code => sub {
3061 my ($param) = @_;
3062
3063 my $rpcenv = PVE::RPCEnvironment::get();
3064
3065 my $authuser = $rpcenv->get_user();
3066
3067 my $vmid = extract_param($param, 'vmid');
3068
3069 my $snapname = extract_param($param, 'snapname');
3070
3071 return undef if !defined($param->{description});
3072
3073 my $updatefn = sub {
3074
ffda963f 3075 my $conf = PVE::QemuConfig->load_config($vmid);
d788cea6 3076
ffda963f 3077 PVE::QemuConfig->check_lock($conf);
d788cea6
DM		 3078
3079 my $snap = $conf->{snapshots}->{$snapname};
3080
75466c4f
DM		 3081 die "snapshot '$snapname' does not exist\n" if !defined($snap);
3082
d788cea6
DM		 3083 $snap->{description} = $param->{description} if defined($param->{description});
3084
ffda963f 3085 PVE::QemuConfig->write_config($vmid, $conf);
d788cea6
DM		 3086 };
3087
ffda963f 3088 PVE::QemuConfig->lock_config($vmid, $updatefn);
d788cea6
DM		 3089
3090 return undef;
3091 }});
3092
3093__PACKAGE__->register_method({
3094 name => 'get_snapshot_config',
3095 path => '{vmid}/snapshot/{snapname}/config',
3096 method => 'GET',
3097 proxyto => 'node',
3098 description => "Get snapshot configuration",
3099 permissions => {
3100 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
3101 },
3102 parameters => {
3103 additionalProperties => 0,
3104 properties => {
3105 node => get_standard_option('pve-node'),
3106 vmid => get_standard_option('pve-vmid'),
3107 snapname => get_standard_option('pve-snapshot-name'),
3108 },
3109 },
3110 returns => { type => "object" },
3111 code => sub {
3112 my ($param) = @_;
3113
3114 my $rpcenv = PVE::RPCEnvironment::get();
3115
3116 my $authuser = $rpcenv->get_user();
3117
3118 my $vmid = extract_param($param, 'vmid');
3119
3120 my $snapname = extract_param($param, 'snapname');
3121
ffda963f 3122 my $conf = PVE::QemuConfig->load_config($vmid);
d788cea6
DM		 3123
3124 my $snap = $conf->{snapshots}->{$snapname};
3125
75466c4f
DM		 3126 die "snapshot '$snapname' does not exist\n" if !defined($snap);
3127
d788cea6
DM		 3128 return $snap;
3129 }});
3130
7e7d7b61
DM		 3131__PACKAGE__->register_method({
3132 name => 'rollback',
154ccdcd 3133 path => '{vmid}/snapshot/{snapname}/rollback',
7e7d7b61
DM		 3134 method => 'POST',
3135 protected => 1,
3136 proxyto => 'node',
3137 description => "Rollback VM state to specified snapshot.",
3138 permissions => {
f1baf1df 3139 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 3140 },
3141 parameters => {
3142 additionalProperties => 0,
3143 properties => {
3144 node => get_standard_option('pve-node'),
335af808 3145 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
8abd398b 3146 snapname => get_standard_option('pve-snapshot-name'),
7e7d7b61
DM		 3147 },
3148 },
3149 returns => {
3150 type => 'string',
3151 description => "the task ID.",
3152 },
3153 code => sub {
3154 my ($param) = @_;
3155
3156 my $rpcenv = PVE::RPCEnvironment::get();
3157
3158 my $authuser = $rpcenv->get_user();
3159
3160 my $node = extract_param($param, 'node');
3161
3162 my $vmid = extract_param($param, 'vmid');
3163
3164 my $snapname = extract_param($param, 'snapname');
3165
7e7d7b61 3166 my $realcmd = sub {
22c377f0 3167 PVE::Cluster::log_msg('info', $authuser, "rollback snapshot VM $vmid: $snapname");
b2c9558d 3168 PVE::QemuConfig->snapshot_rollback($vmid, $snapname);
7e7d7b61
DM		 3169 };
3170
3171 return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $realcmd);
3172 }});
3173
3174__PACKAGE__->register_method({
3175 name => 'delsnapshot',
3176 path => '{vmid}/snapshot/{snapname}',
3177 method => 'DELETE',
3178 protected => 1,
3179 proxyto => 'node',
3180 description => "Delete a VM snapshot.",
3181 permissions => {
f1baf1df 3182 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 3183 },
3184 parameters => {
3185 additionalProperties => 0,
3186 properties => {
3187 node => get_standard_option('pve-node'),
335af808 3188 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }),
8abd398b 3189 snapname => get_standard_option('pve-snapshot-name'),
3ee28e38
DM		 3190 force => {
3191 optional => 1,
3192 type => 'boolean',
3193 description => "For removal from config file, even if removing disk snapshots fails.",
3194 },
7e7d7b61
DM		 3195 },
3196 },
3197 returns => {
3198 type => 'string',
3199 description => "the task ID.",
3200 },
3201 code => sub {
3202 my ($param) = @_;
3203
3204 my $rpcenv = PVE::RPCEnvironment::get();
3205
3206 my $authuser = $rpcenv->get_user();
3207
3208 my $node = extract_param($param, 'node');
3209
3210 my $vmid = extract_param($param, 'vmid');
3211
3212 my $snapname = extract_param($param, 'snapname');
3213
7e7d7b61 3214 my $realcmd = sub {
22c377f0 3215 PVE::Cluster::log_msg('info', $authuser, "delete snapshot VM $vmid: $snapname");
b2c9558d 3216 PVE::QemuConfig->snapshot_delete($vmid, $snapname, $param->{force});
7e7d7b61 3217 };
9dbd1ee4 3218
7b2257a8 3219 return $rpcenv->fork_worker('qmdelsnapshot', $vmid, $authuser, $realcmd);
9dbd1ee4
AD		 3220 }});
3221
04a69bb4
AD		 3222__PACKAGE__->register_method({
3223 name => 'template',
3224 path => '{vmid}/template',
3225 method => 'POST',
3226 protected => 1,
3227 proxyto => 'node',
3228 description => "Create a Template.",
b02691d8 3229 permissions => {
7af0a6c8
DM		 3230 description => "You need 'VM.Allocate' permissions on /vms/{vmid}",
3231 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
b02691d8 3232 },
04a69bb4
AD		 3233 parameters => {
3234 additionalProperties => 0,
3235 properties => {
3236 node => get_standard_option('pve-node'),
335af808 3237 vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid_stopped }),
04a69bb4
AD		 3238 disk => {
3239 optional => 1,
3240 type => 'string',
3241 description => "If you want to convert only 1 disk to base image.",
74479ee9 3242 enum => [PVE::QemuServer::valid_drive_names()],
04a69bb4
AD		 3243 },
3244
3245 },
3246 },
3247 returns => { type => 'null'},
3248 code => sub {
3249 my ($param) = @_;
3250
3251 my $rpcenv = PVE::RPCEnvironment::get();
3252
3253 my $authuser = $rpcenv->get_user();
3254
3255 my $node = extract_param($param, 'node');
3256
3257 my $vmid = extract_param($param, 'vmid');
3258
3259 my $disk = extract_param($param, 'disk');
3260
3261 my $updatefn = sub {
3262
ffda963f 3263 my $conf = PVE::QemuConfig->load_config($vmid);
04a69bb4 3264
ffda963f 3265 PVE::QemuConfig->check_lock($conf);
04a69bb4 3266
75466c4f 3267 die "unable to create template, because VM contains snapshots\n"
b91c2aae 3268 if $conf->{snapshots} && scalar(keys %{$conf->{snapshots}});
0402a80b 3269
75466c4f 3270 die "you can't convert a template to a template\n"
ffda963f 3271 if PVE::QemuConfig->is_template($conf) && !$disk;
0402a80b 3272
75466c4f 3273 die "you can't convert a VM to template if VM is running\n"
218cab9a 3274 if PVE::QemuServer::check_running($vmid);
35c5fdef 3275
04a69bb4
AD		 3276 my $realcmd = sub {
3277 PVE::QemuServer::template_create($vmid, $conf, $disk);
3278 };
04a69bb4 3279
75e7e997 3280 $conf->{template} = 1;
ffda963f 3281 PVE::QemuConfig->write_config($vmid, $conf);
75e7e997
DM		 3282
3283 return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
04a69bb4
AD		 3284 };
3285
ffda963f 3286 PVE::QemuConfig->lock_config($vmid, $updatefn);
04a69bb4
AD		 3287 return undef;
3288 }});
3289
1e3baf05 32901;
Virtual Machine Manager