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