]> git.proxmox.com Git - qemu-server.git/blame - PVE/VZDump/QemuServer.pm
backup: query status: use latest up-to-date info when finished
[qemu-server.git] / PVE / VZDump / QemuServer.pm
CommitLineData
1e3baf05
DM
1package PVE::VZDump::QemuServer;
2
1e3baf05
DM
3use strict;
4use warnings;
d610b145 5
1e3baf05 6use File::Basename;
d610b145
TL
7use File::Path;
8use IO::File;
9use IPC::Open3;
69e62894 10use JSON;
d610b145
TL
11
12use PVE::Cluster qw(cfs_read_file);
66ab1d91 13use PVE::INotify;
91bd6c90 14use PVE::IPCC;
d610b145 15use PVE::JSONSchema;
0a13e08e 16use PVE::QMPClient;
f5bdefa4 17use PVE::Storage::Plugin;
c5983223 18use PVE::Storage::PBSPlugin;
1e3baf05 19use PVE::Storage;
d610b145
TL
20use PVE::Tools;
21use PVE::VZDump;
22
912792e2 23use PVE::QemuConfig;
1e3baf05 24use PVE::QemuServer;
3392d6ca 25use PVE::QemuServer::Machine;
0a13e08e 26use PVE::QemuServer::Monitor qw(mon_cmd);
1e3baf05
DM
27
28use base qw (PVE::VZDump::Plugin);
29
30sub new {
31 my ($class, $vzdump) = @_;
874a096e 32
66ab1d91 33 PVE::VZDump::check_bin('qm');
1e3baf05 34
e2812738 35 my $self = bless { vzdump => $vzdump }, $class;
1e3baf05
DM
36
37 $self->{vmlist} = PVE::QemuServer::vzlist();
38 $self->{storecfg} = PVE::Storage::config();
39
40 return $self;
41};
42
1e3baf05
DM
43sub type {
44 return 'qemu';
45}
46
47sub vmlist {
48 my ($self) = @_;
1e3baf05
DM
49 return [ keys %{$self->{vmlist}} ];
50}
51
52sub prepare {
53 my ($self, $task, $vmid, $mode) = @_;
54
55 $task->{disks} = [];
56
ffda963f 57 my $conf = $self->{vmlist}->{$vmid} = PVE::QemuConfig->load_config($vmid);
1e3baf05 58
85b84b7b
WL
59 $self->loginfo("VM Name: $conf->{name}")
60 if defined($conf->{name});
61
91bd6c90
DM
62 $self->{vm_was_running} = 1;
63 if (!PVE::QemuServer::check_running($vmid)) {
64 $self->{vm_was_running} = 0;
585b6e28
DM
65 }
66
1e3baf05
DM
67 $task->{hostname} = $conf->{name};
68
874a096e 69 my $hostname = PVE::INotify::nodename();
1e3baf05 70
b969cc68
DM
71 my $vollist = [];
72 my $drivehash = {};
185df962 73 my $backup_volumes = PVE::QemuConfig->get_backup_volumes($conf);
1e3baf05 74
185df962
AL
75 foreach my $volume (@{$backup_volumes}) {
76 my $name = $volume->{key};
5a92276e 77 my $volume_config = $volume->{volume_config};
185df962 78 my $volid = $volume_config->{file};
1e3baf05 79
185df962
AL
80 if (!$volume->{included}) {
81 $self->loginfo("exclude disk '$name' '$volid' ($volume->{reason})");
82 next;
83 } elsif ($self->{vm_was_running} && $volume_config->{iothread}) {
3392d6ca 84 if (!PVE::QemuServer::Machine::runs_at_least_qemu_version($vmid, 4, 0, 1)) {
185df962 85 die "disk '$name' '$volid' (iothread=on) can't use backup feature with running QEMU " .
48343b3f
TL
86 "version < 4.0.1! Either set backup=no for this drive or upgrade QEMU and restart VM\n";
87 }
b53b958b 88 } else {
185df962
AL
89 my $log = "include disk '$name' '$volid'";
90 if (defined(my $size = $volume_config->{size})) {
91 my $readable_size = PVE::JSONSchema::format_size($size);
0db93c2d 92 $log .= " $readable_size";
185df962 93 }
0db93c2d 94 $self->loginfo($log);
874a096e 95 }
b969cc68 96
f5bdefa4 97 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
b969cc68 98 push @$vollist, $volid if $storeid;
185df962
AL
99 $drivehash->{$name} = $volume->{volume_config};
100 }
b969cc68
DM
101
102 PVE::Storage::activate_volumes($self->{storecfg}, $vollist);
103
075b417a
DM
104 foreach my $ds (sort keys %$drivehash) {
105 my $drive = $drivehash->{$ds};
874a096e 106
1e3baf05 107 my $volid = $drive->{file};
f5bdefa4 108 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
a113a58a
TL
109
110 my $path = $volid;
1e3baf05 111 if ($storeid) {
b969cc68 112 $path = PVE::Storage::path($self->{storecfg}, $volid);
1e3baf05 113 }
b969cc68 114 next if !$path;
1e3baf05 115
a113a58a 116 my ($size, $format) = eval { PVE::Storage::volume_size_info($self->{storecfg}, $volid, 5) };
daca220d 117 die "no such volume '$volid'\n" if $@;
91bd6c90 118
a113a58a
TL
119 my $diskinfo = {
120 path => $path,
121 volid => $volid,
122 storeid => $storeid,
123 format => $format,
124 virtdev => $ds,
125 qmdevice => "drive-$ds",
126 };
1e3baf05
DM
127
128 if (-b $path) {
1e3baf05 129 $diskinfo->{type} = 'block';
1e3baf05 130 } else {
1e3baf05 131 $diskinfo->{type} = 'file';
1e3baf05
DM
132 }
133
134 push @{$task->{disks}}, $diskinfo;
b969cc68 135 }
1e3baf05
DM
136}
137
138sub vm_status {
139 my ($self, $vmid) = @_;
140
66ab1d91 141 my $running = PVE::QemuServer::check_running($vmid) ? 1 : 0;
874a096e
DM
142
143 return wantarray ? ($running, $running ? 'running' : 'stopped') : $running;
1e3baf05
DM
144}
145
146sub lock_vm {
147 my ($self, $vmid) = @_;
148
f301bc0d 149 PVE::QemuConfig->set_lock($vmid, 'backup');
1e3baf05
DM
150}
151
152sub unlock_vm {
153 my ($self, $vmid) = @_;
154
f301bc0d 155 PVE::QemuConfig->remove_lock($vmid, 'backup');
1e3baf05
DM
156}
157
158sub stop_vm {
159 my ($self, $task, $vmid) = @_;
160
161 my $opts = $self->{vzdump}->{opts};
162
163 my $wait = $opts->{stopwait} * 60;
164 # send shutdown and wait
254575e9 165 $self->cmd ("qm shutdown $vmid --skiplock --keepActive --timeout $wait");
1e3baf05
DM
166}
167
168sub start_vm {
169 my ($self, $task, $vmid) = @_;
170
66ab1d91 171 $self->cmd ("qm start $vmid --skiplock");
1e3baf05
DM
172}
173
174sub suspend_vm {
175 my ($self, $task, $vmid) = @_;
176
66ab1d91 177 $self->cmd ("qm suspend $vmid --skiplock");
1e3baf05
DM
178}
179
180sub resume_vm {
181 my ($self, $task, $vmid) = @_;
182
66ab1d91 183 $self->cmd ("qm resume $vmid --skiplock");
1e3baf05
DM
184}
185
1e3baf05
DM
186sub assemble {
187 my ($self, $task, $vmid) = @_;
188
04096e7b 189 my $conffile = PVE::QemuConfig->config_file($vmid);
1e3baf05
DM
190
191 my $outfile = "$task->{tmpdir}/qemu-server.conf";
c05f7f3f
WL
192 my $firewall_src = "/etc/pve/firewall/$vmid.fw";
193 my $firewall_dest = "$task->{tmpdir}/qemu-server.fw";
194
195 my $outfd = IO::File->new (">$outfile") ||
196 die "unable to open '$outfile'";
197 my $conffd = IO::File->new ($conffile, 'r') ||
198 die "unable open '$conffile'";
199
200 my $found_snapshot;
391c2230 201 my $found_pending;
c05f7f3f
WL
202 while (defined (my $line = <$conffd>)) {
203 next if $line =~ m/^\#vzdump\#/; # just to be sure
204 next if $line =~ m/^\#qmdump\#/; # just to be sure
391c2230
FG
205 if ($line =~ m/^\[(.*)\]\s*$/) {
206 if ($1 =~ m/PENDING/i) {
207 $found_pending = 1;
208 } else {
209 $found_snapshot = 1;
210 }
1e3baf05 211 }
1bd6fe13 212 next if $found_snapshot || $found_pending; # skip all snapshots and pending changes config data
391c2230 213
c05f7f3f
WL
214 if ($line =~ m/^unused\d+:\s*(\S+)\s*/) {
215 $self->loginfo("skip unused drive '$1' (not included into backup)");
216 next;
1e3baf05 217 }
c05f7f3f 218 next if $line =~ m/^lock:/ || $line =~ m/^parent:/;
91bd6c90 219
c05f7f3f
WL
220 print $outfd $line;
221 }
222
223 foreach my $di (@{$task->{disks}}) {
224 if ($di->{type} eq 'block' || $di->{type} eq 'file') {
225 my $storeid = $di->{storeid} || '';
226 my $format = $di->{format} || '';
227 print $outfd "#qmdump#map:$di->{virtdev}:$di->{qmdevice}:$storeid:$format:\n";
228 } else {
229 die "internal error";
91bd6c90 230 }
c05f7f3f 231 }
1e3baf05 232
c05f7f3f
WL
233 if ($found_snapshot) {
234 $self->loginfo("snapshots found (not included into backup)");
235 }
391c2230
FG
236 if ($found_pending) {
237 $self->loginfo("pending configuration changes found (not included into backup)");
238 }
239
c05f7f3f 240 PVE::Tools::file_copy($firewall_src, $firewall_dest) if -f $firewall_src;
1e3baf05
DM
241}
242
243sub archive {
fad02a16 244 my ($self, $task, $vmid, $filename, $comp) = @_;
1e3baf05 245
c5983223 246 my $opts = $self->{vzdump}->{opts};
c5983223
DM
247 my $scfg = $opts->{scfg};
248
69074863 249 if ($self->{vzdump}->{opts}->{pbs}) {
c5983223
DM
250 $self->archive_pbs($task, $vmid);
251 } else {
252 $self->archive_vma($task, $vmid, $filename, $comp);
253 }
254}
255
4d159c24
TL
256# number, [precision=1]
257my $num2str = sub {
258 return sprintf( "%." . ( $_[1] || 1 ) . "f", $_[0] );
259};
260sub bytes_to_human {
261 my ($bytes, $precission) = @_;
262
263 return $num2str->($bytes, $precission) . ' B' if $bytes < 1024;
264 my $kb = $bytes/1024;
265
266 return $num2str->($kb, $precission) . " KiB" if $kb < 1024;
267 my $mb = $kb/1024;
268
269 return $num2str->($mb, $precission) . " MiB" if $mb < 1024;
270 my $gb = $mb/1024;
271
272 return $num2str->($gb, $precission) . " GiB" if $gb < 1024;
273 my $tb = $gb/1024;
274
275 return $num2str->($tb, $precission) . " TiB";
276};
277
c5983223
DM
278my $query_backup_status_loop = sub {
279 my ($self, $vmid, $job_uuid) = @_;
280
c5983223 281 my $starttime = time ();
09eb196b 282 my $last_time = $starttime;
4d159c24
TL
283 my ($last_percent, $last_total, $last_target, $last_zero, $last_transferred) = (-1, 0, 0, 0, 0);
284 my ($transferred, $reused);
285 my $first_round = 1;
c5983223 286
09eb196b
TL
287 my $get_mbps = sub {
288 my ($mb, $delta) = @_;
4d159c24
TL
289 return "0 B/s" if $mb <= 0;
290 my $bw = int(($mb / $delta));
291 return bytes_to_human($bw) . "/s";
09eb196b
TL
292 };
293
c5983223 294 while(1) {
09eb196b
TL
295 my $status = mon_cmd($vmid, 'query-backup');
296
c5983223 297 my $total = $status->{total} || 0;
4d159c24
TL
298 my $dirty = $status->{dirty};
299 my $target = (defined($dirty) && $dirty < $total) ? $dirty : $total;
c5983223 300 $transferred = $status->{transferred} || 0;
4d159c24
TL
301 $reused = $status->{reused};
302 my $percent = $target ? int(($transferred * 100)/$target) : 0;
c5983223 303 my $zero = $status->{'zero-bytes'} || 0;
c5983223
DM
304
305 die "got unexpected uuid\n" if !$status->{uuid} || ($status->{uuid} ne $job_uuid);
306
307 my $ctime = time();
308 my $duration = $ctime - $starttime;
309
310 my $rbytes = $transferred - $last_transferred;
311 my $wbytes = $rbytes - ($zero - $last_zero);
312
313 my $timediff = ($ctime - $last_time) || 1; # fixme
09eb196b
TL
314 my $mbps_read = $get_mbps->($rbytes, $timediff);
315 my $mbps_write = $get_mbps->($wbytes, $timediff);
4d159c24
TL
316 my $target_h = bytes_to_human($target);
317 my $transferred_h = bytes_to_human($transferred);
318
319 if ($first_round && $target != $total) {
320 my $total_h = bytes_to_human($total);
321 $self->loginfo("using fast incremental mode (dirty-bitmap), $target_h dirty of $total_h total");
322 }
09eb196b 323
4d159c24
TL
324 my $statusline = "status: $percent% ($transferred_h of $target_h), duration $duration"
325 .", read: $mbps_read, write: $mbps_write";
09eb196b 326
c5983223
DM
327 my $res = $status->{status} || 'unknown';
328 if ($res ne 'active') {
329 $self->loginfo($statusline);
09eb196b
TL
330 if ($res ne 'done') {
331 die (($status->{errmsg} || "unknown error") . "\n") if $res eq 'error';
332 die "got unexpected status '$res'\n";
09eb196b 333 }
6cdb568c
TL
334 $last_target = $target if $target;
335 $last_total = $total if $total;
336 $last_zero = $zero if $zero;
337 $last_transferred = $transferred if $transferred;
c5983223
DM
338 last;
339 }
09eb196b 340 if ($percent != $last_percent && ($timediff > 2)) {
c5983223 341 $self->loginfo($statusline);
09eb196b 342 $last_percent = $percent;
4d159c24 343 $last_target = $target if $target;
c5983223
DM
344 $last_total = $total if $total;
345 $last_zero = $zero if $zero;
346 $last_transferred = $transferred if $transferred;
347 $last_time = $ctime;
348 }
349 sleep(1);
4d159c24 350 $first_round = 0;
c5983223
DM
351 }
352
353 my $duration = time() - $starttime;
354 if ($transferred && $duration) {
4d159c24 355 my $transferred_h = bytes_to_human($transferred, 2);
09eb196b 356 my $mbps = $get_mbps->($transferred, $duration);
4d159c24
TL
357 if ($reused) {
358 my $reused_h = bytes_to_human($reused, 2);
359 my $reuse_per = int($reused * 100 / $last_total);
360 $self->loginfo("backup was done incrementally, reused $reused_h (${reuse_per}%) from last backup");
361 $self->loginfo("transferred $transferred_h in $duration seconds ($mbps)");
362 } else {
363 $self->loginfo("transferred $transferred_h in $duration seconds ($mbps)");
364 }
365 }
366
367 if ($last_zero) {
368 my $zero_per = $last_target ? int(($last_zero * 100)/$last_target) : 0;
369 my $zero_h = bytes_to_human($last_zero, 2);
370 $self->loginfo("Backup is sparse: ${zero_per}% ($zero_h) zero data");
c5983223
DM
371 }
372};
373
374sub archive_pbs {
375 my ($self, $task, $vmid) = @_;
376
1e3baf05 377 my $conffile = "$task->{tmpdir}/qemu-server.conf";
c05f7f3f 378 my $firewall = "$task->{tmpdir}/qemu-server.fw";
1e3baf05
DM
379
380 my $opts = $self->{vzdump}->{opts};
c5983223
DM
381 my $scfg = $opts->{scfg};
382
383 my $starttime = time();
384
c5983223
DM
385 my $server = $scfg->{server};
386 my $datastore = $scfg->{datastore};
387 my $username = $scfg->{username} // 'root@pam';
388 my $fingerprint = $scfg->{fingerprint};
389
390 my $repo = "$username\@$server:$datastore";
391 my $password = PVE::Storage::PBSPlugin::pbs_get_password($scfg, $opts->{storage});
392
d11e91d2 393 my $diskcount = scalar(@{$task->{disks}});
c5983223
DM
394 if (PVE::QemuConfig->is_template($self->{vmlist}->{$vmid}) || !$diskcount) {
395 my @pathlist;
396 foreach my $di (@{$task->{disks}}) {
397 if ($di->{type} eq 'block' || $di->{type} eq 'file') {
398 push @pathlist, "$di->{qmdevice}.img:$di->{path}";
399 } else {
d11e91d2 400 die "implement me (type $di->{type})";
c5983223
DM
401 }
402 }
403
404 if (!$diskcount) {
405 $self->loginfo("backup contains no disks");
406 }
407
408 local $ENV{PBS_PASSWORD} = $password;
77b24c62 409 local $ENV{PBS_FINGERPRINT} = $fingerprint if defined($fingerprint);
c5983223
DM
410 my $cmd = [
411 '/usr/bin/proxmox-backup-client',
412 'backup',
413 '--repository', $repo,
414 '--backup-type', 'vm',
415 '--backup-id', "$vmid",
416 '--backup-time', $task->{backup_time},
d11e91d2 417 ];
c5983223
DM
418
419 push @$cmd, "qemu-server.conf:$conffile";
420 push @$cmd, "fw.conf:$firewall" if -e $firewall;
421 push @$cmd, @pathlist if scalar(@pathlist);
422
423 $self->loginfo("starting template backup");
424 $self->loginfo(join(' ', @$cmd));
425
426 $self->cmd($cmd);
427
428 return;
429 }
430
81dcd479
TL
431 # get list early so we die on unkown drive types before doing anything
432 my $devlist = _get_task_devlist($task);
c5983223 433
0b2f574b 434 $self->enforce_vm_running_for_backup($vmid);
c5983223 435
f6168f1a 436 my $backup_job_uuid;
c5983223
DM
437 eval {
438 $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
d11e91d2 439 die "interrupted by signal\n";
c5983223
DM
440 };
441
cb521f2d 442 my $fs_frozen = $self->qga_fs_freeze($task, $vmid);
c5983223 443
d11e91d2
TL
444 my $params = {
445 format => "pbs",
446 'backup-file' => $repo,
447 'backup-id' => "$vmid",
448 'backup-time' => $task->{backup_time},
449 password => $password,
450 devlist => $devlist,
451 'config-file' => $conffile,
bbdf1ea5 452 'use-dirty-bitmap' => JSON::true,
c5983223 453 };
d11e91d2
TL
454 $params->{fingerprint} = $fingerprint if defined($fingerprint);
455 $params->{'firewall-file'} = $firewall if -e $firewall;
c5983223 456
f57666e9
DM
457 $params->{timeout} = 60; # give some time to connect to the backup server
458
d11e91d2 459 my $res = eval { mon_cmd($vmid, "backup", %$params) };
c5983223 460 my $qmperr = $@;
d11e91d2 461 $backup_job_uuid = $res->{UUID} if $res;
c5983223 462
1ece829a
TL
463 if ($fs_frozen) {
464 $self->qga_fs_thaw($vmid);
c5983223
DM
465 }
466
467 die $qmperr if $qmperr;
f6168f1a 468 die "got no uuid for backup task\n" if !defined($backup_job_uuid);
c5983223 469
f6168f1a 470 $self->loginfo("started backup task '$backup_job_uuid'");
c5983223 471
0b2f574b 472 $self->resume_vm_after_job_start($task, $vmid);
c5983223 473
f6168f1a 474 $query_backup_status_loop->($self, $vmid, $backup_job_uuid);
c5983223
DM
475 };
476 my $err = $@;
c5983223
DM
477 if ($err) {
478 $self->logerr($err);
0b2f574b 479 $self->mon_backup_cancel($vmid) if defined($backup_job_uuid);
c5983223 480 }
0b2f574b 481 $self->restore_vm_power_state($vmid);
c5983223
DM
482
483 die $err if $err;
484}
485
02da0c65
TL
486my $fork_compressor_pipe = sub {
487 my ($self, $comp, $outfileno) = @_;
488
489 my @pipefd = POSIX::pipe();
490 my $cpid = fork();
491 die "unable to fork worker - $!" if !defined($cpid) || $cpid < 0;
492 if ($cpid == 0) {
493 eval {
494 POSIX::close($pipefd[1]);
495 # redirect STDIN
496 my $fd = fileno(STDIN);
497 close STDIN;
498 POSIX::close(0) if $fd != 0;
499 die "unable to redirect STDIN - $!"
500 if !open(STDIN, "<&", $pipefd[0]);
501
502 # redirect STDOUT
503 $fd = fileno(STDOUT);
504 close STDOUT;
505 POSIX::close (1) if $fd != 1;
506
507 die "unable to redirect STDOUT - $!"
508 if !open(STDOUT, ">&", $outfileno);
509
510 exec($comp);
511 die "fork compressor '$comp' failed\n";
512 };
513 if (my $err = $@) {
514 $self->logerr($err);
515 POSIX::_exit(1);
516 }
517 POSIX::_exit(0);
518 kill(-9, $$);
519 } else {
520 POSIX::close($pipefd[0]);
521 $outfileno = $pipefd[1];
522 }
523
524 return ($cpid, $outfileno);
525};
526
c5983223
DM
527sub archive_vma {
528 my ($self, $task, $vmid, $filename, $comp) = @_;
529
530 my $conffile = "$task->{tmpdir}/qemu-server.conf";
531 my $firewall = "$task->{tmpdir}/qemu-server.fw";
532
533 my $opts = $self->{vzdump}->{opts};
534
535 my $starttime = time();
1e3baf05 536
91bd6c90
DM
537 my $speed = 0;
538 if ($opts->{bwlimit}) {
874a096e 539 $speed = $opts->{bwlimit}*1024;
91bd6c90 540 }
1e3baf05 541
c82935e9 542 my $diskcount = scalar(@{$task->{disks}});
ffda963f 543 if (PVE::QemuConfig->is_template($self->{vmlist}->{$vmid}) || !$diskcount) {
23b4120b
DM
544 my @pathlist;
545 foreach my $di (@{$task->{disks}}) {
546 if ($di->{type} eq 'block' || $di->{type} eq 'file') {
547 push @pathlist, "$di->{qmdevice}=$di->{path}";
548 } else {
549 die "implement me";
550 }
551 }
552
c82935e9
DM
553 if (!$diskcount) {
554 $self->loginfo("backup contains no disks");
555 }
556
23b4120b
DM
557 my $outcmd;
558 if ($comp) {
874a096e 559 $outcmd = "exec:$comp";
23b4120b 560 } else {
874a096e 561 $outcmd = "exec:cat";
23b4120b
DM
562 }
563
a2fab11a 564 $outcmd .= " > $filename" if !$opts->{stdout};
23b4120b 565
c05f7f3f
WL
566 my $cmd = ['/usr/bin/vma', 'create', '-v', '-c', $conffile];
567 push @$cmd, '-c', $firewall if -e $firewall;
568 push @$cmd, $outcmd, @pathlist;
23b4120b
DM
569
570 $self->loginfo("starting template backup");
571 $self->loginfo(join(' ', @$cmd));
572
573 if ($opts->{stdout}) {
6bb12239 574 $self->cmd($cmd, output => ">&" . fileno($opts->{stdout}));
23b4120b
DM
575 } else {
576 $self->cmd($cmd);
577 }
578
579 return;
580 }
581
81dcd479 582 my $devlist = _get_task_devlist($task);
1e3baf05 583
0b2f574b 584 $self->enforce_vm_running_for_backup($vmid);
91bd6c90
DM
585
586 my $cpid;
d2cc2cbe
DM
587 my $backup_job_uuid;
588
91bd6c90
DM
589 eval {
590 $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
d11e91d2 591 die "interrupted by signal\n";
91bd6c90
DM
592 };
593
91bd6c90
DM
594 my $outfh;
595 if ($opts->{stdout}) {
596 $outfh = $opts->{stdout};
597 } else {
598 $outfh = IO::File->new($filename, "w") ||
599 die "unable to open file '$filename' - $!\n";
600 }
02da0c65 601 my $outfileno = fileno($outfh);
91bd6c90 602
91bd6c90 603 if ($comp) {
02da0c65 604 ($cpid, $outfileno) = $fork_compressor_pipe->($self, $comp, $outfileno);
91bd6c90
DM
605 }
606
e8705fc5
TL
607 my $qmpclient = PVE::QMPClient->new();
608 my $backup_cb = sub {
609 my ($vmid, $resp) = @_;
610 $backup_job_uuid = $resp->{return}->{UUID};
611 };
612 my $add_fd_cb = sub {
91bd6c90
DM
613 my ($vmid, $resp) = @_;
614
c05f7f3f
WL
615 my $params = {
616 'backup-file' => "/dev/fdname/backup",
617 speed => $speed,
618 'config-file' => $conffile,
619 devlist => $devlist
620 };
c05f7f3f 621 $params->{'firewall-file'} = $firewall if -e $firewall;
d11e91d2 622
c05f7f3f 623 $qmpclient->queue_cmd($vmid, $backup_cb, 'backup', %$params);
91bd6c90
DM
624 };
625
d11e91d2 626 $qmpclient->queue_cmd($vmid, $add_fd_cb, 'getfd', fd => $outfileno, fdname => "backup");
ab6a9a0c 627
cb521f2d 628 my $fs_frozen = $self->qga_fs_freeze($task, $vmid);
874a096e 629
c5983223 630 eval { $qmpclient->queue_execute(30) };
f0f30448 631 my $qmperr = $@;
91bd6c90 632
1ece829a
TL
633 if ($fs_frozen) {
634 $self->qga_fs_thaw($vmid);
ab6a9a0c 635 }
d11e91d2 636
f0f30448 637 die $qmperr if $qmperr;
874a096e 638 die $qmpclient->{errors}->{$vmid} if $qmpclient->{errors}->{$vmid};
91bd6c90
DM
639
640 if ($cpid) {
874a096e 641 POSIX::close($outfileno) == 0 ||
91bd6c90
DM
642 die "close output file handle failed\n";
643 }
644
d2cc2cbe 645 die "got no uuid for backup task\n" if !defined($backup_job_uuid);
91bd6c90 646
d2cc2cbe 647 $self->loginfo("started backup task '$backup_job_uuid'");
91bd6c90 648
0b2f574b 649 $self->resume_vm_after_job_start($task, $vmid);
91bd6c90 650
d2cc2cbe 651 $query_backup_status_loop->($self, $vmid, $backup_job_uuid);
91bd6c90
DM
652 };
653 my $err = $@;
19599cd9 654 if ($err) {
60635a57 655 $self->logerr($err);
0b2f574b 656 $self->mon_backup_cancel($vmid) if defined($backup_job_uuid);
19599cd9
DM
657 }
658
0b2f574b 659 $self->restore_vm_power_state($vmid);
91bd6c90
DM
660
661 if ($err) {
874a096e
DM
662 if ($cpid) {
663 kill(9, $cpid);
91bd6c90
DM
664 waitpid($cpid, 0);
665 }
666 die $err;
667 }
668
669 if ($cpid && (waitpid($cpid, 0) > 0)) {
670 my $stat = $?;
671 my $ec = $stat >> 8;
672 my $signal = $stat & 127;
673 if ($ec || $signal) {
874a096e 674 die "$comp failed - wrong exit status $ec" .
91bd6c90
DM
675 ($signal ? " (signal $signal)\n" : "\n");
676 }
677 }
678}
679
81dcd479
TL
680sub _get_task_devlist {
681 my ($task) = @_;
682
683 my $devlist = '';
684 foreach my $di (@{$task->{disks}}) {
685 if ($di->{type} eq 'block' || $di->{type} eq 'file') {
686 $devlist .= ',' if $devlist;
687 $devlist .= $di->{qmdevice};
688 } else {
689 die "implement me (type '$di->{type}')";
690 }
691 }
692 return $devlist;
693}
694
1ece829a 695sub qga_fs_freeze {
cb521f2d
TL
696 my ($self, $task, $vmid) = @_;
697 return if !$self->{vmlist}->{$vmid}->{agent} || $task->{mode} eq 'stop' || !$self->{vm_was_running};
1ece829a
TL
698
699 if (!PVE::QemuServer::qga_check_running($vmid, 1)) {
700 $self->loginfo("skipping guest-agent 'fs-freeze', agent configured but not running?");
701 return;
702 }
703
704 $self->loginfo("issuing guest-agent 'fs-freeze' command");
705 eval { mon_cmd($vmid, "guest-fsfreeze-freeze") };
706 $self->logerr($@) if $@;
707
708 return 1; # even on mon command error, ensure we always thaw again
709}
710
711# only call if fs_freeze return 1
712sub qga_fs_thaw {
713 my ($self, $vmid) = @_;
714
715 $self->loginfo("issuing guest-agent 'fs-thaw' command");
716 eval { mon_cmd($vmid, "guest-fsfreeze-thaw") };
717 $self->logerr($@) if $@;
718}
719
0b2f574b
TL
720# we need a running QEMU/KVM process for backup, starts a paused (prelaunch)
721# one if VM isn't already running
722sub enforce_vm_running_for_backup {
723 my ($self, $vmid) = @_;
724
725 if (PVE::QemuServer::check_running($vmid)) {
726 $self->{vm_was_running} = 1;
727 return;
728 }
729
730 eval {
731 $self->loginfo("starting kvm to execute backup task");
732 # start with skiplock
0c498cca
FG
733 my $params = {
734 skiplock => 1,
735 paused => 1,
736 };
737 PVE::QemuServer::vm_start($self->{storecfg}, $vmid, $params);
0b2f574b
TL
738 };
739 die $@ if $@;
740}
741
742# resume VM againe once we got in a clear state (stop mode backup of running VM)
743sub resume_vm_after_job_start {
744 my ($self, $task, $vmid) = @_;
745
746 return if !$self->{vm_was_running};
747
748 if (my $stoptime = $task->{vmstoptime}) {
749 my $delay = time() - $task->{vmstoptime};
750 $task->{vmstoptime} = undef; # avoid printing 'online after ..' twice
751 $self->loginfo("resuming VM again after $delay seconds");
752 } else {
753 $self->loginfo("resuming VM again");
754 }
755 mon_cmd($vmid, 'cont');
756}
757
758# stop again if VM was not running before
759sub restore_vm_power_state {
760 my ($self, $vmid) = @_;
761
762 # we always let VMs keep running
763 return if $self->{vm_was_running};
764
765 eval {
766 my $resp = mon_cmd($vmid, 'query-status');
767 my $status = $resp && $resp->{status} ? $resp->{status} : 'unknown';
768 if ($status eq 'prelaunch') {
769 $self->loginfo("stopping kvm after backup task");
770 PVE::QemuServer::vm_stop($self->{storecfg}, $vmid, 1);
771 } else {
772 $self->loginfo("kvm status changed after backup ('$status') - keep VM running");
773 }
774 };
775 warn $@ if $@;
776}
777
778sub mon_backup_cancel {
779 my ($self, $vmid) = @_;
780
781 $self->loginfo("aborting backup job");
782 eval { mon_cmd($vmid, 'backup-cancel') };
783 $self->logerr($@) if $@;
784}
785
91bd6c90
DM
786sub snapshot {
787 my ($self, $task, $vmid) = @_;
788
789 # nothing to do
1e3baf05
DM
790}
791
792sub cleanup {
793 my ($self, $task, $vmid) = @_;
794
91bd6c90 795 # nothing to do ?
1e3baf05
DM
796}
797
7981;