]>
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; | |
69e62894 | 10 | use JSON; |
d610b145 TL |
11 | |
12 | use PVE::Cluster qw(cfs_read_file); | |
66ab1d91 | 13 | use PVE::INotify; |
91bd6c90 | 14 | use PVE::IPCC; |
d610b145 | 15 | use PVE::JSONSchema; |
0a13e08e | 16 | use PVE::QMPClient; |
f5bdefa4 | 17 | use PVE::Storage::Plugin; |
c5983223 | 18 | use PVE::Storage::PBSPlugin; |
1e3baf05 | 19 | use PVE::Storage; |
d610b145 TL |
20 | use PVE::Tools; |
21 | use PVE::VZDump; | |
22 | ||
912792e2 | 23 | use PVE::QemuConfig; |
1e3baf05 | 24 | use PVE::QemuServer; |
3392d6ca | 25 | use PVE::QemuServer::Machine; |
0a13e08e | 26 | use PVE::QemuServer::Monitor qw(mon_cmd); |
1e3baf05 DM |
27 | |
28 | use base qw (PVE::VZDump::Plugin); | |
29 | ||
30 | sub 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 |
43 | sub type { |
44 | return 'qemu'; | |
45 | } | |
46 | ||
47 | sub vmlist { | |
48 | my ($self) = @_; | |
1e3baf05 DM |
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 = {}; | |
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 | ||
138 | sub 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 | ||
146 | sub lock_vm { | |
147 | my ($self, $vmid) = @_; | |
148 | ||
f301bc0d | 149 | PVE::QemuConfig->set_lock($vmid, 'backup'); |
1e3baf05 DM |
150 | } |
151 | ||
152 | sub unlock_vm { | |
153 | my ($self, $vmid) = @_; | |
154 | ||
f301bc0d | 155 | PVE::QemuConfig->remove_lock($vmid, 'backup'); |
1e3baf05 DM |
156 | } |
157 | ||
158 | sub 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 | ||
168 | sub start_vm { | |
169 | my ($self, $task, $vmid) = @_; | |
170 | ||
66ab1d91 | 171 | $self->cmd ("qm start $vmid --skiplock"); |
1e3baf05 DM |
172 | } |
173 | ||
174 | sub suspend_vm { | |
175 | my ($self, $task, $vmid) = @_; | |
176 | ||
66ab1d91 | 177 | $self->cmd ("qm suspend $vmid --skiplock"); |
1e3baf05 DM |
178 | } |
179 | ||
180 | sub resume_vm { | |
181 | my ($self, $task, $vmid) = @_; | |
182 | ||
66ab1d91 | 183 | $self->cmd ("qm resume $vmid --skiplock"); |
1e3baf05 DM |
184 | } |
185 | ||
1e3baf05 DM |
186 | sub 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 | ||
243 | sub 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] |
257 | my $num2str = sub { | |
258 | return sprintf( "%." . ( $_[1] || 1 ) . "f", $_[0] ); | |
259 | }; | |
260 | sub 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 |
278 | my $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); | |
91c9f3b0 | 360 | $self->loginfo("backup was done incrementally, reused $reused_h (${reuse_per}%)"); |
4d159c24 | 361 | } |
91c9f3b0 | 362 | $self->loginfo("transferred $transferred_h in $duration seconds ($mbps)"); |
4d159c24 TL |
363 | } |
364 | ||
365 | if ($last_zero) { | |
366 | my $zero_per = $last_target ? int(($last_zero * 100)/$last_target) : 0; | |
367 | my $zero_h = bytes_to_human($last_zero, 2); | |
368 | $self->loginfo("Backup is sparse: ${zero_per}% ($zero_h) zero data"); | |
c5983223 | 369 | } |
b4be9c02 TL |
370 | |
371 | return { | |
372 | total => $last_total, | |
373 | reused => $reused, | |
374 | }; | |
c5983223 DM |
375 | }; |
376 | ||
377 | sub archive_pbs { | |
378 | my ($self, $task, $vmid) = @_; | |
379 | ||
1e3baf05 | 380 | my $conffile = "$task->{tmpdir}/qemu-server.conf"; |
c05f7f3f | 381 | my $firewall = "$task->{tmpdir}/qemu-server.fw"; |
1e3baf05 DM |
382 | |
383 | my $opts = $self->{vzdump}->{opts}; | |
c5983223 DM |
384 | my $scfg = $opts->{scfg}; |
385 | ||
386 | my $starttime = time(); | |
387 | ||
c5983223 DM |
388 | my $server = $scfg->{server}; |
389 | my $datastore = $scfg->{datastore}; | |
390 | my $username = $scfg->{username} // 'root@pam'; | |
391 | my $fingerprint = $scfg->{fingerprint}; | |
392 | ||
393 | my $repo = "$username\@$server:$datastore"; | |
394 | my $password = PVE::Storage::PBSPlugin::pbs_get_password($scfg, $opts->{storage}); | |
ece74030 | 395 | my $keyfile = PVE::Storage::PBSPlugin::pbs_encryption_key_file_name($scfg, $opts->{storage}); |
c5983223 | 396 | |
d11e91d2 | 397 | my $diskcount = scalar(@{$task->{disks}}); |
c5983223 DM |
398 | if (PVE::QemuConfig->is_template($self->{vmlist}->{$vmid}) || !$diskcount) { |
399 | my @pathlist; | |
b4be9c02 | 400 | # FIXME: accumulate disk sizes to use for backup job (email) log |
c5983223 DM |
401 | foreach my $di (@{$task->{disks}}) { |
402 | if ($di->{type} eq 'block' || $di->{type} eq 'file') { | |
403 | push @pathlist, "$di->{qmdevice}.img:$di->{path}"; | |
404 | } else { | |
d11e91d2 | 405 | die "implement me (type $di->{type})"; |
c5983223 DM |
406 | } |
407 | } | |
408 | ||
409 | if (!$diskcount) { | |
410 | $self->loginfo("backup contains no disks"); | |
411 | } | |
412 | ||
413 | local $ENV{PBS_PASSWORD} = $password; | |
77b24c62 | 414 | local $ENV{PBS_FINGERPRINT} = $fingerprint if defined($fingerprint); |
c5983223 DM |
415 | my $cmd = [ |
416 | '/usr/bin/proxmox-backup-client', | |
417 | 'backup', | |
418 | '--repository', $repo, | |
419 | '--backup-type', 'vm', | |
420 | '--backup-id', "$vmid", | |
421 | '--backup-time', $task->{backup_time}, | |
d11e91d2 | 422 | ]; |
c5983223 DM |
423 | |
424 | push @$cmd, "qemu-server.conf:$conffile"; | |
425 | push @$cmd, "fw.conf:$firewall" if -e $firewall; | |
426 | push @$cmd, @pathlist if scalar(@pathlist); | |
427 | ||
428 | $self->loginfo("starting template backup"); | |
429 | $self->loginfo(join(' ', @$cmd)); | |
430 | ||
431 | $self->cmd($cmd); | |
432 | ||
433 | return; | |
434 | } | |
435 | ||
81dcd479 TL |
436 | # get list early so we die on unkown drive types before doing anything |
437 | my $devlist = _get_task_devlist($task); | |
c5983223 | 438 | |
0b2f574b | 439 | $self->enforce_vm_running_for_backup($vmid); |
c5983223 | 440 | |
f6168f1a | 441 | my $backup_job_uuid; |
c5983223 DM |
442 | eval { |
443 | $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub { | |
d11e91d2 | 444 | die "interrupted by signal\n"; |
c5983223 DM |
445 | }; |
446 | ||
fb9f512c SR |
447 | my $qemu_support = eval { mon_cmd($vmid, "query-proxmox-support") }; |
448 | if (!$qemu_support) { | |
449 | die "PBS backups are not supported by the running QEMU version. Please make " | |
450 | . "sure you've installed the latest version and the VM has been restarted.\n"; | |
451 | } | |
452 | ||
cb521f2d | 453 | my $fs_frozen = $self->qga_fs_freeze($task, $vmid); |
c5983223 | 454 | |
d11e91d2 TL |
455 | my $params = { |
456 | format => "pbs", | |
457 | 'backup-file' => $repo, | |
458 | 'backup-id' => "$vmid", | |
459 | 'backup-time' => $task->{backup_time}, | |
460 | password => $password, | |
461 | devlist => $devlist, | |
462 | 'config-file' => $conffile, | |
c5983223 | 463 | }; |
d11e91d2 TL |
464 | $params->{fingerprint} = $fingerprint if defined($fingerprint); |
465 | $params->{'firewall-file'} = $firewall if -e $firewall; | |
ece74030 WB |
466 | if (-e $keyfile) { |
467 | $self->loginfo("enabling encryption"); | |
468 | $params->{keyfile} = $keyfile; | |
469 | $params->{encrypt} = JSON::true; | |
470 | } else { | |
471 | $params->{encrypt} = JSON::false; | |
472 | } | |
c5983223 | 473 | |
fb9f512c SR |
474 | $params->{'use-dirty-bitmap'} = JSON::true if $qemu_support->{'pbs-dirty-bitmap'}; |
475 | ||
f57666e9 DM |
476 | $params->{timeout} = 60; # give some time to connect to the backup server |
477 | ||
d11e91d2 | 478 | my $res = eval { mon_cmd($vmid, "backup", %$params) }; |
c5983223 | 479 | my $qmperr = $@; |
d11e91d2 | 480 | $backup_job_uuid = $res->{UUID} if $res; |
c5983223 | 481 | |
1ece829a TL |
482 | if ($fs_frozen) { |
483 | $self->qga_fs_thaw($vmid); | |
c5983223 DM |
484 | } |
485 | ||
486 | die $qmperr if $qmperr; | |
f6168f1a | 487 | die "got no uuid for backup task\n" if !defined($backup_job_uuid); |
c5983223 | 488 | |
f6168f1a | 489 | $self->loginfo("started backup task '$backup_job_uuid'"); |
c5983223 | 490 | |
0b2f574b | 491 | $self->resume_vm_after_job_start($task, $vmid); |
c5983223 | 492 | |
2098f2ff TL |
493 | my $stat = $query_backup_status_loop->($self, $vmid, $backup_job_uuid); |
494 | $task->{size} = $stat->{total}; | |
c5983223 DM |
495 | }; |
496 | my $err = $@; | |
c5983223 DM |
497 | if ($err) { |
498 | $self->logerr($err); | |
0b2f574b | 499 | $self->mon_backup_cancel($vmid) if defined($backup_job_uuid); |
c5983223 | 500 | } |
0b2f574b | 501 | $self->restore_vm_power_state($vmid); |
c5983223 DM |
502 | |
503 | die $err if $err; | |
504 | } | |
505 | ||
02da0c65 TL |
506 | my $fork_compressor_pipe = sub { |
507 | my ($self, $comp, $outfileno) = @_; | |
508 | ||
509 | my @pipefd = POSIX::pipe(); | |
510 | my $cpid = fork(); | |
511 | die "unable to fork worker - $!" if !defined($cpid) || $cpid < 0; | |
512 | if ($cpid == 0) { | |
513 | eval { | |
514 | POSIX::close($pipefd[1]); | |
515 | # redirect STDIN | |
516 | my $fd = fileno(STDIN); | |
517 | close STDIN; | |
518 | POSIX::close(0) if $fd != 0; | |
519 | die "unable to redirect STDIN - $!" | |
520 | if !open(STDIN, "<&", $pipefd[0]); | |
521 | ||
522 | # redirect STDOUT | |
523 | $fd = fileno(STDOUT); | |
524 | close STDOUT; | |
525 | POSIX::close (1) if $fd != 1; | |
526 | ||
527 | die "unable to redirect STDOUT - $!" | |
528 | if !open(STDOUT, ">&", $outfileno); | |
529 | ||
530 | exec($comp); | |
531 | die "fork compressor '$comp' failed\n"; | |
532 | }; | |
533 | if (my $err = $@) { | |
534 | $self->logerr($err); | |
535 | POSIX::_exit(1); | |
536 | } | |
537 | POSIX::_exit(0); | |
538 | kill(-9, $$); | |
539 | } else { | |
540 | POSIX::close($pipefd[0]); | |
541 | $outfileno = $pipefd[1]; | |
542 | } | |
543 | ||
544 | return ($cpid, $outfileno); | |
545 | }; | |
546 | ||
c5983223 DM |
547 | sub archive_vma { |
548 | my ($self, $task, $vmid, $filename, $comp) = @_; | |
549 | ||
550 | my $conffile = "$task->{tmpdir}/qemu-server.conf"; | |
551 | my $firewall = "$task->{tmpdir}/qemu-server.fw"; | |
552 | ||
553 | my $opts = $self->{vzdump}->{opts}; | |
554 | ||
555 | my $starttime = time(); | |
1e3baf05 | 556 | |
91bd6c90 DM |
557 | my $speed = 0; |
558 | if ($opts->{bwlimit}) { | |
874a096e | 559 | $speed = $opts->{bwlimit}*1024; |
91bd6c90 | 560 | } |
1e3baf05 | 561 | |
c82935e9 | 562 | my $diskcount = scalar(@{$task->{disks}}); |
ffda963f | 563 | if (PVE::QemuConfig->is_template($self->{vmlist}->{$vmid}) || !$diskcount) { |
23b4120b DM |
564 | my @pathlist; |
565 | foreach my $di (@{$task->{disks}}) { | |
566 | if ($di->{type} eq 'block' || $di->{type} eq 'file') { | |
567 | push @pathlist, "$di->{qmdevice}=$di->{path}"; | |
568 | } else { | |
569 | die "implement me"; | |
570 | } | |
571 | } | |
572 | ||
c82935e9 DM |
573 | if (!$diskcount) { |
574 | $self->loginfo("backup contains no disks"); | |
575 | } | |
576 | ||
23b4120b DM |
577 | my $outcmd; |
578 | if ($comp) { | |
874a096e | 579 | $outcmd = "exec:$comp"; |
23b4120b | 580 | } else { |
874a096e | 581 | $outcmd = "exec:cat"; |
23b4120b DM |
582 | } |
583 | ||
a2fab11a | 584 | $outcmd .= " > $filename" if !$opts->{stdout}; |
23b4120b | 585 | |
c05f7f3f WL |
586 | my $cmd = ['/usr/bin/vma', 'create', '-v', '-c', $conffile]; |
587 | push @$cmd, '-c', $firewall if -e $firewall; | |
588 | push @$cmd, $outcmd, @pathlist; | |
23b4120b DM |
589 | |
590 | $self->loginfo("starting template backup"); | |
591 | $self->loginfo(join(' ', @$cmd)); | |
592 | ||
593 | if ($opts->{stdout}) { | |
6bb12239 | 594 | $self->cmd($cmd, output => ">&" . fileno($opts->{stdout})); |
23b4120b DM |
595 | } else { |
596 | $self->cmd($cmd); | |
597 | } | |
598 | ||
599 | return; | |
600 | } | |
601 | ||
81dcd479 | 602 | my $devlist = _get_task_devlist($task); |
1e3baf05 | 603 | |
0b2f574b | 604 | $self->enforce_vm_running_for_backup($vmid); |
91bd6c90 DM |
605 | |
606 | my $cpid; | |
d2cc2cbe DM |
607 | my $backup_job_uuid; |
608 | ||
91bd6c90 DM |
609 | eval { |
610 | $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub { | |
d11e91d2 | 611 | die "interrupted by signal\n"; |
91bd6c90 DM |
612 | }; |
613 | ||
91bd6c90 DM |
614 | my $outfh; |
615 | if ($opts->{stdout}) { | |
616 | $outfh = $opts->{stdout}; | |
617 | } else { | |
618 | $outfh = IO::File->new($filename, "w") || | |
619 | die "unable to open file '$filename' - $!\n"; | |
620 | } | |
02da0c65 | 621 | my $outfileno = fileno($outfh); |
91bd6c90 | 622 | |
91bd6c90 | 623 | if ($comp) { |
02da0c65 | 624 | ($cpid, $outfileno) = $fork_compressor_pipe->($self, $comp, $outfileno); |
91bd6c90 DM |
625 | } |
626 | ||
e8705fc5 TL |
627 | my $qmpclient = PVE::QMPClient->new(); |
628 | my $backup_cb = sub { | |
629 | my ($vmid, $resp) = @_; | |
630 | $backup_job_uuid = $resp->{return}->{UUID}; | |
631 | }; | |
632 | my $add_fd_cb = sub { | |
91bd6c90 DM |
633 | my ($vmid, $resp) = @_; |
634 | ||
c05f7f3f WL |
635 | my $params = { |
636 | 'backup-file' => "/dev/fdname/backup", | |
637 | speed => $speed, | |
638 | 'config-file' => $conffile, | |
639 | devlist => $devlist | |
640 | }; | |
c05f7f3f | 641 | $params->{'firewall-file'} = $firewall if -e $firewall; |
d11e91d2 | 642 | |
c05f7f3f | 643 | $qmpclient->queue_cmd($vmid, $backup_cb, 'backup', %$params); |
91bd6c90 DM |
644 | }; |
645 | ||
d11e91d2 | 646 | $qmpclient->queue_cmd($vmid, $add_fd_cb, 'getfd', fd => $outfileno, fdname => "backup"); |
ab6a9a0c | 647 | |
cb521f2d | 648 | my $fs_frozen = $self->qga_fs_freeze($task, $vmid); |
874a096e | 649 | |
c5983223 | 650 | eval { $qmpclient->queue_execute(30) }; |
f0f30448 | 651 | my $qmperr = $@; |
91bd6c90 | 652 | |
1ece829a TL |
653 | if ($fs_frozen) { |
654 | $self->qga_fs_thaw($vmid); | |
ab6a9a0c | 655 | } |
d11e91d2 | 656 | |
f0f30448 | 657 | die $qmperr if $qmperr; |
874a096e | 658 | die $qmpclient->{errors}->{$vmid} if $qmpclient->{errors}->{$vmid}; |
91bd6c90 DM |
659 | |
660 | if ($cpid) { | |
874a096e | 661 | POSIX::close($outfileno) == 0 || |
91bd6c90 DM |
662 | die "close output file handle failed\n"; |
663 | } | |
664 | ||
d2cc2cbe | 665 | die "got no uuid for backup task\n" if !defined($backup_job_uuid); |
91bd6c90 | 666 | |
d2cc2cbe | 667 | $self->loginfo("started backup task '$backup_job_uuid'"); |
91bd6c90 | 668 | |
0b2f574b | 669 | $self->resume_vm_after_job_start($task, $vmid); |
91bd6c90 | 670 | |
d2cc2cbe | 671 | $query_backup_status_loop->($self, $vmid, $backup_job_uuid); |
91bd6c90 DM |
672 | }; |
673 | my $err = $@; | |
19599cd9 | 674 | if ($err) { |
60635a57 | 675 | $self->logerr($err); |
0b2f574b | 676 | $self->mon_backup_cancel($vmid) if defined($backup_job_uuid); |
19599cd9 DM |
677 | } |
678 | ||
0b2f574b | 679 | $self->restore_vm_power_state($vmid); |
91bd6c90 DM |
680 | |
681 | if ($err) { | |
874a096e DM |
682 | if ($cpid) { |
683 | kill(9, $cpid); | |
91bd6c90 DM |
684 | waitpid($cpid, 0); |
685 | } | |
686 | die $err; | |
687 | } | |
688 | ||
689 | if ($cpid && (waitpid($cpid, 0) > 0)) { | |
690 | my $stat = $?; | |
691 | my $ec = $stat >> 8; | |
692 | my $signal = $stat & 127; | |
693 | if ($ec || $signal) { | |
874a096e | 694 | die "$comp failed - wrong exit status $ec" . |
91bd6c90 DM |
695 | ($signal ? " (signal $signal)\n" : "\n"); |
696 | } | |
697 | } | |
698 | } | |
699 | ||
81dcd479 TL |
700 | sub _get_task_devlist { |
701 | my ($task) = @_; | |
702 | ||
703 | my $devlist = ''; | |
704 | foreach my $di (@{$task->{disks}}) { | |
705 | if ($di->{type} eq 'block' || $di->{type} eq 'file') { | |
706 | $devlist .= ',' if $devlist; | |
707 | $devlist .= $di->{qmdevice}; | |
708 | } else { | |
709 | die "implement me (type '$di->{type}')"; | |
710 | } | |
711 | } | |
712 | return $devlist; | |
713 | } | |
714 | ||
1ece829a | 715 | sub qga_fs_freeze { |
cb521f2d TL |
716 | my ($self, $task, $vmid) = @_; |
717 | return if !$self->{vmlist}->{$vmid}->{agent} || $task->{mode} eq 'stop' || !$self->{vm_was_running}; | |
1ece829a TL |
718 | |
719 | if (!PVE::QemuServer::qga_check_running($vmid, 1)) { | |
720 | $self->loginfo("skipping guest-agent 'fs-freeze', agent configured but not running?"); | |
721 | return; | |
722 | } | |
723 | ||
724 | $self->loginfo("issuing guest-agent 'fs-freeze' command"); | |
725 | eval { mon_cmd($vmid, "guest-fsfreeze-freeze") }; | |
726 | $self->logerr($@) if $@; | |
727 | ||
728 | return 1; # even on mon command error, ensure we always thaw again | |
729 | } | |
730 | ||
731 | # only call if fs_freeze return 1 | |
732 | sub qga_fs_thaw { | |
733 | my ($self, $vmid) = @_; | |
734 | ||
735 | $self->loginfo("issuing guest-agent 'fs-thaw' command"); | |
736 | eval { mon_cmd($vmid, "guest-fsfreeze-thaw") }; | |
737 | $self->logerr($@) if $@; | |
738 | } | |
739 | ||
0b2f574b TL |
740 | # we need a running QEMU/KVM process for backup, starts a paused (prelaunch) |
741 | # one if VM isn't already running | |
742 | sub enforce_vm_running_for_backup { | |
743 | my ($self, $vmid) = @_; | |
744 | ||
745 | if (PVE::QemuServer::check_running($vmid)) { | |
746 | $self->{vm_was_running} = 1; | |
747 | return; | |
748 | } | |
749 | ||
750 | eval { | |
751 | $self->loginfo("starting kvm to execute backup task"); | |
752 | # start with skiplock | |
0c498cca FG |
753 | my $params = { |
754 | skiplock => 1, | |
755 | paused => 1, | |
756 | }; | |
757 | PVE::QemuServer::vm_start($self->{storecfg}, $vmid, $params); | |
0b2f574b TL |
758 | }; |
759 | die $@ if $@; | |
760 | } | |
761 | ||
762 | # resume VM againe once we got in a clear state (stop mode backup of running VM) | |
763 | sub resume_vm_after_job_start { | |
764 | my ($self, $task, $vmid) = @_; | |
765 | ||
766 | return if !$self->{vm_was_running}; | |
767 | ||
768 | if (my $stoptime = $task->{vmstoptime}) { | |
769 | my $delay = time() - $task->{vmstoptime}; | |
770 | $task->{vmstoptime} = undef; # avoid printing 'online after ..' twice | |
771 | $self->loginfo("resuming VM again after $delay seconds"); | |
772 | } else { | |
773 | $self->loginfo("resuming VM again"); | |
774 | } | |
775 | mon_cmd($vmid, 'cont'); | |
776 | } | |
777 | ||
778 | # stop again if VM was not running before | |
779 | sub restore_vm_power_state { | |
780 | my ($self, $vmid) = @_; | |
781 | ||
782 | # we always let VMs keep running | |
783 | return if $self->{vm_was_running}; | |
784 | ||
785 | eval { | |
786 | my $resp = mon_cmd($vmid, 'query-status'); | |
787 | my $status = $resp && $resp->{status} ? $resp->{status} : 'unknown'; | |
788 | if ($status eq 'prelaunch') { | |
789 | $self->loginfo("stopping kvm after backup task"); | |
790 | PVE::QemuServer::vm_stop($self->{storecfg}, $vmid, 1); | |
791 | } else { | |
792 | $self->loginfo("kvm status changed after backup ('$status') - keep VM running"); | |
793 | } | |
794 | }; | |
795 | warn $@ if $@; | |
796 | } | |
797 | ||
798 | sub mon_backup_cancel { | |
799 | my ($self, $vmid) = @_; | |
800 | ||
801 | $self->loginfo("aborting backup job"); | |
802 | eval { mon_cmd($vmid, 'backup-cancel') }; | |
803 | $self->logerr($@) if $@; | |
804 | } | |
805 | ||
91bd6c90 DM |
806 | sub snapshot { |
807 | my ($self, $task, $vmid) = @_; | |
808 | ||
809 | # nothing to do | |
1e3baf05 DM |
810 | } |
811 | ||
812 | sub cleanup { | |
813 | my ($self, $task, $vmid) = @_; | |
814 | ||
91bd6c90 | 815 | # nothing to do ? |
1e3baf05 DM |
816 | } |
817 | ||
818 | 1; |