]> 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 new 'machine' configuration
[qemu-server.git] / PVE / API2 / Qemu.pm
CommitLineData
1e3baf05
DM		 1package PVE::API2::Qemu;
2
3use strict;
4use warnings;
5b9d692a 5use Cwd 'abs_path';
1e3baf05 6
502d18a2 7use PVE::Cluster qw (cfs_read_file cfs_write_file);;
1e3baf05
DM		 8use PVE::SafeSyslog;
9use PVE::Tools qw(extract_param);
f9bfceef 10use PVE::Exception qw(raise raise_param_exc raise_perm_exc);
1e3baf05
DM		 11use PVE::Storage;
12use PVE::JSONSchema qw(get_standard_option);
13use PVE::RESTHandler;
14use PVE::QemuServer;
3ea94c60 15use PVE::QemuMigrate;
1e3baf05
DM		 16use PVE::RPCEnvironment;
17use PVE::AccessControl;
18use PVE::INotify;
de8f60b2 19use PVE::Network;
1e3baf05
DM		 20
21use Data::Dumper; # fixme: remove
22
23use base qw(PVE::RESTHandler);
24
25my $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.";
26
27my $resolve_cdrom_alias = sub {
28 my $param = shift;
29
30 if (my $value = $param->{cdrom}) {
31 $value .= ",media=cdrom" if $value !~ m/media=/;
32 $param->{ide2} = $value;
33 delete $param->{cdrom};
34 }
35};
36
a0d1b1a2 37
ae57f6b3 38my $check_storage_access = sub {
fcbb753e 39 my ($rpcenv, $authuser, $storecfg, $vmid, $settings, $default_storage) = @_;
a0d1b1a2 40
ae57f6b3
DM		 41 PVE::QemuServer::foreach_drive($settings, sub {
42 my ($ds, $drive) = @_;
a0d1b1a2 43
ae57f6b3 44 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
a0d1b1a2 45
ae57f6b3 46 my $volid = $drive->{file};
a0d1b1a2 47
09d0ee64
DM		 48 if (!$volid || $volid eq 'none') {
49 # nothing to check
f5782fd0
DM		 50 } elsif ($isCDROM && ($volid eq 'cdrom')) {
51 $rpcenv->check($authuser, "/", ['Sys.Console']);
09d0ee64 52 } elsif (!$isCDROM && ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/)) {
a0d1b1a2
DM		 53 my ($storeid, $size) = ($2 || $default_storage, $3);
54 die "no storage ID specified (and no default storage)\n" if !$storeid;
fcbb753e 55 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
a0d1b1a2 56 } else {
8b192abf 57 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
a0d1b1a2
DM		 58 }
59 });
ae57f6b3 60};
a0d1b1a2 61
9418baad 62my $check_storage_access_clone = sub {
81f043eb 63 my ($rpcenv, $authuser, $storecfg, $conf, $storage) = @_;
6116f729 64
55173c6b
DM		 65 my $sharedvm = 1;
66
6116f729
DM		 67 PVE::QemuServer::foreach_drive($conf, sub {
68 my ($ds, $drive) = @_;
69
70 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
71
72 my $volid = $drive->{file};
73
74 return if !$volid || $volid eq 'none';
75
76 if ($isCDROM) {
77 if ($volid eq 'cdrom') {
78 $rpcenv->check($authuser, "/", ['Sys.Console']);
79 } else {
75466c4f 80 # we simply allow access
55173c6b
DM		 81 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid);
82 my $scfg = PVE::Storage::storage_config($storecfg, $sid);
83 $sharedvm = 0 if !$scfg->{shared};
84
6116f729
DM		 85 }
86 } else {
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
81f043eb 91 $sid = $storage if $storage;
6116f729
DM		 92 $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
93 }
94 });
55173c6b
DM		 95
96 return $sharedvm;
6116f729
DM		 97};
98
ae57f6b3
DM		 99# Note: $pool is only needed when creating a VM, because pool permissions
100# are automatically inherited if VM already exists inside a pool.
101my $create_disks = sub {
102 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $settings, $default_storage) = @_;
a0d1b1a2
DM		 103
104 my $vollist = [];
a0d1b1a2 105
ae57f6b3
DM		 106 my $res = {};
107 PVE::QemuServer::foreach_drive($settings, sub {
108 my ($ds, $disk) = @_;
109
110 my $volid = $disk->{file};
111
f5782fd0 112 if (!$volid || $volid eq 'none' || $volid eq 'cdrom') {
628e9a2b
AD		 113 delete $disk->{size};
114 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
09d0ee64 115 } elsif ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/) {
ae57f6b3
DM		 116 my ($storeid, $size) = ($2 || $default_storage, $3);
117 die "no storage ID specified (and no default storage)\n" if !$storeid;
118 my $defformat = PVE::Storage::storage_default_format($storecfg, $storeid);
119 my $fmt = $disk->{format} || $defformat;
a0d1b1a2
DM		 120 my $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
121 $fmt, undef, $size*1024*1024);
a0d1b1a2 122 $disk->{file} = $volid;
24afaca0 123 $disk->{size} = $size*1024*1024*1024;
a0d1b1a2 124 push @$vollist, $volid;
ae57f6b3
DM		 125 delete $disk->{format}; # no longer needed
126 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
127 } else {
eabe0da0 128
ba68cf09 129 my $path = $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
75466c4f 130
eabe0da0 131 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
35cb731c 132
35cb731c
AD		 133 my $foundvolid = undef;
134
eabe0da0
DM		 135 if ($storeid) {
136 PVE::Storage::activate_volumes($storecfg, [ $volid ]);
137 my $dl = PVE::Storage::vdisk_list($storecfg, $storeid, undef);
138
139 PVE::Storage::foreach_volid($dl, sub {
140 my ($volumeid) = @_;
141 if($volumeid eq $volid) {
142 $foundvolid = 1;
143 return;
144 }
145 });
146 }
75466c4f 147
35cb731c 148 die "image '$path' does not exists\n" if (!(-f $path || -b $path || $foundvolid));
24afaca0
DM		 149
150 my ($size) = PVE::Storage::volume_size_info($storecfg, $volid, 1);
151 $disk->{size} = $size;
152 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
a0d1b1a2 153 }
ae57f6b3 154 });
a0d1b1a2
DM		 155
156 # free allocated images on error
157 if (my $err = $@) {
158 syslog('err', "VM $vmid creating disks failed");
159 foreach my $volid (@$vollist) {
160 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
161 warn $@ if $@;
162 }
163 die $err;
164 }
165
166 # modify vm config if everything went well
ae57f6b3
DM		 167 foreach my $ds (keys %$res) {
168 $conf->{$ds} = $res->{$ds};
a0d1b1a2
DM		 169 }
170
171 return $vollist;
172};
173
174my $check_vm_modify_config_perm = sub {
ae57f6b3 175 my ($rpcenv, $authuser, $vmid, $pool, $key_list) = @_;
a0d1b1a2 176
6e5c4da7 177 return 1 if $authuser eq 'root@pam';
a0d1b1a2 178
ae57f6b3 179 foreach my $opt (@$key_list) {
a0d1b1a2
DM		 180 # disk checks need to be done somewhere else
181 next if PVE::QemuServer::valid_drivename($opt);
182
183 if ($opt eq 'sockets' || $opt eq 'cores' ||
75466c4f 184 $opt eq 'cpu' || $opt eq 'smp' ||
ab6b35df 185 $opt eq 'cpulimit' || $opt eq 'cpuunits') {
a0d1b1a2
DM		 186 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.CPU']);
187 } elsif ($opt eq 'boot' || $opt eq 'bootdisk') {
188 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
ccd5438f 189 } elsif ($opt eq 'memory' || $opt eq 'balloon' || $opt eq 'shares') {
a0d1b1a2
DM		 190 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Memory']);
191 } elsif ($opt eq 'args' || $opt eq 'lock') {
192 die "only root can set '$opt' config\n";
75466c4f 193 } elsif ($opt eq 'cpu' || $opt eq 'kvm' || $opt eq 'acpi' ||
a0d1b1a2
DM		 194 $opt eq 'vga' || $opt eq 'watchdog' || $opt eq 'tablet') {
195 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.HWType']);
196 } elsif ($opt =~ m/^net\d+$/) {
197 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']);
198 } else {
199 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Options']);
200 }
201 }
202
203 return 1;
204};
205
1e3baf05 206__PACKAGE__->register_method({
afdb31d5
DM		 207 name => 'vmlist',
208 path => '',
1e3baf05
DM		 209 method => 'GET',
210 description => "Virtual machine index (per node).",
a0d1b1a2
DM		 211 permissions => {
212 description => "Only list VMs where you have VM.Audit permissons on /vms/<vmid>.",
213 user => 'all',
214 },
1e3baf05
DM		 215 proxyto => 'node',
216 protected => 1, # qemu pid files are only readable by root
217 parameters => {
218 additionalProperties => 0,
219 properties => {
220 node => get_standard_option('pve-node'),
221 },
222 },
223 returns => {
224 type => 'array',
225 items => {
226 type => "object",
227 properties => {},
228 },
229 links => [ { rel => 'child', href => "{vmid}" } ],
230 },
231 code => sub {
232 my ($param) = @_;
233
a0d1b1a2
DM		 234 my $rpcenv = PVE::RPCEnvironment::get();
235 my $authuser = $rpcenv->get_user();
236
1e3baf05
DM		 237 my $vmstatus = PVE::QemuServer::vmstatus();
238
a0d1b1a2
DM		 239 my $res = [];
240 foreach my $vmid (keys %$vmstatus) {
241 next if !$rpcenv->check($authuser, "/vms/$vmid", [ 'VM.Audit' ], 1);
242
243 my $data = $vmstatus->{$vmid};
244 $data->{vmid} = $vmid;
245 push @$res, $data;
246 }
1e3baf05 247
a0d1b1a2 248 return $res;
1e3baf05
DM		 249 }});
250
d703d4c0 251
d703d4c0 252
1e3baf05 253__PACKAGE__->register_method({
afdb31d5
DM		 254 name => 'create_vm',
255 path => '',
1e3baf05 256 method => 'POST',
3e16d5fc 257 description => "Create or restore a virtual machine.",
a0d1b1a2 258 permissions => {
f9bfceef
DM		 259 description => "You need 'VM.Allocate' permissions on /vms/{vmid} or on the VM pool /pool/{pool}. " .
260 "For restore (option 'archive'), it is enough if the user has 'VM.Backup' permission and the VM already exists. " .
261 "If you create disks you need 'Datastore.AllocateSpace' on any used storage.",
262 user => 'all', # check inside
a0d1b1a2 263 },
1e3baf05
DM		 264 protected => 1,
265 proxyto => 'node',
266 parameters => {
267 additionalProperties => 0,
268 properties => PVE::QemuServer::json_config_properties(
269 {
270 node => get_standard_option('pve-node'),
271 vmid => get_standard_option('pve-vmid'),
3e16d5fc
DM		 272 archive => {
273 description => "The backup file.",
274 type => 'string',
275 optional => 1,
276 maxLength => 255,
277 },
278 storage => get_standard_option('pve-storage-id', {
279 description => "Default storage.",
280 optional => 1,
281 }),
282 force => {
afdb31d5 283 optional => 1,
3e16d5fc
DM		 284 type => 'boolean',
285 description => "Allow to overwrite existing VM.",
51586c3a
DM		 286 requires => 'archive',
287 },
288 unique => {
afdb31d5 289 optional => 1,
51586c3a
DM		 290 type => 'boolean',
291 description => "Assign a unique random ethernet address.",
292 requires => 'archive',
3e16d5fc 293 },
75466c4f 294 pool => {
a0d1b1a2
DM		 295 optional => 1,
296 type => 'string', format => 'pve-poolid',
297 description => "Add the VM to the specified pool.",
298 },
1e3baf05
DM		 299 }),
300 },
afdb31d5 301 returns => {
5fdbe4f0
DM		 302 type => 'string',
303 },
1e3baf05
DM		 304 code => sub {
305 my ($param) = @_;
306
5fdbe4f0
DM		 307 my $rpcenv = PVE::RPCEnvironment::get();
308
a0d1b1a2 309 my $authuser = $rpcenv->get_user();
5fdbe4f0 310
1e3baf05
DM		 311 my $node = extract_param($param, 'node');
312
1e3baf05
DM		 313 my $vmid = extract_param($param, 'vmid');
314
3e16d5fc
DM		 315 my $archive = extract_param($param, 'archive');
316
317 my $storage = extract_param($param, 'storage');
318
51586c3a
DM		 319 my $force = extract_param($param, 'force');
320
321 my $unique = extract_param($param, 'unique');
75466c4f 322
a0d1b1a2 323 my $pool = extract_param($param, 'pool');
51586c3a 324
1e3baf05 325 my $filename = PVE::QemuServer::config_file($vmid);
afdb31d5
DM		 326
327 my $storecfg = PVE::Storage::config();
1e3baf05 328
3e16d5fc 329 PVE::Cluster::check_cfs_quorum();
1e3baf05 330
a0d1b1a2
DM		 331 if (defined($pool)) {
332 $rpcenv->check_pool_exist($pool);
75466c4f 333 }
a0d1b1a2 334
fcbb753e 335 $rpcenv->check($authuser, "/storage/$storage", ['Datastore.AllocateSpace'])
a0d1b1a2
DM		 336 if defined($storage);
337
f9bfceef
DM		 338 if ($rpcenv->check($authuser, "/vms/$vmid", ['VM.Allocate'], 1)) {
339 # OK
340 } elsif ($pool && $rpcenv->check($authuser, "/pool/$pool", ['VM.Allocate'], 1)) {
341 # OK
342 } elsif ($archive && $force && (-f $filename) &&
343 $rpcenv->check($authuser, "/vms/$vmid", ['VM.Backup'], 1)) {
344 # OK: user has VM.Backup permissions, and want to restore an existing VM
345 } else {
346 raise_perm_exc();
347 }
348
afdb31d5 349 if (!$archive) {
3e16d5fc 350 &$resolve_cdrom_alias($param);
1e3baf05 351
fcbb753e 352 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param, $storage);
ae57f6b3
DM		 353
354 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, $pool, [ keys %$param]);
355
3e16d5fc
DM		 356 foreach my $opt (keys %$param) {
357 if (PVE::QemuServer::valid_drivename($opt)) {
358 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
359 raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
afdb31d5 360
3e16d5fc
DM		 361 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
362 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
363 }
1e3baf05 364 }
3e16d5fc
DM		 365
366 PVE::QemuServer::add_random_macs($param);
51586c3a
DM		 367 } else {
368 my $keystr = join(' ', keys %$param);
bc4dcb99
DM		 369 raise_param_exc({ archive => "option conflicts with other options ($keystr)"}) if $keystr;
370
5b9d692a 371 if ($archive eq '-') {
afdb31d5 372 die "pipe requires cli environment\n"
d7810bc1 373 if $rpcenv->{type} ne 'cli';
5b9d692a 374 } else {
ba68cf09 375 my $path = $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $archive);
d7810bc1
DM		 376
377 PVE::Storage::activate_volumes($storecfg, [ $archive ])
378 if PVE::Storage::parse_volume_id ($archive, 1);
379
971f27c4
DM		 380 die "can't find archive file '$archive'\n" if !($path && -f $path);
381 $archive = $path;
382 }
1e3baf05
DM		 383 }
384
3e16d5fc
DM		 385 my $restorefn = sub {
386
6116f729 387 # fixme: this test does not work if VM exists on other node!
3e16d5fc 388 if (-f $filename) {
afdb31d5 389 die "unable to restore vm $vmid: config file already exists\n"
51586c3a 390 if !$force;
3e16d5fc 391
afdb31d5 392 die "unable to restore vm $vmid: vm is running\n"
3e16d5fc
DM		 393 if PVE::QemuServer::check_running($vmid);
394 }
395
396 my $realcmd = sub {
a0d1b1a2 397 PVE::QemuServer::restore_archive($archive, $vmid, $authuser, {
51586c3a 398 storage => $storage,
a0d1b1a2 399 pool => $pool,
51586c3a 400 unique => $unique });
502d18a2 401
be517049 402 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
3e16d5fc
DM		 403 };
404
a0d1b1a2 405 return $rpcenv->fork_worker('qmrestore', $vmid, $authuser, $realcmd);
3e16d5fc 406 };
1e3baf05 407
1e3baf05
DM		 408 my $createfn = sub {
409
191435c6 410 # test after locking
afdb31d5 411 die "unable to create vm $vmid: config file already exists\n"
1e3baf05
DM		 412 if -f $filename;
413
5fdbe4f0 414 my $realcmd = sub {
1e3baf05 415
5fdbe4f0 416 my $vollist = [];
1e3baf05 417
1858638f
DM		 418 my $conf = $param;
419
5fdbe4f0 420 eval {
ae57f6b3 421
1858638f 422 $vollist = &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $param, $storage);
1e3baf05 423
5fdbe4f0
DM		 424 # try to be smart about bootdisk
425 my @disks = PVE::QemuServer::disknames();
426 my $firstdisk;
427 foreach my $ds (reverse @disks) {
1858638f
DM		 428 next if !$conf->{$ds};
429 my $disk = PVE::QemuServer::parse_drive($ds, $conf->{$ds});
5fdbe4f0
DM		 430 next if PVE::QemuServer::drive_is_cdrom($disk);
431 $firstdisk = $ds;
432 }
1e3baf05 433
1858638f
DM		 434 if (!$conf->{bootdisk} && $firstdisk) {
435 $conf->{bootdisk} = $firstdisk;
5fdbe4f0 436 }
1e3baf05 437
ae9ca91d
DM		 438 PVE::QemuServer::update_config_nolock($vmid, $conf);
439
5fdbe4f0
DM		 440 };
441 my $err = $@;
1e3baf05 442
5fdbe4f0
DM		 443 if ($err) {
444 foreach my $volid (@$vollist) {
445 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
446 warn $@ if $@;
447 }
448 die "create failed - $err";
449 }
502d18a2 450
be517049 451 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
5fdbe4f0
DM		 452 };
453
a0d1b1a2 454 return $rpcenv->fork_worker('qmcreate', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 455 };
456
191435c6 457 return PVE::QemuServer::lock_config_full($vmid, 1, $archive ? $restorefn : $createfn);
1e3baf05
DM		 458 }});
459
460__PACKAGE__->register_method({
461 name => 'vmdiridx',
afdb31d5 462 path => '{vmid}',
1e3baf05
DM		 463 method => 'GET',
464 proxyto => 'node',
465 description => "Directory index",
a0d1b1a2
DM		 466 permissions => {
467 user => 'all',
468 },
1e3baf05
DM		 469 parameters => {
470 additionalProperties => 0,
471 properties => {
472 node => get_standard_option('pve-node'),
473 vmid => get_standard_option('pve-vmid'),
474 },
475 },
476 returns => {
477 type => 'array',
478 items => {
479 type => "object",
480 properties => {
481 subdir => { type => 'string' },
482 },
483 },
484 links => [ { rel => 'child', href => "{subdir}" } ],
485 },
486 code => sub {
487 my ($param) = @_;
488
489 my $res = [
490 { subdir => 'config' },
491 { subdir => 'status' },
492 { subdir => 'unlink' },
493 { subdir => 'vncproxy' },
3ea94c60 494 { subdir => 'migrate' },
2f48a4f5 495 { subdir => 'resize' },
586bfa78 496 { subdir => 'move' },
1e3baf05
DM		 497 { subdir => 'rrd' },
498 { subdir => 'rrddata' },
91c94f0a 499 { subdir => 'monitor' },
7e7d7b61 500 { subdir => 'snapshot' },
1e3baf05 501 ];
afdb31d5 502
1e3baf05
DM		 503 return $res;
504 }});
505
506__PACKAGE__->register_method({
afdb31d5
DM		 507 name => 'rrd',
508 path => '{vmid}/rrd',
1e3baf05
DM		 509 method => 'GET',
510 protected => 1, # fixme: can we avoid that?
511 permissions => {
378b359e 512 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 513 },
514 description => "Read VM RRD statistics (returns PNG)",
515 parameters => {
516 additionalProperties => 0,
517 properties => {
518 node => get_standard_option('pve-node'),
519 vmid => get_standard_option('pve-vmid'),
520 timeframe => {
521 description => "Specify the time frame you are interested in.",
522 type => 'string',
523 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
524 },
525 ds => {
526 description => "The list of datasources you want to display.",
527 type => 'string', format => 'pve-configid-list',
528 },
529 cf => {
530 description => "The RRD consolidation function",
531 type => 'string',
532 enum => [ 'AVERAGE', 'MAX' ],
533 optional => 1,
534 },
535 },
536 },
537 returns => {
538 type => "object",
539 properties => {
540 filename => { type => 'string' },
541 },
542 },
543 code => sub {
544 my ($param) = @_;
545
546 return PVE::Cluster::create_rrd_graph(
afdb31d5 547 "pve2-vm/$param->{vmid}", $param->{timeframe},
1e3baf05 548 $param->{ds}, $param->{cf});
afdb31d5 549
1e3baf05
DM		 550 }});
551
552__PACKAGE__->register_method({
afdb31d5
DM		 553 name => 'rrddata',
554 path => '{vmid}/rrddata',
1e3baf05
DM		 555 method => 'GET',
556 protected => 1, # fixme: can we avoid that?
557 permissions => {
378b359e 558 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 559 },
560 description => "Read VM RRD statistics",
561 parameters => {
562 additionalProperties => 0,
563 properties => {
564 node => get_standard_option('pve-node'),
565 vmid => get_standard_option('pve-vmid'),
566 timeframe => {
567 description => "Specify the time frame you are interested in.",
568 type => 'string',
569 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
570 },
571 cf => {
572 description => "The RRD consolidation function",
573 type => 'string',
574 enum => [ 'AVERAGE', 'MAX' ],
575 optional => 1,
576 },
577 },
578 },
579 returns => {
580 type => "array",
581 items => {
582 type => "object",
583 properties => {},
584 },
585 },
586 code => sub {
587 my ($param) = @_;
588
589 return PVE::Cluster::create_rrd_data(
590 "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{cf});
591 }});
592
593
594__PACKAGE__->register_method({
afdb31d5
DM		 595 name => 'vm_config',
596 path => '{vmid}/config',
1e3baf05
DM		 597 method => 'GET',
598 proxyto => 'node',
599 description => "Get virtual machine configuration.",
a0d1b1a2
DM		 600 permissions => {
601 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
602 },
1e3baf05
DM		 603 parameters => {
604 additionalProperties => 0,
605 properties => {
606 node => get_standard_option('pve-node'),
607 vmid => get_standard_option('pve-vmid'),
608 },
609 },
afdb31d5 610 returns => {
1e3baf05 611 type => "object",
554ac7e7
DM		 612 properties => {
613 digest => {
614 type => 'string',
615 description => 'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
616 }
617 },
1e3baf05
DM		 618 },
619 code => sub {
620 my ($param) = @_;
621
622 my $conf = PVE::QemuServer::load_config($param->{vmid});
623
22c377f0
DM		 624 delete $conf->{snapshots};
625
1e3baf05
DM		 626 return $conf;
627 }});
628
ae57f6b3
DM		 629my $vm_is_volid_owner = sub {
630 my ($storecfg, $vmid, $volid) =@_;
631
632 if ($volid !~ m|^/|) {
633 my ($path, $owner);
634 eval { ($path, $owner) = PVE::Storage::path($storecfg, $volid); };
635 if ($owner && ($owner == $vmid)) {
636 return 1;
637 }
638 }
639
640 return undef;
641};
642
643my $test_deallocate_drive = sub {
644 my ($storecfg, $vmid, $key, $drive, $force) = @_;
645
646 if (!PVE::QemuServer::drive_is_cdrom($drive)) {
647 my $volid = $drive->{file};
648 if (&$vm_is_volid_owner($storecfg, $vmid, $volid)) {
649 if ($force || $key =~ m/^unused/) {
650 my $sid = PVE::Storage::parse_volume_id($volid);
651 return $sid;
652 }
653 }
654 }
655
656 return undef;
657};
658
5d7a6767 659my $delete_drive = sub {
1858638f 660 my ($conf, $storecfg, $vmid, $key, $drive, $force) = @_;
5d7a6767
DM		 661
662 if (!PVE::QemuServer::drive_is_cdrom($drive)) {
663 my $volid = $drive->{file};
a8e2f942 664
ae57f6b3 665 if (&$vm_is_volid_owner($storecfg, $vmid, $volid)) {
a8e2f942
DM		 666 if ($force || $key =~ m/^unused/) {
667 eval {
668 # check if the disk is really unused
669 my $used_paths = PVE::QemuServer::get_used_paths($vmid, $storecfg, $conf, 1, $key);
670 my $path = PVE::Storage::path($storecfg, $volid);
671
672 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
673 if $used_paths->{$path};
674
675 PVE::Storage::vdisk_free($storecfg, $volid);
676 };
7e4e69a6 677 die $@ if $@;
ae57f6b3
DM		 678 } else {
679 PVE::QemuServer::add_unused_volume($conf, $volid, $vmid);
5d7a6767 680 }
ae57f6b3
DM		 681 }
682 }
49f9db93
DM		 683
684 delete $conf->{$key};
ae57f6b3
DM		 685};
686
687my $vmconfig_delete_option = sub {
688 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force) = @_;
689
690 return if !defined($conf->{$opt});
691
692 my $isDisk = PVE::QemuServer::valid_drivename($opt)|| ($opt =~ m/^unused/);
693
694 if ($isDisk) {
695 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
696
697 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
75466c4f 698 if (my $sid = &$test_deallocate_drive($storecfg, $vmid, $opt, $drive, $force)) {
fcbb753e 699 $rpcenv->check($authuser, "/storage/$sid", ['Datastore.Allocate']);
5d7a6767 700 }
ae57f6b3 701 }
9a8d6b66
AD		 702
703 my $unplugwarning = "";
704 if($conf->{ostype} && $conf->{ostype} eq 'l26'){
705 $unplugwarning = "<br>verify that you have acpiphp && pci_hotplug modules loaded in your guest VM";
706 }elsif($conf->{ostype} && $conf->{ostype} eq 'l24'){
707 $unplugwarning = "<br>kernel 2.4 don't support hotplug, please disable hotplug in options";
708 }elsif(!$conf->{ostype} || ($conf->{ostype} && $conf->{ostype} eq 'other')){
709 $unplugwarning = "<br>verify that your guest support acpi hotplug";
710 }
711
e8a7e9b4
AD		 712 if($opt eq 'tablet'){
713 PVE::QemuServer::vm_deviceplug(undef, $conf, $vmid, $opt);
714 }else{
715 die "error hot-unplug $opt $unplugwarning" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
716 }
cd6ecb89 717
ae57f6b3
DM		 718 if ($isDisk) {
719 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
720 &$delete_drive($conf, $storecfg, $vmid, $opt, $drive, $force);
5d7a6767 721 } else {
ae57f6b3
DM		 722 delete $conf->{$opt};
723 }
724
725 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
726};
727
9bf371a6 728my $safe_num_ne = sub {
93ae06e1
DM		 729 my ($a, $b) = @_;
730
75466c4f
DM		 731 return 0 if !defined($a) && !defined($b);
732 return 1 if !defined($a);
733 return 1 if !defined($b);
93ae06e1
DM		 734
735 return $a != $b;
736};
737
ae57f6b3
DM		 738my $vmconfig_update_disk = sub {
739 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $value, $force) = @_;
5d7a6767 740
ae57f6b3
DM		 741 my $drive = PVE::QemuServer::parse_drive($opt, $value);
742
743 if (PVE::QemuServer::drive_is_cdrom($drive)) { #cdrom
744 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
745 } else {
746 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
747 }
748
749 if ($conf->{$opt}) {
750
751 if (my $old_drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt})) {
752
753 my $media = $drive->{media} || 'disk';
754 my $oldmedia = $old_drive->{media} || 'disk';
755 die "unable to change media type\n" if $media ne $oldmedia;
756
757 if (!PVE::QemuServer::drive_is_cdrom($old_drive) &&
758 ($drive->{file} ne $old_drive->{file})) { # delete old disks
759
760 &$vmconfig_delete_option($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force);
761 $conf = PVE::QemuServer::load_config($vmid); # update/reload
762 }
0f56d571 763
9bf371a6
DM		 764 if(&$safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
765 &$safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
766 &$safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
767 &$safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
768 &$safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
769 &$safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr})) {
75466c4f
DM		 770 PVE::QemuServer::qemu_block_set_io_throttle($vmid,"drive-$opt", $drive->{mbps}*1024*1024,
771 $drive->{mbps_rd}*1024*1024, $drive->{mbps_wr}*1024*1024,
772 $drive->{iops}, $drive->{iops_rd}, $drive->{iops_wr})
9bf371a6 773 if !PVE::QemuServer::drive_is_cdrom($drive);
0f56d571 774 }
ae57f6b3
DM		 775 }
776 }
777
778 &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, undef, {$opt => $value});
779 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
780
781 $conf = PVE::QemuServer::load_config($vmid); # update/reload
782 $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
783
784 if (PVE::QemuServer::drive_is_cdrom($drive)) { # cdrom
785
786 if (PVE::QemuServer::check_running($vmid)) {
787 if ($drive->{file} eq 'none') {
ce156282 788 PVE::QemuServer::vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
ae57f6b3
DM		 789 } else {
790 my $path = PVE::QemuServer::get_iso_path($storecfg, $vmid, $drive->{file});
ce156282
AD		 791 PVE::QemuServer::vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt"); #force eject if locked
792 PVE::QemuServer::vm_mon_cmd($vmid, "change",device => "drive-$opt",target => "$path") if $path;
ae57f6b3
DM		 793 }
794 }
795
796 } else { # hotplug new disks
797
798 die "error hotplug $opt" if !PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
5d7a6767 799 }
5d7a6767
DM		 800};
801
ae57f6b3
DM		 802my $vmconfig_update_net = sub {
803 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $value) = @_;
804
de8f60b2
AD		 805 if ($conf->{$opt} && PVE::QemuServer::check_running($vmid)) {
806 my $oldnet = PVE::QemuServer::parse_net($conf->{$opt});
807 my $newnet = PVE::QemuServer::parse_net($value);
808
809 if($oldnet->{model} ne $newnet->{model}){
810 #if model change, we try to hot-unplug
811 die "error hot-unplug $opt for update" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
812 }else{
75466c4f 813
de8f60b2
AD		 814 if($newnet->{bridge} && $oldnet->{bridge}){
815 my $iface = "tap".$vmid."i".$1 if $opt =~ m/net(\d+)/;
ae57f6b3 816
de8f60b2
AD		 817 if($newnet->{rate} ne $oldnet->{rate}){
818 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
819 }
820
821 if(($newnet->{bridge} ne $oldnet->{bridge}) || ($newnet->{tag} ne $oldnet->{tag})){
822 eval{PVE::Network::tap_unplug($iface, $oldnet->{bridge}, $oldnet->{tag});};
823 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag});
824 }
825
826 }else{
827 #if bridge/nat mode change, we try to hot-unplug
828 die "error hot-unplug $opt for update" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
829 }
830 }
75466c4f 831
de8f60b2 832 }
ae57f6b3
DM		 833 $conf->{$opt} = $value;
834 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
835 $conf = PVE::QemuServer::load_config($vmid); # update/reload
836
837 my $net = PVE::QemuServer::parse_net($conf->{$opt});
838
839 die "error hotplug $opt" if !PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $net);
840};
841
a0d1b1a2 842my $vm_config_perm_list = [
75466c4f
DM		 843 'VM.Config.Disk',
844 'VM.Config.CDROM',
845 'VM.Config.CPU',
846 'VM.Config.Memory',
847 'VM.Config.Network',
a0d1b1a2
DM		 848 'VM.Config.HWType',
849 'VM.Config.Options',
850 ];
851
1e3baf05 852__PACKAGE__->register_method({
afdb31d5
DM		 853 name => 'update_vm',
854 path => '{vmid}/config',
1e3baf05
DM		 855 method => 'PUT',
856 protected => 1,
857 proxyto => 'node',
858 description => "Set virtual machine options.",
a0d1b1a2
DM		 859 permissions => {
860 check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
861 },
1e3baf05
DM		 862 parameters => {
863 additionalProperties => 0,
864 properties => PVE::QemuServer::json_config_properties(
865 {
866 node => get_standard_option('pve-node'),
867 vmid => get_standard_option('pve-vmid'),
3ea94c60 868 skiplock => get_standard_option('skiplock'),
1e3baf05
DM		 869 delete => {
870 type => 'string', format => 'pve-configid-list',
871 description => "A list of settings you want to delete.",
872 optional => 1,
873 },
874 force => {
875 type => 'boolean',
876 description => $opt_force_description,
877 optional => 1,
878 requires => 'delete',
879 },
554ac7e7
DM		 880 digest => {
881 type => 'string',
882 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
883 maxLength => 40,
afdb31d5 884 optional => 1,
554ac7e7 885 }
1e3baf05
DM		 886 }),
887 },
888 returns => { type => 'null'},
889 code => sub {
890 my ($param) = @_;
891
892 my $rpcenv = PVE::RPCEnvironment::get();
893
a0d1b1a2 894 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 895
896 my $node = extract_param($param, 'node');
897
1e3baf05
DM		 898 my $vmid = extract_param($param, 'vmid');
899
5fdbe4f0
DM		 900 my $digest = extract_param($param, 'digest');
901
902 my @paramarr = (); # used for log message
903 foreach my $key (keys %$param) {
904 push @paramarr, "-$key", $param->{$key};
905 }
906
1e3baf05 907 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 908 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 909 if $skiplock && $authuser ne 'root@pam';
1e3baf05 910
0532bc63
DM		 911 my $delete_str = extract_param($param, 'delete');
912
1e3baf05
DM		 913 my $force = extract_param($param, 'force');
914
0532bc63
DM		 915 die "no options specified\n" if !$delete_str && !scalar(keys %$param);
916
1e68cb19
DM		 917 my $storecfg = PVE::Storage::config();
918
7bfdeb5f
DM		 919 my $defaults = PVE::QemuServer::load_defaults();
920
1e68cb19
DM		 921 &$resolve_cdrom_alias($param);
922
923 # now try to verify all parameters
924
0532bc63
DM		 925 my @delete = ();
926 foreach my $opt (PVE::Tools::split_list($delete_str)) {
927 $opt = 'ide2' if $opt eq 'cdrom';
928 raise_param_exc({ delete => "you can't use '-$opt' and " .
929 "-delete $opt' at the same time" })
930 if defined($param->{$opt});
931
932 if (!PVE::QemuServer::option_exists($opt)) {
933 raise_param_exc({ delete => "unknown option '$opt'" });
934 }
ae57f6b3 935
0532bc63
DM		 936 push @delete, $opt;
937 }
1e3baf05 938
1e68cb19
DM		 939 foreach my $opt (keys %$param) {
940 if (PVE::QemuServer::valid_drivename($opt)) {
941 # cleanup drive path
942 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
943 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
944 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
75466c4f 945 } elsif ($opt =~ m/^net(\d+)$/) {
1e68cb19
DM		 946 # add macaddr
947 my $net = PVE::QemuServer::parse_net($param->{$opt});
948 $param->{$opt} = PVE::QemuServer::print_net($net);
1e68cb19
DM		 949 }
950 }
1e3baf05 951
ae57f6b3
DM		 952 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [@delete]);
953
954 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [keys %$param]);
955
fcbb753e 956 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param);
1e3baf05 957
5d39a182 958 my $updatefn = sub {
1e3baf05 959
5d39a182 960 my $conf = PVE::QemuServer::load_config($vmid);
1e3baf05 961
5d39a182
DM		 962 die "checksum missmatch (file change by other user?)\n"
963 if $digest && $digest ne $conf->{digest};
1e3baf05 964
5d39a182 965 PVE::QemuServer::check_lock($conf) if !$skiplock;
1e3baf05 966
7bfdeb5f
DM		 967 if ($param->{memory} || defined($param->{balloon})) {
968 my $maxmem = $param->{memory} || $conf->{memory} || $defaults->{memory};
969 my $balloon = defined($param->{balloon}) ? $param->{balloon} : $conf->{balloon};
970
971 die "balloon value too large (must be smaller than assigned memory)\n"
6e46ac07 972 if $balloon && $balloon > $maxmem;
7bfdeb5f
DM		 973 }
974
a0d1b1a2 975 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: " . join (' ', @paramarr));
c2a64aa7 976
5d7a6767 977 foreach my $opt (@delete) { # delete
1e68cb19 978 $conf = PVE::QemuServer::load_config($vmid); # update/reload
ae57f6b3 979 &$vmconfig_delete_option($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force);
5d39a182 980 }
1e3baf05 981
7bfdeb5f
DM		 982 my $running = PVE::QemuServer::check_running($vmid);
983
5d7a6767 984 foreach my $opt (keys %$param) { # add/change
1e3baf05 985
1e68cb19 986 $conf = PVE::QemuServer::load_config($vmid); # update/reload
1e3baf05 987
5d7a6767
DM		 988 next if $conf->{$opt} && ($param->{$opt} eq $conf->{$opt}); # skip if nothing changed
989
ae57f6b3 990 if (PVE::QemuServer::valid_drivename($opt)) {
5d7a6767 991
75466c4f 992 &$vmconfig_update_disk($rpcenv, $authuser, $conf, $storecfg, $vmid,
ae57f6b3 993 $opt, $param->{$opt}, $force);
75466c4f 994
ae57f6b3 995 } elsif ($opt =~ m/^net(\d+)$/) { #nics
1858638f 996
75466c4f 997 &$vmconfig_update_net($rpcenv, $authuser, $conf, $storecfg, $vmid,
ae57f6b3 998 $opt, $param->{$opt});
1e68cb19
DM		 999
1000 } else {
1001
cd6ecb89
AD		 1002 if($opt eq 'tablet' && $param->{$opt} == 1){
1003 PVE::QemuServer::vm_deviceplug(undef, $conf, $vmid, $opt);
1004 }elsif($opt eq 'tablet' && $param->{$opt} == 0){
1005 PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
1006 }
1007
1858638f
DM		 1008 $conf->{$opt} = $param->{$opt};
1009 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
3a1e36bb 1010 }
5d39a182 1011 }
7bfdeb5f
DM		 1012
1013 # allow manual ballooning if shares is set to zero
75466c4f 1014 if ($running && defined($param->{balloon}) &&
7bfdeb5f
DM		 1015 defined($conf->{shares}) && ($conf->{shares} == 0)) {
1016 my $balloon = $param->{'balloon'} || $conf->{memory} || $defaults->{memory};
1017 PVE::QemuServer::vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
1018 }
1019
5d39a182
DM		 1020 };
1021
1022 PVE::QemuServer::lock_config($vmid, $updatefn);
fcdb0117 1023
1e3baf05
DM		 1024 return undef;
1025 }});
1026
1027
1028__PACKAGE__->register_method({
afdb31d5
DM		 1029 name => 'destroy_vm',
1030 path => '{vmid}',
1e3baf05
DM		 1031 method => 'DELETE',
1032 protected => 1,
1033 proxyto => 'node',
1034 description => "Destroy the vm (also delete all used/owned volumes).",
a0d1b1a2
DM		 1035 permissions => {
1036 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
1037 },
1e3baf05
DM		 1038 parameters => {
1039 additionalProperties => 0,
1040 properties => {
1041 node => get_standard_option('pve-node'),
1042 vmid => get_standard_option('pve-vmid'),
3ea94c60 1043 skiplock => get_standard_option('skiplock'),
1e3baf05
DM		 1044 },
1045 },
afdb31d5 1046 returns => {
5fdbe4f0
DM		 1047 type => 'string',
1048 },
1e3baf05
DM		 1049 code => sub {
1050 my ($param) = @_;
1051
1052 my $rpcenv = PVE::RPCEnvironment::get();
1053
a0d1b1a2 1054 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1055
1056 my $vmid = $param->{vmid};
1057
1058 my $skiplock = $param->{skiplock};
afdb31d5 1059 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1060 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1061
5fdbe4f0
DM		 1062 # test if VM exists
1063 my $conf = PVE::QemuServer::load_config($vmid);
1064
afdb31d5 1065 my $storecfg = PVE::Storage::config();
1e3baf05 1066
75466c4f 1067 my $delVMfromPoolFn = sub {
502d18a2 1068 my $usercfg = cfs_read_file("user.cfg");
5d0094ea
DM		 1069 if (my $pool = $usercfg->{vms}->{$vmid}) {
1070 if (my $data = $usercfg->{pools}->{$pool}) {
1071 delete $data->{vms}->{$vmid};
1072 delete $usercfg->{vms}->{$vmid};
1073 cfs_write_file("user.cfg", $usercfg);
1074 }
502d18a2
DM		 1075 }
1076 };
1077
5fdbe4f0 1078 my $realcmd = sub {
ff1a2432
DM		 1079 my $upid = shift;
1080
1081 syslog('info', "destroy VM $vmid: $upid\n");
1082
5fdbe4f0 1083 PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock);
502d18a2 1084
be517049 1085 PVE::AccessControl::remove_vm_from_pool($vmid);
5fdbe4f0 1086 };
1e3baf05 1087
a0d1b1a2 1088 return $rpcenv->fork_worker('qmdestroy', $vmid, $authuser, $realcmd);
1e3baf05
DM		 1089 }});
1090
1091__PACKAGE__->register_method({
afdb31d5
DM		 1092 name => 'unlink',
1093 path => '{vmid}/unlink',
1e3baf05
DM		 1094 method => 'PUT',
1095 protected => 1,
1096 proxyto => 'node',
1097 description => "Unlink/delete disk images.",
a0d1b1a2
DM		 1098 permissions => {
1099 check => [ 'perm', '/vms/{vmid}', ['VM.Config.Disk']],
1100 },
1e3baf05
DM		 1101 parameters => {
1102 additionalProperties => 0,
1103 properties => {
1104 node => get_standard_option('pve-node'),
1105 vmid => get_standard_option('pve-vmid'),
1106 idlist => {
1107 type => 'string', format => 'pve-configid-list',
1108 description => "A list of disk IDs you want to delete.",
1109 },
1110 force => {
1111 type => 'boolean',
1112 description => $opt_force_description,
1113 optional => 1,
1114 },
1115 },
1116 },
1117 returns => { type => 'null'},
1118 code => sub {
1119 my ($param) = @_;
1120
1121 $param->{delete} = extract_param($param, 'idlist');
1122
1123 __PACKAGE__->update_vm($param);
1124
1125 return undef;
1126 }});
1127
1128my $sslcert;
1129
1130__PACKAGE__->register_method({
afdb31d5
DM		 1131 name => 'vncproxy',
1132 path => '{vmid}/vncproxy',
1e3baf05
DM		 1133 method => 'POST',
1134 protected => 1,
1135 permissions => {
378b359e 1136 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1e3baf05
DM		 1137 },
1138 description => "Creates a TCP VNC proxy connections.",
1139 parameters => {
1140 additionalProperties => 0,
1141 properties => {
1142 node => get_standard_option('pve-node'),
1143 vmid => get_standard_option('pve-vmid'),
1144 },
1145 },
afdb31d5 1146 returns => {
1e3baf05
DM		 1147 additionalProperties => 0,
1148 properties => {
1149 user => { type => 'string' },
1150 ticket => { type => 'string' },
1151 cert => { type => 'string' },
1152 port => { type => 'integer' },
1153 upid => { type => 'string' },
1154 },
1155 },
1156 code => sub {
1157 my ($param) = @_;
1158
1159 my $rpcenv = PVE::RPCEnvironment::get();
1160
a0d1b1a2 1161 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1162
1163 my $vmid = $param->{vmid};
1164 my $node = $param->{node};
1165
b6f39da2
DM		 1166 my $authpath = "/vms/$vmid";
1167
a0d1b1a2 1168 my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath);
b6f39da2 1169
1e3baf05
DM		 1170 $sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192)
1171 if !$sslcert;
1172
1173 my $port = PVE::Tools::next_vnc_port();
1174
1175 my $remip;
afdb31d5 1176
4f1be36c 1177 if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
1e3baf05
DM		 1178 $remip = PVE::Cluster::remote_node_ip($node);
1179 }
1180
6bb726c9
SP		 1181 # NOTE: kvm VNC traffic is already TLS encrypted
1182 my $remcmd = $remip ? ['/usr/bin/ssh', '-T', '-o', 'BatchMode=yes', $remip] : [];
1e3baf05 1183
afdb31d5 1184 my $timeout = 10;
1e3baf05
DM		 1185
1186 my $realcmd = sub {
1187 my $upid = shift;
1188
1189 syslog('info', "starting vnc proxy $upid\n");
1190
1191 my $qmcmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
1192
1193 my $qmstr = join(' ', @$qmcmd);
1194
1195 # also redirect stderr (else we get RFB protocol errors)
be62c45c 1196 my $cmd = ['/bin/nc', '-l', '-p', $port, '-w', $timeout, '-c', "$qmstr 2>/dev/null"];
1e3baf05 1197
be62c45c 1198 PVE::Tools::run_command($cmd);
1e3baf05
DM		 1199
1200 return;
1201 };
1202
a0d1b1a2 1203 my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd);
1e3baf05 1204
3da85107
DM		 1205 PVE::Tools::wait_for_vnc_port($port);
1206
1e3baf05 1207 return {
a0d1b1a2 1208 user => $authuser,
1e3baf05 1209 ticket => $ticket,
afdb31d5
DM		 1210 port => $port,
1211 upid => $upid,
1212 cert => $sslcert,
1e3baf05
DM		 1213 };
1214 }});
1215
5fdbe4f0
DM		 1216__PACKAGE__->register_method({
1217 name => 'vmcmdidx',
afdb31d5 1218 path => '{vmid}/status',
5fdbe4f0
DM		 1219 method => 'GET',
1220 proxyto => 'node',
1221 description => "Directory index",
a0d1b1a2
DM		 1222 permissions => {
1223 user => 'all',
1224 },
5fdbe4f0
DM		 1225 parameters => {
1226 additionalProperties => 0,
1227 properties => {
1228 node => get_standard_option('pve-node'),
1229 vmid => get_standard_option('pve-vmid'),
1230 },
1231 },
1232 returns => {
1233 type => 'array',
1234 items => {
1235 type => "object",
1236 properties => {
1237 subdir => { type => 'string' },
1238 },
1239 },
1240 links => [ { rel => 'child', href => "{subdir}" } ],
1241 },
1242 code => sub {
1243 my ($param) = @_;
1244
1245 # test if VM exists
1246 my $conf = PVE::QemuServer::load_config($param->{vmid});
1247
1248 my $res = [
1249 { subdir => 'current' },
1250 { subdir => 'start' },
1251 { subdir => 'stop' },
1252 ];
afdb31d5 1253
5fdbe4f0
DM		 1254 return $res;
1255 }});
1256
88fc87b4
DM		 1257my $vm_is_ha_managed = sub {
1258 my ($vmid) = @_;
1259
1260 my $cc = PVE::Cluster::cfs_read_file('cluster.conf');
1261 if (PVE::Cluster::cluster_conf_lookup_pvevm($cc, 0, $vmid, 1)) {
1262 return 1;
75466c4f 1263 }
88fc87b4
DM		 1264 return 0;
1265};
1266
1e3baf05 1267__PACKAGE__->register_method({
afdb31d5 1268 name => 'vm_status',
5fdbe4f0 1269 path => '{vmid}/status/current',
1e3baf05
DM		 1270 method => 'GET',
1271 proxyto => 'node',
1272 protected => 1, # qemu pid files are only readable by root
1273 description => "Get virtual machine status.",
a0d1b1a2
DM		 1274 permissions => {
1275 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1276 },
1e3baf05
DM		 1277 parameters => {
1278 additionalProperties => 0,
1279 properties => {
1280 node => get_standard_option('pve-node'),
1281 vmid => get_standard_option('pve-vmid'),
1282 },
1283 },
1284 returns => { type => 'object' },
1285 code => sub {
1286 my ($param) = @_;
1287
1288 # test if VM exists
1289 my $conf = PVE::QemuServer::load_config($param->{vmid});
1290
03a33f30 1291 my $vmstatus = PVE::QemuServer::vmstatus($param->{vmid}, 1);
8610701a 1292 my $status = $vmstatus->{$param->{vmid}};
1e3baf05 1293
88fc87b4 1294 $status->{ha} = &$vm_is_ha_managed($param->{vmid});
8610701a
DM		 1295
1296 return $status;
1e3baf05
DM		 1297 }});
1298
1299__PACKAGE__->register_method({
afdb31d5 1300 name => 'vm_start',
5fdbe4f0
DM		 1301 path => '{vmid}/status/start',
1302 method => 'POST',
1e3baf05
DM		 1303 protected => 1,
1304 proxyto => 'node',
5fdbe4f0 1305 description => "Start virtual machine.",
a0d1b1a2
DM		 1306 permissions => {
1307 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1308 },
1e3baf05
DM		 1309 parameters => {
1310 additionalProperties => 0,
1311 properties => {
1312 node => get_standard_option('pve-node'),
1313 vmid => get_standard_option('pve-vmid'),
3ea94c60
DM		 1314 skiplock => get_standard_option('skiplock'),
1315 stateuri => get_standard_option('pve-qm-stateuri'),
7e8dcf2c
AD		 1316 migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
1317
1e3baf05
DM		 1318 },
1319 },
afdb31d5 1320 returns => {
5fdbe4f0
DM		 1321 type => 'string',
1322 },
1e3baf05
DM		 1323 code => sub {
1324 my ($param) = @_;
1325
1326 my $rpcenv = PVE::RPCEnvironment::get();
1327
a0d1b1a2 1328 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1329
1330 my $node = extract_param($param, 'node');
1331
1e3baf05
DM		 1332 my $vmid = extract_param($param, 'vmid');
1333
3ea94c60 1334 my $stateuri = extract_param($param, 'stateuri');
afdb31d5 1335 raise_param_exc({ stateuri => "Only root may use this option." })
a0d1b1a2 1336 if $stateuri && $authuser ne 'root@pam';
3ea94c60 1337
1e3baf05 1338 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1339 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1340 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1341
7e8dcf2c
AD		 1342 my $migratedfrom = extract_param($param, 'migratedfrom');
1343 raise_param_exc({ migratedfrom => "Only root may use this option." })
1344 if $migratedfrom && $authuser ne 'root@pam';
1345
afdb31d5 1346 my $storecfg = PVE::Storage::config();
5fdbe4f0 1347
cce37749
DM		 1348 if (&$vm_is_ha_managed($vmid) && !$stateuri &&
1349 $rpcenv->{type} ne 'ha') {
5fdbe4f0 1350
88fc87b4
DM		 1351 my $hacmd = sub {
1352 my $upid = shift;
5fdbe4f0 1353
88fc87b4 1354 my $service = "pvevm:$vmid";
5fdbe4f0 1355
88fc87b4
DM		 1356 my $cmd = ['clusvcadm', '-e', $service, '-m', $node];
1357
1358 print "Executing HA start for VM $vmid\n";
1359
1360 PVE::Tools::run_command($cmd);
1361
1362 return;
1363 };
1364
1365 return $rpcenv->fork_worker('hastart', $vmid, $authuser, $hacmd);
1366
1367 } else {
1368
1369 my $realcmd = sub {
1370 my $upid = shift;
1371
1372 syslog('info', "start VM $vmid: $upid\n");
1373
7e8dcf2c 1374 PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock, $migratedfrom);
88fc87b4
DM		 1375
1376 return;
1377 };
5fdbe4f0 1378
88fc87b4
DM		 1379 return $rpcenv->fork_worker('qmstart', $vmid, $authuser, $realcmd);
1380 }
5fdbe4f0
DM		 1381 }});
1382
1383__PACKAGE__->register_method({
afdb31d5 1384 name => 'vm_stop',
5fdbe4f0
DM		 1385 path => '{vmid}/status/stop',
1386 method => 'POST',
1387 protected => 1,
1388 proxyto => 'node',
1389 description => "Stop virtual machine.",
a0d1b1a2
DM		 1390 permissions => {
1391 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1392 },
5fdbe4f0
DM		 1393 parameters => {
1394 additionalProperties => 0,
1395 properties => {
1396 node => get_standard_option('pve-node'),
1397 vmid => get_standard_option('pve-vmid'),
1398 skiplock => get_standard_option('skiplock'),
af30308f 1399 migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
c6bb9502
DM		 1400 timeout => {
1401 description => "Wait maximal timeout seconds.",
1402 type => 'integer',
1403 minimum => 0,
1404 optional => 1,
254575e9
DM		 1405 },
1406 keepActive => {
1407 description => "Do not decativate storage volumes.",
1408 type => 'boolean',
1409 optional => 1,
1410 default => 0,
c6bb9502 1411 }
5fdbe4f0
DM		 1412 },
1413 },
afdb31d5 1414 returns => {
5fdbe4f0
DM		 1415 type => 'string',
1416 },
1417 code => sub {
1418 my ($param) = @_;
1419
1420 my $rpcenv = PVE::RPCEnvironment::get();
1421
a0d1b1a2 1422 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1423
1424 my $node = extract_param($param, 'node');
1425
1426 my $vmid = extract_param($param, 'vmid');
1427
1428 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1429 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1430 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1431
254575e9 1432 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1433 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1434 if $keepActive && $authuser ne 'root@pam';
254575e9 1435
af30308f
DM		 1436 my $migratedfrom = extract_param($param, 'migratedfrom');
1437 raise_param_exc({ migratedfrom => "Only root may use this option." })
1438 if $migratedfrom && $authuser ne 'root@pam';
1439
1440
ff1a2432
DM		 1441 my $storecfg = PVE::Storage::config();
1442
3be30d63 1443 if (&$vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
5fdbe4f0 1444
88fc87b4
DM		 1445 my $hacmd = sub {
1446 my $upid = shift;
5fdbe4f0 1447
88fc87b4 1448 my $service = "pvevm:$vmid";
c6bb9502 1449
88fc87b4
DM		 1450 my $cmd = ['clusvcadm', '-d', $service];
1451
1452 print "Executing HA stop for VM $vmid\n";
1453
1454 PVE::Tools::run_command($cmd);
5fdbe4f0 1455
88fc87b4
DM		 1456 return;
1457 };
1458
1459 return $rpcenv->fork_worker('hastop', $vmid, $authuser, $hacmd);
1460
1461 } else {
1462 my $realcmd = sub {
1463 my $upid = shift;
1464
1465 syslog('info', "stop VM $vmid: $upid\n");
1466
1467 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0,
af30308f 1468 $param->{timeout}, 0, 1, $keepActive, $migratedfrom);
88fc87b4
DM		 1469
1470 return;
1471 };
1472
1473 return $rpcenv->fork_worker('qmstop', $vmid, $authuser, $realcmd);
1474 }
5fdbe4f0
DM		 1475 }});
1476
1477__PACKAGE__->register_method({
afdb31d5 1478 name => 'vm_reset',
5fdbe4f0
DM		 1479 path => '{vmid}/status/reset',
1480 method => 'POST',
1481 protected => 1,
1482 proxyto => 'node',
1483 description => "Reset virtual machine.",
a0d1b1a2
DM		 1484 permissions => {
1485 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1486 },
5fdbe4f0
DM		 1487 parameters => {
1488 additionalProperties => 0,
1489 properties => {
1490 node => get_standard_option('pve-node'),
1491 vmid => get_standard_option('pve-vmid'),
1492 skiplock => get_standard_option('skiplock'),
1493 },
1494 },
afdb31d5 1495 returns => {
5fdbe4f0
DM		 1496 type => 'string',
1497 },
1498 code => sub {
1499 my ($param) = @_;
1500
1501 my $rpcenv = PVE::RPCEnvironment::get();
1502
a0d1b1a2 1503 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1504
1505 my $node = extract_param($param, 'node');
1506
1507 my $vmid = extract_param($param, 'vmid');
1508
1509 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1510 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1511 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1512
ff1a2432
DM		 1513 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1514
5fdbe4f0
DM		 1515 my $realcmd = sub {
1516 my $upid = shift;
1517
1e3baf05 1518 PVE::QemuServer::vm_reset($vmid, $skiplock);
5fdbe4f0
DM		 1519
1520 return;
1521 };
1522
a0d1b1a2 1523 return $rpcenv->fork_worker('qmreset', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1524 }});
1525
1526__PACKAGE__->register_method({
afdb31d5 1527 name => 'vm_shutdown',
5fdbe4f0
DM		 1528 path => '{vmid}/status/shutdown',
1529 method => 'POST',
1530 protected => 1,
1531 proxyto => 'node',
1532 description => "Shutdown virtual machine.",
a0d1b1a2
DM		 1533 permissions => {
1534 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1535 },
5fdbe4f0
DM		 1536 parameters => {
1537 additionalProperties => 0,
1538 properties => {
1539 node => get_standard_option('pve-node'),
1540 vmid => get_standard_option('pve-vmid'),
1541 skiplock => get_standard_option('skiplock'),
c6bb9502
DM		 1542 timeout => {
1543 description => "Wait maximal timeout seconds.",
1544 type => 'integer',
1545 minimum => 0,
1546 optional => 1,
9269013a
DM		 1547 },
1548 forceStop => {
1549 description => "Make sure the VM stops.",
1550 type => 'boolean',
1551 optional => 1,
1552 default => 0,
254575e9
DM		 1553 },
1554 keepActive => {
1555 description => "Do not decativate storage volumes.",
1556 type => 'boolean',
1557 optional => 1,
1558 default => 0,
c6bb9502 1559 }
5fdbe4f0
DM		 1560 },
1561 },
afdb31d5 1562 returns => {
5fdbe4f0
DM		 1563 type => 'string',
1564 },
1565 code => sub {
1566 my ($param) = @_;
1567
1568 my $rpcenv = PVE::RPCEnvironment::get();
1569
a0d1b1a2 1570 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1571
1572 my $node = extract_param($param, 'node');
1573
1574 my $vmid = extract_param($param, 'vmid');
1575
1576 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1577 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1578 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1579
254575e9 1580 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1581 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1582 if $keepActive && $authuser ne 'root@pam';
254575e9 1583
02d07cf5
DM		 1584 my $storecfg = PVE::Storage::config();
1585
5fdbe4f0
DM		 1586 my $realcmd = sub {
1587 my $upid = shift;
1588
1589 syslog('info', "shutdown VM $vmid: $upid\n");
1590
afdb31d5 1591 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
254575e9 1592 1, $param->{forceStop}, $keepActive);
c6bb9502 1593
5fdbe4f0
DM		 1594 return;
1595 };
1596
a0d1b1a2 1597 return $rpcenv->fork_worker('qmshutdown', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1598 }});
1599
1600__PACKAGE__->register_method({
afdb31d5 1601 name => 'vm_suspend',
5fdbe4f0
DM		 1602 path => '{vmid}/status/suspend',
1603 method => 'POST',
1604 protected => 1,
1605 proxyto => 'node',
1606 description => "Suspend virtual machine.",
a0d1b1a2
DM		 1607 permissions => {
1608 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1609 },
5fdbe4f0
DM		 1610 parameters => {
1611 additionalProperties => 0,
1612 properties => {
1613 node => get_standard_option('pve-node'),
1614 vmid => get_standard_option('pve-vmid'),
1615 skiplock => get_standard_option('skiplock'),
1616 },
1617 },
afdb31d5 1618 returns => {
5fdbe4f0
DM		 1619 type => 'string',
1620 },
1621 code => sub {
1622 my ($param) = @_;
1623
1624 my $rpcenv = PVE::RPCEnvironment::get();
1625
a0d1b1a2 1626 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1627
1628 my $node = extract_param($param, 'node');
1629
1630 my $vmid = extract_param($param, 'vmid');
1631
1632 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1633 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1634 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1635
ff1a2432
DM		 1636 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1637
5fdbe4f0
DM		 1638 my $realcmd = sub {
1639 my $upid = shift;
1640
1641 syslog('info', "suspend VM $vmid: $upid\n");
1642
1e3baf05 1643 PVE::QemuServer::vm_suspend($vmid, $skiplock);
5fdbe4f0
DM		 1644
1645 return;
1646 };
1647
a0d1b1a2 1648 return $rpcenv->fork_worker('qmsuspend', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1649 }});
1650
1651__PACKAGE__->register_method({
afdb31d5 1652 name => 'vm_resume',
5fdbe4f0
DM		 1653 path => '{vmid}/status/resume',
1654 method => 'POST',
1655 protected => 1,
1656 proxyto => 'node',
1657 description => "Resume virtual machine.",
a0d1b1a2
DM		 1658 permissions => {
1659 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1660 },
5fdbe4f0
DM		 1661 parameters => {
1662 additionalProperties => 0,
1663 properties => {
1664 node => get_standard_option('pve-node'),
1665 vmid => get_standard_option('pve-vmid'),
1666 skiplock => get_standard_option('skiplock'),
1667 },
1668 },
afdb31d5 1669 returns => {
5fdbe4f0
DM		 1670 type => 'string',
1671 },
1672 code => sub {
1673 my ($param) = @_;
1674
1675 my $rpcenv = PVE::RPCEnvironment::get();
1676
a0d1b1a2 1677 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1678
1679 my $node = extract_param($param, 'node');
1680
1681 my $vmid = extract_param($param, 'vmid');
1682
1683 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1684 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1685 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1686
b7eeab21 1687 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
ff1a2432 1688
5fdbe4f0
DM		 1689 my $realcmd = sub {
1690 my $upid = shift;
1691
1692 syslog('info', "resume VM $vmid: $upid\n");
1693
1e3baf05 1694 PVE::QemuServer::vm_resume($vmid, $skiplock);
1e3baf05 1695
5fdbe4f0
DM		 1696 return;
1697 };
1698
a0d1b1a2 1699 return $rpcenv->fork_worker('qmresume', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1700 }});
1701
1702__PACKAGE__->register_method({
afdb31d5 1703 name => 'vm_sendkey',
5fdbe4f0
DM		 1704 path => '{vmid}/sendkey',
1705 method => 'PUT',
1706 protected => 1,
1707 proxyto => 'node',
1708 description => "Send key event to virtual machine.",
a0d1b1a2
DM		 1709 permissions => {
1710 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1711 },
5fdbe4f0
DM		 1712 parameters => {
1713 additionalProperties => 0,
1714 properties => {
1715 node => get_standard_option('pve-node'),
1716 vmid => get_standard_option('pve-vmid'),
1717 skiplock => get_standard_option('skiplock'),
1718 key => {
1719 description => "The key (qemu monitor encoding).",
1720 type => 'string'
1721 }
1722 },
1723 },
1724 returns => { type => 'null'},
1725 code => sub {
1726 my ($param) = @_;
1727
1728 my $rpcenv = PVE::RPCEnvironment::get();
1729
a0d1b1a2 1730 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1731
1732 my $node = extract_param($param, 'node');
1733
1734 my $vmid = extract_param($param, 'vmid');
1735
1736 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1737 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1738 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0
DM		 1739
1740 PVE::QemuServer::vm_sendkey($vmid, $skiplock, $param->{key});
1741
1742 return;
1e3baf05
DM		 1743 }});
1744
1ac0d2ee
AD		 1745__PACKAGE__->register_method({
1746 name => 'vm_feature',
1747 path => '{vmid}/feature',
1748 method => 'GET',
1749 proxyto => 'node',
75466c4f 1750 protected => 1,
1ac0d2ee
AD		 1751 description => "Check if feature for virtual machine is available.",
1752 permissions => {
1753 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1754 },
1755 parameters => {
1756 additionalProperties => 0,
1757 properties => {
1758 node => get_standard_option('pve-node'),
1759 vmid => get_standard_option('pve-vmid'),
1760 feature => {
1761 description => "Feature to check.",
1762 type => 'string',
7758ce86 1763 enum => [ 'snapshot', 'clone', 'copy' ],
1ac0d2ee
AD		 1764 },
1765 snapname => get_standard_option('pve-snapshot-name', {
1766 optional => 1,
1767 }),
1768 },
1ac0d2ee
AD		 1769 },
1770 returns => {
719893a9
DM		 1771 type => "object",
1772 properties => {
1773 hasFeature => { type => 'boolean' },
1774 nodes => {
1775 type => 'array',
1776 items => { type => 'string' },
1777 }
1778 },
1ac0d2ee
AD		 1779 },
1780 code => sub {
1781 my ($param) = @_;
1782
1783 my $node = extract_param($param, 'node');
1784
1785 my $vmid = extract_param($param, 'vmid');
1786
1787 my $snapname = extract_param($param, 'snapname');
1788
1789 my $feature = extract_param($param, 'feature');
1790
1791 my $running = PVE::QemuServer::check_running($vmid);
1792
1793 my $conf = PVE::QemuServer::load_config($vmid);
1794
1795 if($snapname){
1796 my $snap = $conf->{snapshots}->{$snapname};
1797 die "snapshot '$snapname' does not exist\n" if !defined($snap);
1798 $conf = $snap;
1799 }
1800 my $storecfg = PVE::Storage::config();
1801
719893a9
DM		 1802 my $nodelist = PVE::QemuServer::shared_nodes($conf, $storecfg);
1803 my $hasFeature = PVE::QemuServer::has_feature($feature, $conf, $storecfg, $snapname, $running);
1804
1805 return {
1806 hasFeature => $hasFeature,
1807 nodes => [ keys %$nodelist ],
1808 };
1ac0d2ee
AD		 1809 }});
1810
6116f729 1811__PACKAGE__->register_method({
9418baad
DM		 1812 name => 'clone_vm',
1813 path => '{vmid}/clone',
6116f729
DM		 1814 method => 'POST',
1815 protected => 1,
1816 proxyto => 'node',
37329185 1817 description => "Create a copy of virtual machine/template.",
6116f729 1818 permissions => {
9418baad 1819 description => "You need 'VM.Clone' permissions on /vms/{vmid}, and 'VM.Allocate' permissions " .
6116f729
DM		 1820 "on /vms/{newid} (or on the VM pool /pool/{pool}). You also need " .
1821 "'Datastore.AllocateSpace' on any used storage.",
75466c4f
DM		 1822 check =>
1823 [ 'and',
9418baad 1824 ['perm', '/vms/{vmid}', [ 'VM.Clone' ]],
75466c4f 1825 [ 'or',
6116f729
DM		 1826 [ 'perm', '/vms/{newid}', ['VM.Allocate']],
1827 [ 'perm', '/pool/{pool}', ['VM.Allocate'], require_param => 'pool'],
1828 ],
1829 ]
1830 },
1831 parameters => {
1832 additionalProperties => 0,
1833 properties => {
6116f729
DM		 1834 node => get_standard_option('pve-node'),
1835 vmid => get_standard_option('pve-vmid'),
9418baad 1836 newid => get_standard_option('pve-vmid', { description => 'VMID for the clone.' }),
a60ab1a6
DM		 1837 name => {
1838 optional => 1,
1839 type => 'string', format => 'dns-name',
1840 description => "Set a name for the new VM.",
1841 },
1842 description => {
1843 optional => 1,
1844 type => 'string',
1845 description => "Description for the new VM.",
1846 },
75466c4f 1847 pool => {
6116f729
DM		 1848 optional => 1,
1849 type => 'string', format => 'pve-poolid',
1850 description => "Add the new VM to the specified pool.",
1851 },
9076d880
DM		 1852 snapname => get_standard_option('pve-snapshot-name', {
1853 requires => 'full',
1854 optional => 1,
1855 }),
81f043eb 1856 storage => get_standard_option('pve-storage-id', {
9418baad 1857 description => "Target storage for full clone.",
4e4f83fe 1858 requires => 'full',
81f043eb
AD		 1859 optional => 1,
1860 }),
55173c6b 1861 'format' => {
42a19c87
AD		 1862 description => "Target format for file storage.",
1863 requires => 'full',
1864 type => 'string',
1865 optional => 1,
55173c6b 1866 enum => [ 'raw', 'qcow2', 'vmdk'],
42a19c87 1867 },
6116f729
DM		 1868 full => {
1869 optional => 1,
55173c6b
DM		 1870 type => 'boolean',
1871 description => "Create a full copy of all disk. This is always done when " .
9418baad 1872 "you clone a normal VM. For VM templates, we try to create a linked clone by default.",
6116f729
DM		 1873 default => 0,
1874 },
75466c4f 1875 target => get_standard_option('pve-node', {
55173c6b
DM		 1876 description => "Target node. Only allowed if the original VM is on shared storage.",
1877 optional => 1,
1878 }),
1879 },
6116f729
DM		 1880 },
1881 returns => {
1882 type => 'string',
1883 },
1884 code => sub {
1885 my ($param) = @_;
1886
1887 my $rpcenv = PVE::RPCEnvironment::get();
1888
55173c6b 1889 my $authuser = $rpcenv->get_user();
6116f729
DM		 1890
1891 my $node = extract_param($param, 'node');
1892
1893 my $vmid = extract_param($param, 'vmid');
1894
1895 my $newid = extract_param($param, 'newid');
1896
6116f729
DM		 1897 my $pool = extract_param($param, 'pool');
1898
1899 if (defined($pool)) {
1900 $rpcenv->check_pool_exist($pool);
1901 }
1902
55173c6b 1903 my $snapname = extract_param($param, 'snapname');
9076d880 1904
81f043eb
AD		 1905 my $storage = extract_param($param, 'storage');
1906
42a19c87
AD		 1907 my $format = extract_param($param, 'format');
1908
55173c6b
DM		 1909 my $target = extract_param($param, 'target');
1910
1911 my $localnode = PVE::INotify::nodename();
1912
751cc556 1913 undef $target if $target && ($target eq $localnode || $target eq 'localhost');
55173c6b
DM		 1914
1915 PVE::Cluster::check_node_exists($target) if $target;
1916
6116f729
DM		 1917 my $storecfg = PVE::Storage::config();
1918
4a5a2590
DM		 1919 if ($storage) {
1920 # check if storage is enabled on local node
1921 PVE::Storage::storage_check_enabled($storecfg, $storage);
1922 if ($target) {
1923 # check if storage is available on target node
1924 PVE::Storage::storage_check_node($storecfg, $storage, $target);
1925 # clone only works if target storage is shared
1926 my $scfg = PVE::Storage::storage_config($storecfg, $storage);
1927 die "can't clone to non-shared storage '$storage'\n" if !$scfg->{shared};
1928 }
1929 }
1930
55173c6b 1931 PVE::Cluster::check_cfs_quorum();
6116f729 1932
4e4f83fe
DM		 1933 my $running = PVE::QemuServer::check_running($vmid) || 0;
1934
4e4f83fe
DM		 1935 # exclusive lock if VM is running - else shared lock is enough;
1936 my $shared_lock = $running ? 0 : 1;
1937
9418baad 1938 my $clonefn = sub {
6116f729 1939
829967a9
DM		 1940 # do all tests after lock
1941 # we also try to do all tests before we fork the worker
1942
6116f729
DM		 1943 my $conf = PVE::QemuServer::load_config($vmid);
1944
1945 PVE::QemuServer::check_lock($conf);
1946
4e4f83fe 1947 my $verify_running = PVE::QemuServer::check_running($vmid) || 0;
6116f729 1948
4e4f83fe 1949 die "unexpected state change\n" if $verify_running != $running;
6116f729 1950
75466c4f
DM		 1951 die "snapshot '$snapname' does not exist\n"
1952 if $snapname && !defined( $conf->{snapshots}->{$snapname});
6116f729 1953
75466c4f 1954 my $oldconf = $snapname ? $conf->{snapshots}->{$snapname} : $conf;
9076d880 1955
9418baad 1956 my $sharedvm = &$check_storage_access_clone($rpcenv, $authuser, $storecfg, $oldconf, $storage);
6116f729 1957
9418baad 1958 die "can't clone VM to node '$target' (VM uses local storage)\n" if $target && !$sharedvm;
75466c4f 1959
6116f729
DM		 1960 my $conffile = PVE::QemuServer::config_file($newid);
1961
1962 die "unable to create VM $newid: config file already exists\n"
1963 if -f $conffile;
1964
9418baad 1965 my $newconf = { lock => 'clone' };
829967a9
DM		 1966 my $drives = {};
1967 my $vollist = [];
1968
1969 foreach my $opt (keys %$oldconf) {
1970 my $value = $oldconf->{$opt};
1971
1972 # do not copy snapshot related info
1973 next if $opt eq 'snapshots' || $opt eq 'parent' || $opt eq 'snaptime' ||
1974 $opt eq 'vmstate' || $opt eq 'snapstate';
1975
1976 # always change MAC! address
1977 if ($opt =~ m/^net(\d+)$/) {
1978 my $net = PVE::QemuServer::parse_net($value);
1979 $net->{macaddr} = PVE::Tools::random_ether_addr();
1980 $newconf->{$opt} = PVE::QemuServer::print_net($net);
1981 } elsif (my $drive = PVE::QemuServer::parse_drive($opt, $value)) {
1982 if (PVE::QemuServer::drive_is_cdrom($drive)) {
1983 $newconf->{$opt} = $value; # simply copy configuration
1984 } else {
dba198b0 1985 if ($param->{full} || !PVE::Storage::volume_is_base($storecfg, $drive->{file})) {
2dd53043 1986 die "Full clone feature is not available"
dba198b0 1987 if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running);
2dd53043 1988 $drive->{full} = 1;
dba198b0 1989 }
829967a9
DM		 1990 $drives->{$opt} = $drive;
1991 push @$vollist, $drive->{file};
1992 }
1993 } else {
1994 # copy everything else
1995 $newconf->{$opt} = $value;
1996 }
1997 }
1998
1999 delete $newconf->{template};
2000
2001 if ($param->{name}) {
2002 $newconf->{name} = $param->{name};
2003 } else {
c55fee03
DM		 2004 if ($oldconf->{name}) {
2005 $newconf->{name} = "Copy-of-$oldconf->{name}";
2006 } else {
2007 $newconf->{name} = "Copy-of-VM-$vmid";
2008 }
829967a9 2009 }
2dd53043 2010
829967a9
DM		 2011 if ($param->{description}) {
2012 $newconf->{description} = $param->{description};
2013 }
2014
6116f729 2015 # create empty/temp config - this fails if VM already exists on other node
9418baad 2016 PVE::Tools::file_set_contents($conffile, "# qmclone temporary file\nlock: clone\n");
6116f729
DM		 2017
2018 my $realcmd = sub {
2019 my $upid = shift;
2020
b83e0181 2021 my $newvollist = [];
6116f729 2022
b83e0181 2023 eval {
829967a9 2024 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
75466c4f 2025
6116f729
DM		 2026 PVE::Storage::activate_volumes($storecfg, $vollist);
2027
829967a9
DM		 2028 foreach my $opt (keys %$drives) {
2029 my $drive = $drives->{$opt};
2dd53043 2030
152fe752
DM		 2031 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
2032 $newid, $storage, $format, $drive->{full}, $newvollist);
00b095ca 2033
152fe752 2034 $newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive);
2dd53043 2035
829967a9
DM		 2036 PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
2037 }
b83e0181
DM		 2038
2039 delete $newconf->{lock};
2040 PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
55173c6b
DM		 2041
2042 if ($target) {
2043 my $newconffile = PVE::QemuServer::config_file($newid, $target);
2044 die "Failed to move config to node '$target' - rename failed: $!\n"
2045 if !rename($conffile, $newconffile);
2046 }
d703d4c0 2047
be517049 2048 PVE::AccessControl::add_vm_to_pool($newid, $pool) if $pool;
6116f729 2049 };
75466c4f 2050 if (my $err = $@) {
6116f729
DM		 2051 unlink $conffile;
2052
b83e0181
DM		 2053 sleep 1; # some storage like rbd need to wait before release volume - really?
2054
2055 foreach my $volid (@$newvollist) {
2056 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2057 warn $@ if $@;
2058 }
9418baad 2059 die "clone failed: $err";
6116f729
DM		 2060 }
2061
2062 return;
2063 };
2064
9418baad 2065 return $rpcenv->fork_worker('qmclone', $vmid, $authuser, $realcmd);
6116f729
DM		 2066 };
2067
4e4f83fe 2068 return PVE::QemuServer::lock_config_mode($vmid, 1, $shared_lock, sub {
6116f729 2069 # Aquire exclusive lock lock for $newid
9418baad 2070 return PVE::QemuServer::lock_config_full($newid, 1, $clonefn);
6116f729
DM		 2071 });
2072
2073 }});
2074
586bfa78 2075__PACKAGE__->register_method({
43bc02a9
DM		 2076 name => 'move_vm_disk',
2077 path => '{vmid}/move_disk',
e2cd75fa 2078 method => 'POST',
586bfa78
AD		 2079 protected => 1,
2080 proxyto => 'node',
2081 description => "Move volume to different storage.",
2082 permissions => {
e2cd75fa
DM		 2083 description => "You need 'VM.Config.Disk' permissions on /vms/{vmid}, " .
2084 "and 'Datastore.AllocateSpace' permissions on the storage.",
2085 check =>
2086 [ 'and',
2087 ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
2088 ['perm', '/storage/{storage}', [ 'Datastore.AllocateSpace' ]],
2089 ],
586bfa78
AD		 2090 },
2091 parameters => {
2092 additionalProperties => 0,
2093 properties => {
2094 node => get_standard_option('pve-node'),
2095 vmid => get_standard_option('pve-vmid'),
586bfa78
AD		 2096 disk => {
2097 type => 'string',
2098 description => "The disk you want to move.",
e2cd75fa 2099 enum => [ PVE::QemuServer::disknames() ],
586bfa78 2100 },
e2cd75fa 2101 storage => get_standard_option('pve-storage-id', { description => "Target Storage." }),
635c3c44 2102 'format' => {
586bfa78
AD		 2103 type => 'string',
2104 description => "Target Format.",
2105 enum => [ 'raw', 'qcow2', 'vmdk' ],
2106 optional => 1,
2107 },
70d45e33
DM		 2108 delete => {
2109 type => 'boolean',
2110 description => "Delete the original disk after successful copy. By default the original disk is kept as unused disk.",
2111 optional => 1,
2112 default => 0,
2113 },
586bfa78
AD		 2114 digest => {
2115 type => 'string',
2116 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2117 maxLength => 40,
2118 optional => 1,
2119 },
2120 },
2121 },
e2cd75fa
DM		 2122 returns => {
2123 type => 'string',
2124 description => "the task ID.",
2125 },
586bfa78
AD		 2126 code => sub {
2127 my ($param) = @_;
2128
2129 my $rpcenv = PVE::RPCEnvironment::get();
2130
2131 my $authuser = $rpcenv->get_user();
2132
2133 my $node = extract_param($param, 'node');
2134
2135 my $vmid = extract_param($param, 'vmid');
2136
2137 my $digest = extract_param($param, 'digest');
2138
2139 my $disk = extract_param($param, 'disk');
2140
2141 my $storeid = extract_param($param, 'storage');
2142
2143 my $format = extract_param($param, 'format');
2144
586bfa78
AD		 2145 my $storecfg = PVE::Storage::config();
2146
2147 my $updatefn = sub {
2148
2149 my $conf = PVE::QemuServer::load_config($vmid);
2150
2151 die "checksum missmatch (file change by other user?)\n"
2152 if $digest && $digest ne $conf->{digest};
586bfa78
AD		 2153
2154 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2155
2156 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2157
70d45e33 2158 my $old_volid = $drive->{file} || die "disk '$disk' has no associated volume\n";
586bfa78
AD		 2159
2160 die "you can't move a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2161
e2cd75fa 2162 my $oldfmt;
70d45e33 2163 my ($oldstoreid, $oldvolname) = PVE::Storage::parse_volume_id($old_volid);
586bfa78
AD		 2164 if ($oldvolname =~ m/\.(raw|qcow2|vmdk)$/){
2165 $oldfmt = $1;
2166 }
2167
e2cd75fa
DM		 2168 die "you can't move on the same storage with same format\n" if $oldstoreid eq $storeid &&
2169 (!$format || !$oldfmt || $oldfmt eq $format);
586bfa78
AD		 2170
2171 PVE::Cluster::log_msg('info', $authuser, "move disk VM $vmid: move --disk $disk --storage $storeid");
2172
2173 my $running = PVE::QemuServer::check_running($vmid);
e2cd75fa
DM		 2174
2175 PVE::Storage::activate_volumes($storecfg, [ $drive->{file} ]);
2176
586bfa78
AD		 2177 my $realcmd = sub {
2178
2179 my $newvollist = [];
2180
2181 eval {
2182 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
2183
e2cd75fa
DM		 2184 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $disk, $drive, undef,
2185 $vmid, $storeid, $format, 1, $newvollist);
2186
2187 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $newdrive);
2188
70d45e33
DM		 2189 PVE::QemuServer::add_unused_volume($conf, $old_volid) if !$param->{delete};
2190
e2cd75fa 2191 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
586bfa78
AD		 2192 };
2193 if (my $err = $@) {
2194
2195 foreach my $volid (@$newvollist) {
2196 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2197 warn $@ if $@;
2198 }
2199 die "storage migration failed: $err";
2200 }
70d45e33
DM		 2201
2202 if ($param->{delete}) {
2203 eval { PVE::Storage::vdisk_free($storecfg, $old_volid); };
2204 warn $@ if $@;
2205 }
586bfa78
AD		 2206 };
2207
2208 return $rpcenv->fork_worker('qmmove', $vmid, $authuser, $realcmd);
2209 };
e2cd75fa
DM		 2210
2211 return PVE::QemuServer::lock_config($vmid, $updatefn);
586bfa78
AD		 2212 }});
2213
3ea94c60 2214__PACKAGE__->register_method({
afdb31d5 2215 name => 'migrate_vm',
3ea94c60
DM		 2216 path => '{vmid}/migrate',
2217 method => 'POST',
2218 protected => 1,
2219 proxyto => 'node',
2220 description => "Migrate virtual machine. Creates a new migration task.",
a0d1b1a2
DM		 2221 permissions => {
2222 check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]],
2223 },
3ea94c60
DM		 2224 parameters => {
2225 additionalProperties => 0,
2226 properties => {
2227 node => get_standard_option('pve-node'),
2228 vmid => get_standard_option('pve-vmid'),
2229 target => get_standard_option('pve-node', { description => "Target node." }),
2230 online => {
2231 type => 'boolean',
2232 description => "Use online/live migration.",
2233 optional => 1,
2234 },
2235 force => {
2236 type => 'boolean',
2237 description => "Allow to migrate VMs which use local devices. Only root may use this option.",
2238 optional => 1,
2239 },
2240 },
2241 },
afdb31d5 2242 returns => {
3ea94c60
DM		 2243 type => 'string',
2244 description => "the task ID.",
2245 },
2246 code => sub {
2247 my ($param) = @_;
2248
2249 my $rpcenv = PVE::RPCEnvironment::get();
2250
a0d1b1a2 2251 my $authuser = $rpcenv->get_user();
3ea94c60
DM		 2252
2253 my $target = extract_param($param, 'target');
2254
2255 my $localnode = PVE::INotify::nodename();
2256 raise_param_exc({ target => "target is local node."}) if $target eq $localnode;
2257
2258 PVE::Cluster::check_cfs_quorum();
2259
2260 PVE::Cluster::check_node_exists($target);
2261
2262 my $targetip = PVE::Cluster::remote_node_ip($target);
2263
2264 my $vmid = extract_param($param, 'vmid');
2265
afdb31d5 2266 raise_param_exc({ force => "Only root may use this option." })
a0d1b1a2 2267 if $param->{force} && $authuser ne 'root@pam';
3ea94c60
DM		 2268
2269 # test if VM exists
a5ed42d3 2270 my $conf = PVE::QemuServer::load_config($vmid);
3ea94c60
DM		 2271
2272 # try to detect errors early
a5ed42d3
DM		 2273
2274 PVE::QemuServer::check_lock($conf);
2275
3ea94c60 2276 if (PVE::QemuServer::check_running($vmid)) {
afdb31d5 2277 die "cant migrate running VM without --online\n"
3ea94c60
DM		 2278 if !$param->{online};
2279 }
2280
47152e2e 2281 my $storecfg = PVE::Storage::config();
22d646a7 2282 PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
47152e2e 2283
3be30d63 2284 if (&$vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
3ea94c60 2285
88fc87b4
DM		 2286 my $hacmd = sub {
2287 my $upid = shift;
3ea94c60 2288
88fc87b4
DM		 2289 my $service = "pvevm:$vmid";
2290
2291 my $cmd = ['clusvcadm', '-M', $service, '-m', $target];
2292
2293 print "Executing HA migrate for VM $vmid to node $target\n";
2294
2295 PVE::Tools::run_command($cmd);
2296
2297 return;
2298 };
2299
2300 return $rpcenv->fork_worker('hamigrate', $vmid, $authuser, $hacmd);
2301
2302 } else {
2303
2304 my $realcmd = sub {
2305 my $upid = shift;
2306
2307 PVE::QemuMigrate->migrate($target, $targetip, $vmid, $param);
2308 };
2309
2310 return $rpcenv->fork_worker('qmigrate', $vmid, $authuser, $realcmd);
2311 }
3ea94c60 2312
3ea94c60 2313 }});
1e3baf05 2314
91c94f0a 2315__PACKAGE__->register_method({
afdb31d5
DM		 2316 name => 'monitor',
2317 path => '{vmid}/monitor',
91c94f0a
DM		 2318 method => 'POST',
2319 protected => 1,
2320 proxyto => 'node',
2321 description => "Execute Qemu monitor commands.",
a0d1b1a2
DM		 2322 permissions => {
2323 check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
2324 },
91c94f0a
DM		 2325 parameters => {
2326 additionalProperties => 0,
2327 properties => {
2328 node => get_standard_option('pve-node'),
2329 vmid => get_standard_option('pve-vmid'),
2330 command => {
2331 type => 'string',
2332 description => "The monitor command.",
2333 }
2334 },
2335 },
2336 returns => { type => 'string'},
2337 code => sub {
2338 my ($param) = @_;
2339
2340 my $vmid = $param->{vmid};
2341
2342 my $conf = PVE::QemuServer::load_config ($vmid); # check if VM exists
2343
2344 my $res = '';
2345 eval {
7b7c6d1b 2346 $res = PVE::QemuServer::vm_human_monitor_command($vmid, $param->{command});
91c94f0a
DM		 2347 };
2348 $res = "ERROR: $@" if $@;
2349
2350 return $res;
2351 }});
2352
0d02881c
AD		 2353__PACKAGE__->register_method({
2354 name => 'resize_vm',
614e3941 2355 path => '{vmid}/resize',
0d02881c
AD		 2356 method => 'PUT',
2357 protected => 1,
2358 proxyto => 'node',
2f48a4f5 2359 description => "Extend volume size.",
0d02881c 2360 permissions => {
3b2773f6 2361 check => ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
0d02881c
AD		 2362 },
2363 parameters => {
2364 additionalProperties => 0,
2f48a4f5
DM		 2365 properties => {
2366 node => get_standard_option('pve-node'),
2367 vmid => get_standard_option('pve-vmid'),
2368 skiplock => get_standard_option('skiplock'),
2369 disk => {
2370 type => 'string',
2371 description => "The disk you want to resize.",
2372 enum => [PVE::QemuServer::disknames()],
2373 },
2374 size => {
2375 type => 'string',
f91b2e45 2376 pattern => '\+?\d+(\.\d+)?[KMGT]?',
2f48a4f5
DM		 2377 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.",
2378 },
2379 digest => {
2380 type => 'string',
2381 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2382 maxLength => 40,
2383 optional => 1,
2384 },
2385 },
0d02881c
AD		 2386 },
2387 returns => { type => 'null'},
2388 code => sub {
2389 my ($param) = @_;
2390
2391 my $rpcenv = PVE::RPCEnvironment::get();
2392
2393 my $authuser = $rpcenv->get_user();
2394
2395 my $node = extract_param($param, 'node');
2396
2397 my $vmid = extract_param($param, 'vmid');
2398
2399 my $digest = extract_param($param, 'digest');
2400
2f48a4f5 2401 my $disk = extract_param($param, 'disk');
75466c4f 2402
2f48a4f5 2403 my $sizestr = extract_param($param, 'size');
0d02881c 2404
f91b2e45 2405 my $skiplock = extract_param($param, 'skiplock');
0d02881c
AD		 2406 raise_param_exc({ skiplock => "Only root may use this option." })
2407 if $skiplock && $authuser ne 'root@pam';
2408
0d02881c
AD		 2409 my $storecfg = PVE::Storage::config();
2410
0d02881c
AD		 2411 my $updatefn = sub {
2412
2413 my $conf = PVE::QemuServer::load_config($vmid);
2414
2415 die "checksum missmatch (file change by other user?)\n"
2416 if $digest && $digest ne $conf->{digest};
2417 PVE::QemuServer::check_lock($conf) if !$skiplock;
2418
f91b2e45
DM		 2419 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2420
2421 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2422
2423 my $volid = $drive->{file};
2424
2425 die "disk '$disk' has no associated volume\n" if !$volid;
2426
2427 die "you can't resize a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2428
75466c4f 2429 die "you can't online resize a virtio windows bootdisk\n"
f2965e67
AD		 2430 if PVE::QemuServer::check_running($vmid) && $conf->{bootdisk} eq $disk && $conf->{ostype} =~ m/^w/ && $disk =~ m/^virtio/;
2431
f91b2e45
DM		 2432 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
2433
2434 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
2435
2436 my $size = PVE::Storage::volume_size_info($storecfg, $volid, 5);
2437
2438 die "internal error" if $sizestr !~ m/^(\+)?(\d+(\.\d+)?)([KMGT])?$/;
2439 my ($ext, $newsize, $unit) = ($1, $2, $4);
2440 if ($unit) {
2441 if ($unit eq 'K') {
2442 $newsize = $newsize * 1024;
2443 } elsif ($unit eq 'M') {
2444 $newsize = $newsize * 1024 * 1024;
2445 } elsif ($unit eq 'G') {
2446 $newsize = $newsize * 1024 * 1024 * 1024;
2447 } elsif ($unit eq 'T') {
2448 $newsize = $newsize * 1024 * 1024 * 1024 * 1024;
2449 }
2450 }
2451 $newsize += $size if $ext;
2452 $newsize = int($newsize);
2453
2454 die "unable to skrink disk size\n" if $newsize < $size;
2455
2456 return if $size == $newsize;
2457
2f48a4f5 2458 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: resize --disk $disk --size $sizestr");
0d02881c 2459
f91b2e45 2460 PVE::QemuServer::qemu_block_resize($vmid, "drive-$disk", $storecfg, $volid, $newsize);
75466c4f 2461
f91b2e45
DM		 2462 $drive->{size} = $newsize;
2463 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $drive);
2464
2465 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
2466 };
0d02881c
AD		 2467
2468 PVE::QemuServer::lock_config($vmid, $updatefn);
2469 return undef;
2470 }});
2471
9dbd1ee4 2472__PACKAGE__->register_method({
7e7d7b61 2473 name => 'snapshot_list',
9dbd1ee4 2474 path => '{vmid}/snapshot',
7e7d7b61
DM		 2475 method => 'GET',
2476 description => "List all snapshots.",
2477 permissions => {
2478 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
2479 },
2480 proxyto => 'node',
2481 protected => 1, # qemu pid files are only readable by root
2482 parameters => {
2483 additionalProperties => 0,
2484 properties => {
2485 vmid => get_standard_option('pve-vmid'),
2486 node => get_standard_option('pve-node'),
2487 },
2488 },
2489 returns => {
2490 type => 'array',
2491 items => {
2492 type => "object",
2493 properties => {},
2494 },
2495 links => [ { rel => 'child', href => "{name}" } ],
2496 },
2497 code => sub {
2498 my ($param) = @_;
2499
6aa4651b
DM		 2500 my $vmid = $param->{vmid};
2501
2502 my $conf = PVE::QemuServer::load_config($vmid);
7e7d7b61
DM		 2503 my $snaphash = $conf->{snapshots} || {};
2504
2505 my $res = [];
2506
2507 foreach my $name (keys %$snaphash) {
0ea6bc69 2508 my $d = $snaphash->{$name};
75466c4f
DM		 2509 my $item = {
2510 name => $name,
2511 snaptime => $d->{snaptime} || 0,
6aa4651b 2512 vmstate => $d->{vmstate} ? 1 : 0,
982c7f12
DM		 2513 description => $d->{description} || '',
2514 };
0ea6bc69 2515 $item->{parent} = $d->{parent} if $d->{parent};
3ee28e38 2516 $item->{snapstate} = $d->{snapstate} if $d->{snapstate};
0ea6bc69
DM		 2517 push @$res, $item;
2518 }
2519
6aa4651b
DM		 2520 my $running = PVE::QemuServer::check_running($vmid, 1) ? 1 : 0;
2521 my $current = { name => 'current', digest => $conf->{digest}, running => $running };
d1914468
DM		 2522 $current->{parent} = $conf->{parent} if $conf->{parent};
2523
2524 push @$res, $current;
7e7d7b61
DM		 2525
2526 return $res;
2527 }});
2528
2529__PACKAGE__->register_method({
2530 name => 'snapshot',
2531 path => '{vmid}/snapshot',
2532 method => 'POST',
9dbd1ee4
AD		 2533 protected => 1,
2534 proxyto => 'node',
2535 description => "Snapshot a VM.",
2536 permissions => {
f1baf1df 2537 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
9dbd1ee4
AD		 2538 },
2539 parameters => {
2540 additionalProperties => 0,
2541 properties => {
2542 node => get_standard_option('pve-node'),
2543 vmid => get_standard_option('pve-vmid'),
8abd398b 2544 snapname => get_standard_option('pve-snapshot-name'),
9dbd1ee4
AD		 2545 vmstate => {
2546 optional => 1,
2547 type => 'boolean',
2548 description => "Save the vmstate",
2549 },
2550 freezefs => {
2551 optional => 1,
2552 type => 'boolean',
2553 description => "Freeze the filesystem",
2554 },
782f4f75
DM		 2555 description => {
2556 optional => 1,
2557 type => 'string',
2558 description => "A textual description or comment.",
2559 },
9dbd1ee4
AD		 2560 },
2561 },
7e7d7b61
DM		 2562 returns => {
2563 type => 'string',
2564 description => "the task ID.",
2565 },
9dbd1ee4
AD		 2566 code => sub {
2567 my ($param) = @_;
2568
2569 my $rpcenv = PVE::RPCEnvironment::get();
2570
2571 my $authuser = $rpcenv->get_user();
2572
2573 my $node = extract_param($param, 'node');
2574
2575 my $vmid = extract_param($param, 'vmid');
2576
9dbd1ee4
AD		 2577 my $snapname = extract_param($param, 'snapname');
2578
d1914468
DM		 2579 die "unable to use snapshot name 'current' (reserved name)\n"
2580 if $snapname eq 'current';
2581
7e7d7b61 2582 my $realcmd = sub {
22c377f0 2583 PVE::Cluster::log_msg('info', $authuser, "snapshot VM $vmid: $snapname");
75466c4f 2584 PVE::QemuServer::snapshot_create($vmid, $snapname, $param->{vmstate},
782f4f75 2585 $param->{freezefs}, $param->{description});
7e7d7b61
DM		 2586 };
2587
2588 return $rpcenv->fork_worker('qmsnapshot', $vmid, $authuser, $realcmd);
2589 }});
2590
154ccdcd
DM		 2591__PACKAGE__->register_method({
2592 name => 'snapshot_cmd_idx',
2593 path => '{vmid}/snapshot/{snapname}',
2594 description => '',
2595 method => 'GET',
2596 permissions => {
2597 user => 'all',
2598 },
2599 parameters => {
2600 additionalProperties => 0,
2601 properties => {
2602 vmid => get_standard_option('pve-vmid'),
2603 node => get_standard_option('pve-node'),
8abd398b 2604 snapname => get_standard_option('pve-snapshot-name'),
154ccdcd
DM		 2605 },
2606 },
2607 returns => {
2608 type => 'array',
2609 items => {
2610 type => "object",
2611 properties => {},
2612 },
2613 links => [ { rel => 'child', href => "{cmd}" } ],
2614 },
2615 code => sub {
2616 my ($param) = @_;
2617
2618 my $res = [];
2619
2620 push @$res, { cmd => 'rollback' };
d788cea6 2621 push @$res, { cmd => 'config' };
154ccdcd
DM		 2622
2623 return $res;
2624 }});
2625
d788cea6
DM		 2626__PACKAGE__->register_method({
2627 name => 'update_snapshot_config',
2628 path => '{vmid}/snapshot/{snapname}/config',
2629 method => 'PUT',
2630 protected => 1,
2631 proxyto => 'node',
2632 description => "Update snapshot metadata.",
2633 permissions => {
2634 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
2635 },
2636 parameters => {
2637 additionalProperties => 0,
2638 properties => {
2639 node => get_standard_option('pve-node'),
2640 vmid => get_standard_option('pve-vmid'),
2641 snapname => get_standard_option('pve-snapshot-name'),
2642 description => {
2643 optional => 1,
2644 type => 'string',
2645 description => "A textual description or comment.",
2646 },
2647 },
2648 },
2649 returns => { type => 'null' },
2650 code => sub {
2651 my ($param) = @_;
2652
2653 my $rpcenv = PVE::RPCEnvironment::get();
2654
2655 my $authuser = $rpcenv->get_user();
2656
2657 my $vmid = extract_param($param, 'vmid');
2658
2659 my $snapname = extract_param($param, 'snapname');
2660
2661 return undef if !defined($param->{description});
2662
2663 my $updatefn = sub {
2664
2665 my $conf = PVE::QemuServer::load_config($vmid);
2666
2667 PVE::QemuServer::check_lock($conf);
2668
2669 my $snap = $conf->{snapshots}->{$snapname};
2670
75466c4f
DM		 2671 die "snapshot '$snapname' does not exist\n" if !defined($snap);
2672
d788cea6
DM		 2673 $snap->{description} = $param->{description} if defined($param->{description});
2674
2675 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
2676 };
2677
2678 PVE::QemuServer::lock_config($vmid, $updatefn);
2679
2680 return undef;
2681 }});
2682
2683__PACKAGE__->register_method({
2684 name => 'get_snapshot_config',
2685 path => '{vmid}/snapshot/{snapname}/config',
2686 method => 'GET',
2687 proxyto => 'node',
2688 description => "Get snapshot configuration",
2689 permissions => {
2690 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
2691 },
2692 parameters => {
2693 additionalProperties => 0,
2694 properties => {
2695 node => get_standard_option('pve-node'),
2696 vmid => get_standard_option('pve-vmid'),
2697 snapname => get_standard_option('pve-snapshot-name'),
2698 },
2699 },
2700 returns => { type => "object" },
2701 code => sub {
2702 my ($param) = @_;
2703
2704 my $rpcenv = PVE::RPCEnvironment::get();
2705
2706 my $authuser = $rpcenv->get_user();
2707
2708 my $vmid = extract_param($param, 'vmid');
2709
2710 my $snapname = extract_param($param, 'snapname');
2711
2712 my $conf = PVE::QemuServer::load_config($vmid);
2713
2714 my $snap = $conf->{snapshots}->{$snapname};
2715
75466c4f
DM		 2716 die "snapshot '$snapname' does not exist\n" if !defined($snap);
2717
d788cea6
DM		 2718 return $snap;
2719 }});
2720
7e7d7b61
DM		 2721__PACKAGE__->register_method({
2722 name => 'rollback',
154ccdcd 2723 path => '{vmid}/snapshot/{snapname}/rollback',
7e7d7b61
DM		 2724 method => 'POST',
2725 protected => 1,
2726 proxyto => 'node',
2727 description => "Rollback VM state to specified snapshot.",
2728 permissions => {
f1baf1df 2729 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 2730 },
2731 parameters => {
2732 additionalProperties => 0,
2733 properties => {
2734 node => get_standard_option('pve-node'),
2735 vmid => get_standard_option('pve-vmid'),
8abd398b 2736 snapname => get_standard_option('pve-snapshot-name'),
7e7d7b61
DM		 2737 },
2738 },
2739 returns => {
2740 type => 'string',
2741 description => "the task ID.",
2742 },
2743 code => sub {
2744 my ($param) = @_;
2745
2746 my $rpcenv = PVE::RPCEnvironment::get();
2747
2748 my $authuser = $rpcenv->get_user();
2749
2750 my $node = extract_param($param, 'node');
2751
2752 my $vmid = extract_param($param, 'vmid');
2753
2754 my $snapname = extract_param($param, 'snapname');
2755
7e7d7b61 2756 my $realcmd = sub {
22c377f0
DM		 2757 PVE::Cluster::log_msg('info', $authuser, "rollback snapshot VM $vmid: $snapname");
2758 PVE::QemuServer::snapshot_rollback($vmid, $snapname);
7e7d7b61
DM		 2759 };
2760
2761 return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $realcmd);
2762 }});
2763
2764__PACKAGE__->register_method({
2765 name => 'delsnapshot',
2766 path => '{vmid}/snapshot/{snapname}',
2767 method => 'DELETE',
2768 protected => 1,
2769 proxyto => 'node',
2770 description => "Delete a VM snapshot.",
2771 permissions => {
f1baf1df 2772 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 2773 },
2774 parameters => {
2775 additionalProperties => 0,
2776 properties => {
2777 node => get_standard_option('pve-node'),
2778 vmid => get_standard_option('pve-vmid'),
8abd398b 2779 snapname => get_standard_option('pve-snapshot-name'),
3ee28e38
DM		 2780 force => {
2781 optional => 1,
2782 type => 'boolean',
2783 description => "For removal from config file, even if removing disk snapshots fails.",
2784 },
7e7d7b61
DM		 2785 },
2786 },
2787 returns => {
2788 type => 'string',
2789 description => "the task ID.",
2790 },
2791 code => sub {
2792 my ($param) = @_;
2793
2794 my $rpcenv = PVE::RPCEnvironment::get();
2795
2796 my $authuser = $rpcenv->get_user();
2797
2798 my $node = extract_param($param, 'node');
2799
2800 my $vmid = extract_param($param, 'vmid');
2801
2802 my $snapname = extract_param($param, 'snapname');
2803
7e7d7b61 2804 my $realcmd = sub {
22c377f0 2805 PVE::Cluster::log_msg('info', $authuser, "delete snapshot VM $vmid: $snapname");
3ee28e38 2806 PVE::QemuServer::snapshot_delete($vmid, $snapname, $param->{force});
7e7d7b61 2807 };
9dbd1ee4 2808
7b2257a8 2809 return $rpcenv->fork_worker('qmdelsnapshot', $vmid, $authuser, $realcmd);
9dbd1ee4
AD		 2810 }});
2811
04a69bb4
AD		 2812__PACKAGE__->register_method({
2813 name => 'template',
2814 path => '{vmid}/template',
2815 method => 'POST',
2816 protected => 1,
2817 proxyto => 'node',
2818 description => "Create a Template.",
b02691d8 2819 permissions => {
7af0a6c8
DM		 2820 description => "You need 'VM.Allocate' permissions on /vms/{vmid}",
2821 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
b02691d8 2822 },
04a69bb4
AD		 2823 parameters => {
2824 additionalProperties => 0,
2825 properties => {
2826 node => get_standard_option('pve-node'),
2827 vmid => get_standard_option('pve-vmid'),
2828 disk => {
2829 optional => 1,
2830 type => 'string',
2831 description => "If you want to convert only 1 disk to base image.",
2832 enum => [PVE::QemuServer::disknames()],
2833 },
2834
2835 },
2836 },
2837 returns => { type => 'null'},
2838 code => sub {
2839 my ($param) = @_;
2840
2841 my $rpcenv = PVE::RPCEnvironment::get();
2842
2843 my $authuser = $rpcenv->get_user();
2844
2845 my $node = extract_param($param, 'node');
2846
2847 my $vmid = extract_param($param, 'vmid');
2848
2849 my $disk = extract_param($param, 'disk');
2850
2851 my $updatefn = sub {
2852
2853 my $conf = PVE::QemuServer::load_config($vmid);
2854
2855 PVE::QemuServer::check_lock($conf);
2856
75466c4f 2857 die "unable to create template, because VM contains snapshots\n"
b91c2aae 2858 if $conf->{snapshots} && scalar(keys %{$conf->{snapshots}});
0402a80b 2859
75466c4f 2860 die "you can't convert a template to a template\n"
03c2d0ad 2861 if PVE::QemuServer::is_template($conf) && !$disk;
0402a80b 2862
75466c4f 2863 die "you can't convert a VM to template if VM is running\n"
218cab9a 2864 if PVE::QemuServer::check_running($vmid);
35c5fdef 2865
04a69bb4
AD		 2866 my $realcmd = sub {
2867 PVE::QemuServer::template_create($vmid, $conf, $disk);
2868 };
04a69bb4 2869
75e7e997 2870 $conf->{template} = 1;
04a69bb4 2871 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
75e7e997
DM		 2872
2873 return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
04a69bb4
AD		 2874 };
2875
2876 PVE::QemuServer::lock_config($vmid, $updatefn);
2877 return undef;
2878 }});
2879
1e3baf05 28801;
Virtual Machine Manager