PVE/VZDump/QemuServer.pm

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