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