]>
Commit | Line | Data |
---|---|---|
1e3baf05 DM |
1 | package PVE::VZDump::QemuServer; |
2 | ||
1e3baf05 DM |
3 | use strict; |
4 | use warnings; | |
5 | use File::Path; | |
6 | use File::Basename; | |
66ab1d91 | 7 | use PVE::INotify; |
1e3baf05 | 8 | use PVE::VZDump; |
3e16d5fc DM |
9 | use PVE::Cluster qw(cfs_read_file); |
10 | use PVE::Tools; | |
1e3baf05 DM |
11 | use PVE::Storage; |
12 | use PVE::QemuServer; | |
1e3baf05 DM |
13 | use IO::File; |
14 | ||
15 | use base qw (PVE::VZDump::Plugin); | |
16 | ||
17 | sub new { | |
18 | my ($class, $vzdump) = @_; | |
19 | ||
66ab1d91 | 20 | PVE::VZDump::check_bin('qm'); |
1e3baf05 DM |
21 | |
22 | my $self = bless { vzdump => $vzdump }; | |
23 | ||
24 | $self->{vmlist} = PVE::QemuServer::vzlist(); | |
25 | $self->{storecfg} = PVE::Storage::config(); | |
26 | ||
27 | return $self; | |
28 | }; | |
29 | ||
30 | ||
31 | sub type { | |
32 | return 'qemu'; | |
33 | } | |
34 | ||
35 | sub vmlist { | |
36 | my ($self) = @_; | |
37 | ||
38 | return [ keys %{$self->{vmlist}} ]; | |
39 | } | |
40 | ||
41 | sub prepare { | |
42 | my ($self, $task, $vmid, $mode) = @_; | |
43 | ||
44 | $task->{disks} = []; | |
45 | ||
66ab1d91 | 46 | my $conf = $self->{vmlist}->{$vmid} = PVE::QemuServer::load_config($vmid); |
1e3baf05 DM |
47 | |
48 | $task->{hostname} = $conf->{name}; | |
49 | ||
50 | my $lvmmap = PVE::VZDump::get_lvm_mapping(); | |
51 | ||
66ab1d91 | 52 | my $hostname = PVE::INotify::nodename(); |
1e3baf05 DM |
53 | |
54 | my $ind = {}; | |
55 | my $mountinfo = {}; | |
56 | my $mountind = 0; | |
57 | ||
58 | my $snapshot_count = 0; | |
59 | ||
60 | PVE::QemuServer::foreach_drive($conf, sub { | |
61 | my ($ds, $drive) = @_; | |
62 | ||
63 | return if PVE::QemuServer::drive_is_cdrom ($drive); | |
64 | ||
65 | if (defined($drive->{backup}) && $drive->{backup} eq "no") { | |
66 | $self->loginfo("exclude disk '$ds' (backup=no)"); | |
67 | return; | |
68 | } | |
69 | ||
70 | my $volid = $drive->{file}; | |
71 | ||
72 | my $path; | |
73 | ||
74 | my ($storeid, $volname) = PVE::Storage::parse_volume_id ($volid, 1); | |
75 | if ($storeid) { | |
76 | PVE::Storage::activate_storage ($self->{storecfg}, $storeid); | |
77 | $path = PVE::Storage::path ($self->{storecfg}, $volid); | |
78 | } else { | |
79 | $path = $volid; | |
80 | } | |
81 | ||
82 | return if !$path; | |
83 | ||
84 | die "no such volume '$volid'\n" if ! -e $path; | |
85 | ||
86 | my $diskinfo = { path => $path , volid => $volid, storeid => $storeid, | |
87 | snappath => $path, virtdev => $ds }; | |
88 | ||
89 | if (-b $path) { | |
90 | ||
91 | $diskinfo->{type} = 'block'; | |
92 | ||
93 | $diskinfo->{filename} = "vm-disk-$ds.raw"; | |
94 | ||
95 | if ($mode eq 'snapshot') { | |
96 | my ($lvmvg, $lvmlv) = @{$lvmmap->{$path}} if defined ($lvmmap->{$path}); | |
97 | die ("mode failure - unable to detect lvm volume group\n") if !$lvmvg; | |
98 | ||
99 | $ind->{$lvmvg} = 0 if !defined $ind->{$lvmvg}; | |
100 | $diskinfo->{snapname} = "vzsnap-$hostname-$ind->{$lvmvg}"; | |
101 | $diskinfo->{snapdev} = "/dev/$lvmvg/$diskinfo->{snapname}"; | |
102 | $diskinfo->{lvmvg} = $lvmvg; | |
103 | $diskinfo->{lvmlv} = $lvmlv; | |
104 | $diskinfo->{snappath} = $diskinfo->{snapdev}; | |
105 | $ind->{$lvmvg}++; | |
106 | ||
107 | $snapshot_count++; | |
108 | } | |
109 | ||
110 | } else { | |
111 | ||
112 | $diskinfo->{type} = 'file'; | |
113 | ||
114 | my (undef, $dir, $ext) = fileparse ($path, qr/\.[^.]*/); | |
115 | ||
116 | $diskinfo->{filename} = "vm-disk-$ds$ext"; | |
117 | ||
118 | if ($mode eq 'snapshot') { | |
119 | ||
120 | my ($srcdev, $lvmpath, $lvmvg, $lvmlv, $fstype) = | |
121 | PVE::VZDump::get_lvm_device ($dir, $lvmmap); | |
122 | ||
123 | my $targetdev = PVE::VZDump::get_lvm_device ($task->{dumpdir}, $lvmmap); | |
124 | ||
125 | die ("mode failure - unable to detect lvm volume group\n") if !$lvmvg; | |
126 | die ("mode failure - wrong lvm mount point '$lvmpath'\n") if $dir !~ m|/?$lvmpath/?|; | |
127 | die ("mode failure - unable to dump into snapshot (use option --dumpdir)\n") | |
128 | if $targetdev eq $srcdev; | |
129 | ||
130 | $ind->{$lvmvg} = 0 if !defined $ind->{$lvmvg}; | |
131 | ||
132 | my $info = $mountinfo->{$lvmpath}; | |
133 | if (!$info) { | |
134 | my $snapname = "vzsnap-$hostname-$ind->{$lvmvg}"; | |
135 | my $snapdev = "/dev/$lvmvg/$snapname"; | |
136 | $mountinfo->{$lvmpath} = $info = { | |
137 | snapdev => $snapdev, | |
138 | snapname => $snapname, | |
139 | mountpoint => "/mnt/vzsnap$mountind", | |
140 | }; | |
141 | $ind->{$lvmvg}++; | |
142 | $mountind++; | |
143 | ||
144 | $snapshot_count++; | |
145 | } | |
146 | ||
147 | $diskinfo->{snapdev} = $info->{snapdev}; | |
148 | $diskinfo->{snapname} = $info->{snapname}; | |
149 | $diskinfo->{mountpoint} = $info->{mountpoint}; | |
150 | ||
151 | $diskinfo->{lvmvg} = $lvmvg; | |
152 | $diskinfo->{lvmlv} = $lvmlv; | |
153 | ||
154 | $diskinfo->{fstype} = $fstype; | |
155 | $diskinfo->{lvmpath} = $lvmpath; | |
156 | ||
157 | $diskinfo->{snappath} = $path; | |
158 | $diskinfo->{snappath} =~ s|/?$lvmpath/?|$diskinfo->{mountpoint}/|; | |
159 | } | |
160 | } | |
161 | ||
162 | push @{$task->{disks}}, $diskinfo; | |
163 | ||
164 | }); | |
165 | ||
166 | $task->{snapshot_count} = $snapshot_count; | |
167 | } | |
168 | ||
169 | sub vm_status { | |
170 | my ($self, $vmid) = @_; | |
171 | ||
66ab1d91 DM |
172 | my $running = PVE::QemuServer::check_running($vmid) ? 1 : 0; |
173 | ||
174 | return wantarray ? ($running, $running ? 'running' : 'stopped') : $running; | |
1e3baf05 DM |
175 | } |
176 | ||
177 | sub lock_vm { | |
178 | my ($self, $vmid) = @_; | |
179 | ||
180 | $self->cmd ("qm set $vmid --lock backup"); | |
181 | } | |
182 | ||
183 | sub unlock_vm { | |
184 | my ($self, $vmid) = @_; | |
185 | ||
66ab1d91 | 186 | $self->cmd ("qm unlock $vmid"); |
1e3baf05 DM |
187 | } |
188 | ||
189 | sub stop_vm { | |
190 | my ($self, $task, $vmid) = @_; | |
191 | ||
192 | my $opts = $self->{vzdump}->{opts}; | |
193 | ||
194 | my $wait = $opts->{stopwait} * 60; | |
195 | # send shutdown and wait | |
cf3298e6 | 196 | $self->cmd ("qm shutdown $vmid --skiplock && qm wait $vmid --timeout $wait"); |
1e3baf05 DM |
197 | } |
198 | ||
199 | sub start_vm { | |
200 | my ($self, $task, $vmid) = @_; | |
201 | ||
66ab1d91 | 202 | $self->cmd ("qm start $vmid --skiplock"); |
1e3baf05 DM |
203 | } |
204 | ||
205 | sub suspend_vm { | |
206 | my ($self, $task, $vmid) = @_; | |
207 | ||
66ab1d91 | 208 | $self->cmd ("qm suspend $vmid --skiplock"); |
1e3baf05 DM |
209 | } |
210 | ||
211 | sub resume_vm { | |
212 | my ($self, $task, $vmid) = @_; | |
213 | ||
66ab1d91 | 214 | $self->cmd ("qm resume $vmid --skiplock"); |
1e3baf05 DM |
215 | } |
216 | ||
217 | sub snapshot_alloc { | |
218 | my ($self, $volid, $name, $size, $srcdev) = @_; | |
219 | ||
220 | my $cmd = "lvcreate --size ${size}M --snapshot --name '$name' '$srcdev'"; | |
221 | ||
222 | my ($storeid, $volname) = PVE::Storage::parse_volume_id ($volid, 1); | |
223 | if ($storeid) { | |
224 | ||
225 | my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid); | |
226 | ||
227 | # lock shared storage | |
228 | return PVE::Storage::cluster_lock_storage ($storeid, $scfg->{shared}, undef, sub { | |
229 | ||
230 | if ($scfg->{type} eq 'lvm') { | |
231 | my $vg = $scfg->{vgname}; | |
232 | ||
233 | $self->cmd ($cmd); | |
234 | ||
235 | } else { | |
236 | die "can't allocate snapshot on storage type '$scfg->{type}'\n"; | |
237 | } | |
238 | }); | |
239 | } else { | |
240 | $self->cmd ($cmd); | |
241 | } | |
242 | } | |
243 | ||
244 | sub snapshot_free { | |
245 | my ($self, $volid, $name, $snapdev, $noerr) = @_; | |
246 | ||
247 | my $cmd = "lvremove -f '$snapdev'"; | |
248 | ||
249 | eval { | |
250 | my ($storeid, $volname) = PVE::Storage::parse_volume_id ($volid, 1); | |
251 | if ($storeid) { | |
252 | ||
253 | my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid); | |
254 | ||
255 | # lock shared storage | |
256 | return PVE::Storage::cluster_lock_storage ($storeid, $scfg->{shared}, undef, sub { | |
257 | ||
258 | if ($scfg->{type} eq 'lvm') { | |
259 | my $vg = $scfg->{vgname}; | |
260 | ||
261 | $self->cmd ($cmd); | |
262 | ||
263 | } else { | |
264 | die "can't allocate snapshot on storage type '$scfg->{type}'\n"; | |
265 | } | |
266 | }); | |
267 | } else { | |
268 | $self->cmd ($cmd); | |
269 | } | |
270 | }; | |
271 | die $@ if !$noerr; | |
272 | $self->logerr ($@) if $@; | |
273 | } | |
274 | ||
275 | sub snapshot { | |
276 | my ($self, $task, $vmid) = @_; | |
277 | ||
278 | my $opts = $self->{vzdump}->{opts}; | |
279 | ||
280 | my $mounts = {}; | |
281 | ||
282 | foreach my $di (@{$task->{disks}}) { | |
283 | if ($di->{type} eq 'block') { | |
284 | ||
285 | if (-b $di->{snapdev}) { | |
286 | $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'"); | |
287 | $self->snapshot_free ($di->{volid}, $di->{snapname}, $di->{snapdev}, 1); | |
288 | } | |
289 | ||
290 | $di->{cleanup_lvm} = 1; | |
291 | $self->snapshot_alloc ($di->{volid}, $di->{snapname}, $opts->{size}, | |
292 | "/dev/$di->{lvmvg}/$di->{lvmlv}"); | |
293 | ||
294 | } elsif ($di->{type} eq 'file') { | |
295 | ||
296 | next if defined ($mounts->{$di->{mountpoint}}); # already mounted | |
297 | ||
298 | # note: files are never on shared storage, so we use $di->{path} instead | |
299 | # of $di->{volid} (avoid PVE:Storage calls because path start with /) | |
300 | ||
301 | if (-b $di->{snapdev}) { | |
302 | $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'"); | |
303 | ||
304 | $self->cmd_noerr ("umount $di->{mountpoint}"); | |
305 | ||
306 | $self->snapshot_free ($di->{path}, $di->{snapname}, $di->{snapdev}, 1); | |
307 | } | |
308 | ||
309 | mkpath $di->{mountpoint}; # create mount point for lvm snapshot | |
310 | ||
311 | $di->{cleanup_lvm} = 1; | |
312 | ||
313 | $self->snapshot_alloc ($di->{path}, $di->{snapname}, $opts->{size}, | |
314 | "/dev/$di->{lvmvg}/$di->{lvmlv}"); | |
315 | ||
316 | my $mopts = $di->{fstype} eq 'xfs' ? "-o nouuid" : ''; | |
317 | ||
318 | $di->{snapshot_mount} = 1; | |
319 | ||
320 | $self->cmd ("mount -t $di->{fstype} $mopts $di->{snapdev} $di->{mountpoint}"); | |
321 | ||
322 | $mounts->{$di->{mountpoint}} = 1; | |
323 | ||
324 | } else { | |
325 | die "implement me"; | |
326 | } | |
327 | } | |
328 | } | |
329 | ||
330 | sub get_size { | |
331 | my $path = shift; | |
332 | ||
333 | if (-f $path) { | |
334 | return -s $path; | |
335 | } elsif (-b $path) { | |
336 | my $fh = IO::File->new ($path, "r"); | |
337 | die "unable to open '$path' to detect device size\n" if !$fh; | |
338 | my $size = sysseek $fh, 0, 2; | |
339 | $fh->close(); | |
340 | die "unable to detect device size for '$path'\n" if !$size; | |
341 | return $size; | |
342 | } | |
343 | } | |
344 | ||
345 | sub assemble { | |
346 | my ($self, $task, $vmid) = @_; | |
347 | ||
348 | my $conffile = PVE::QemuServer::config_file ($vmid); | |
349 | ||
350 | my $outfile = "$task->{tmpdir}/qemu-server.conf"; | |
351 | ||
352 | my $outfd; | |
353 | my $conffd; | |
354 | ||
355 | eval { | |
356 | ||
357 | $outfd = IO::File->new (">$outfile") || | |
358 | die "unable to open '$outfile'"; | |
359 | $conffd = IO::File->new ($conffile, 'r') || | |
360 | die "unable open '$conffile'"; | |
361 | ||
362 | while (defined (my $line = <$conffd>)) { | |
363 | next if $line =~ m/^\#vzdump\#/; # just to be sure | |
364 | print $outfd $line; | |
365 | } | |
366 | ||
367 | foreach my $di (@{$task->{disks}}) { | |
368 | if ($di->{type} eq 'block' || $di->{type} eq 'file') { | |
369 | my $size = get_size ($di->{snappath}); | |
370 | my $storeid = $di->{storeid} || ''; | |
371 | print $outfd "#vzdump#map:$di->{virtdev}:$di->{filename}:$size:$storeid:\n"; | |
372 | } else { | |
373 | die "internal error"; | |
374 | } | |
375 | } | |
376 | }; | |
377 | my $err = $@; | |
378 | ||
379 | close ($outfd) if $outfd; | |
380 | close ($conffd) if $conffd; | |
381 | ||
382 | die $err if $err; | |
383 | } | |
384 | ||
385 | sub archive { | |
386 | my ($self, $task, $vmid, $filename) = @_; | |
387 | ||
388 | my $conffile = "$task->{tmpdir}/qemu-server.conf"; | |
389 | ||
390 | my $opts = $self->{vzdump}->{opts}; | |
391 | ||
392 | my $starttime = time (); | |
393 | ||
394 | my $fh; | |
395 | ||
1e3baf05 DM |
396 | my @filea = ($conffile, 'qemu-server.conf'); # always first file in tar |
397 | foreach my $di (@{$task->{disks}}) { | |
398 | if ($di->{type} eq 'block' || $di->{type} eq 'file') { | |
399 | push @filea, $di->{snappath}, $di->{filename}; | |
400 | } else { | |
401 | die "implement me"; | |
402 | } | |
403 | } | |
404 | ||
1e3baf05 DM |
405 | my $files = join (' ', map { "'$_'" } @filea); |
406 | ||
9c502e26 DM |
407 | my $cmd = "/usr/lib/qemu-server/vmtar $files"; |
408 | my $bwl = $opts->{bwlimit}*1024; # bandwidth limit for cstream | |
409 | $cmd .= "|cstream -t $bwl" if $opts->{bwlimit}; | |
410 | $cmd .= "|gzip" if $opts->{compress}; | |
411 | ||
412 | if ($opts->{stdout}) { | |
413 | $self->cmd ($cmd, output => ">&=" . fileno($opts->{stdout})); | |
414 | } else { | |
415 | $self->cmd ("$cmd >$filename"); | |
416 | } | |
1e3baf05 DM |
417 | } |
418 | ||
419 | sub cleanup { | |
420 | my ($self, $task, $vmid) = @_; | |
421 | ||
422 | foreach my $di (@{$task->{disks}}) { | |
423 | ||
424 | if ($di->{snapshot_mount}) { | |
425 | $self->cmd_noerr ("umount $di->{mountpoint}"); | |
426 | } | |
427 | ||
428 | if ($di->{cleanup_lvm}) { | |
429 | if (-b $di->{snapdev}) { | |
430 | if ($di->{type} eq 'block') { | |
431 | $self->snapshot_free ($di->{volid}, $di->{snapname}, $di->{snapdev}, 1); | |
432 | } elsif ($di->{type} eq 'file') { | |
433 | $self->snapshot_free ($di->{path}, $di->{snapname}, $di->{snapdev}, 1); | |
434 | } | |
435 | } | |
436 | } | |
437 | } | |
1e3baf05 DM |
438 | } |
439 | ||
440 | 1; |