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;
  12 use PVE::QemuServer;
  13 use IO::File;
  14
  15 use base qw (PVE::VZDump::Plugin);
  16
  17 sub new {
  18     my ($class, $vzdump) = @_;
  19
  20     PVE::VZDump::check_bin('qm');
  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
  46     my $conf = $self->{vmlist}->{$vmid} = PVE::QemuServer::load_config($vmid);
  47
  48     $task->{hostname} = $conf->{name};
  49
  50     my $lvmmap = PVE::VZDump::get_lvm_mapping();
  51
  52     my $hostname = PVE::INotify::nodename();
  53
  54     my $ind = {};
  55     my $mountinfo = {};
  56     my $mountind = 0;
  57
  58     my $snapshot_count = 0;
  59
  60     my $vollist = [];
  61     my $drivehash = {};
  62     PVE::QemuServer::foreach_drive($conf, sub {
  63         my ($ds, $drive) = @_;
  64
  65         return if PVE::QemuServer::drive_is_cdrom ($drive);
  66
  67         if (defined($drive->{backup}) && $drive->{backup} eq "no") {
  68             $self->loginfo("exclude disk '$ds' (backup=no)");
  69             return;
  70         }
  71
  72         my $volid = $drive->{file};
  73
  74         my ($storeid, $volname) = PVE::Storage::parse_volume_id ($volid, 1);
  75         push @$vollist, $volid if $storeid;
  76         $drivehash->{$ds} = $drive;
  77     });
  78
  79     PVE::Storage::activate_volumes($self->{storecfg}, $vollist);
  80
  81     while (my ($ds, $drive) = each %$drivehash) {
  82
  83         my $volid = $drive->{file};
  84
  85         my $path;
  86
  87         my ($storeid, $volname) = PVE::Storage::parse_volume_id ($volid, 1);
  88         if ($storeid) {
  89             $path = PVE::Storage::path($self->{storecfg}, $volid);
  90         } else {
  91             $path = $volid;
  92         }
  93
  94         next if !$path;
  95
  96         die "no such volume '$volid'\n" if ! -e $path;
  97
  98         my $diskinfo = { path => $path , volid => $volid, storeid => $storeid,
  99                          snappath => $path, virtdev => $ds };
 100
 101         if (-b $path) {
 102
 103             $diskinfo->{type} = 'block';
 104
 105             $diskinfo->{filename} = "vm-disk-$ds.raw";
 106
 107             if ($mode eq 'snapshot') {
 108                 my ($lvmvg, $lvmlv) = @{$lvmmap->{$path}} if defined ($lvmmap->{$path});
 109                 die ("mode failure - unable to detect lvm volume group\n") if !$lvmvg;
 110
 111                 $ind->{$lvmvg} = 0 if !defined $ind->{$lvmvg};
 112                 $diskinfo->{snapname} = "vzsnap-$hostname-$ind->{$lvmvg}";
 113                 $diskinfo->{snapdev} = "/dev/$lvmvg/$diskinfo->{snapname}";
 114                 $diskinfo->{lvmvg} = $lvmvg;
 115                 $diskinfo->{lvmlv} = $lvmlv;
 116                 $diskinfo->{snappath} = $diskinfo->{snapdev};
 117                 $ind->{$lvmvg}++;
 118
 119                 $snapshot_count++;
 120             }
 121
 122         } else {
 123
 124             $diskinfo->{type} = 'file';
 125
 126             my (undef, $dir, $ext) = fileparse ($path, qr/\.[^.]*/);
 127
 128             $diskinfo->{filename} = "vm-disk-$ds$ext";
 129
 130             if ($mode eq 'snapshot') {
 131
 132                 my ($srcdev, $lvmpath, $lvmvg, $lvmlv, $fstype) =
 133                     PVE::VZDump::get_lvm_device ($dir, $lvmmap);
 134
 135                 my $targetdev = PVE::VZDump::get_lvm_device ($task->{dumpdir}, $lvmmap);
 136
 137                 die ("mode failure - unable to detect lvm volume group\n") if !$lvmvg;
 138                 die ("mode failure - wrong lvm mount point '$lvmpath'\n") if $dir !~ m|/?$lvmpath/?|;
 139                 die ("mode failure - unable to dump into snapshot (use option --dumpdir)\n")
 140                     if $targetdev eq $srcdev;
 141
 142                 $ind->{$lvmvg} = 0 if !defined $ind->{$lvmvg};
 143
 144                 my $info = $mountinfo->{$lvmpath};
 145                 if (!$info) {
 146                     my $snapname = "vzsnap-$hostname-$ind->{$lvmvg}";
 147                     my $snapdev = "/dev/$lvmvg/$snapname";
 148                     $mountinfo->{$lvmpath} = $info = {
 149                         snapdev => $snapdev,
 150                         snapname => $snapname,
 151                         mountpoint => "/mnt/vzsnap$mountind",
 152                     };
 153                     $ind->{$lvmvg}++;
 154                     $mountind++;
 155
 156                     $snapshot_count++;
 157                 }
 158
 159                 $diskinfo->{snapdev} = $info->{snapdev};
 160                 $diskinfo->{snapname} = $info->{snapname};
 161                 $diskinfo->{mountpoint} = $info->{mountpoint};
 162
 163                 $diskinfo->{lvmvg} = $lvmvg;
 164                 $diskinfo->{lvmlv} = $lvmlv;
 165
 166                 $diskinfo->{fstype}  = $fstype;
 167                 $diskinfo->{lvmpath} = $lvmpath;
 168
 169                 $diskinfo->{snappath} = $path;
 170                 $diskinfo->{snappath} =~ s|/?$lvmpath/?|$diskinfo->{mountpoint}/|;
 171             }
 172         }
 173
 174         push @{$task->{disks}}, $diskinfo;
 175     }
 176
 177     $task->{snapshot_count} = $snapshot_count;
 178 }
 179
 180 sub vm_status {
 181     my ($self, $vmid) = @_;
 182
 183     my $running = PVE::QemuServer::check_running($vmid) ? 1 : 0;
 184
 185     return wantarray ? ($running, $running ? 'running' : 'stopped') : $running;
 186 }
 187
 188 sub lock_vm {
 189     my ($self, $vmid) = @_;
 190
 191     $self->cmd ("qm set $vmid --lock backup");
 192 }
 193
 194 sub unlock_vm {
 195     my ($self, $vmid) = @_;
 196
 197     $self->cmd ("qm unlock $vmid");
 198 }
 199
 200 sub stop_vm {
 201     my ($self, $task, $vmid) = @_;
 202
 203     my $opts = $self->{vzdump}->{opts};
 204
 205     my $wait = $opts->{stopwait} * 60;
 206     # send shutdown and wait
 207     $self->cmd ("qm shutdown $vmid --skiplock --keepActive --timeout $wait");
 208 }
 209
 210 sub start_vm {
 211     my ($self, $task, $vmid) = @_;
 212
 213     $self->cmd ("qm start $vmid --skiplock");
 214 }
 215
 216 sub suspend_vm {
 217     my ($self, $task, $vmid) = @_;
 218
 219     $self->cmd ("qm suspend $vmid --skiplock");
 220 }
 221
 222 sub resume_vm {
 223     my ($self, $task, $vmid) = @_;
 224
 225     $self->cmd ("qm resume $vmid --skiplock");
 226 }
 227
 228 sub snapshot_alloc {
 229     my ($self, $storeid, $name, $size, $srcdev) = @_;
 230
 231     my $cmd = "lvcreate --size ${size}M --snapshot --name '$name' '$srcdev'";
 232
 233     if ($storeid) {
 234
 235         my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid);
 236
 237         # lock shared storage
 238         return PVE::Storage::cluster_lock_storage ($storeid, $scfg->{shared}, undef, sub {
 239                 $self->cmd ($cmd);
 240         });
 241     } else {
 242         $self->cmd ($cmd);
 243     }
 244 }
 245
 246 sub snapshot_free {
 247     my ($self, $storeid, $name, $snapdev, $noerr) = @_;
 248
 249     my $cmd = ['lvremove', '-f', $snapdev];
 250
 251     # loop, because we often get 'LV in use: not deactivating'
 252     # we use run_command() because we do not want to log errors here
 253     my $wait = 1;
 254     while(-b $snapdev) {
 255         eval {
 256             if ($storeid) {
 257                 my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid);
 258                 # lock shared storage
 259                 return PVE::Storage::cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
 260                     PVE::Tools::run_command($cmd, outfunc => sub {}, errfunc => sub {});
 261                 });
 262             } else {
 263                 PVE::Tools::run_command($cmd, outfunc => sub {}, errfunc => sub {});
 264             }
 265         };
 266         my $err = $@;
 267         last if !$err;
 268         if ($wait >= 64) {
 269             $self->logerr($err);
 270             die $@ if !$noerr;
 271             last;
 272         }
 273         $self->loginfo("lvremove failed - trying again in $wait seconds") if $wait >= 8;
 274         sleep($wait);
 275         $wait = $wait*2;
 276     }
 277 }
 278
 279 sub snapshot {
 280     my ($self, $task, $vmid) = @_;
 281
 282     my $opts = $self->{vzdump}->{opts};
 283
 284     my $mounts = {};
 285
 286     foreach my $di (@{$task->{disks}}) {
 287         if ($di->{type} eq 'block') {
 288
 289             if (-b $di->{snapdev}) {
 290                 $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'");
 291                 $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 292             }
 293
 294             $di->{cleanup_lvm} = 1;
 295             $self->snapshot_alloc ($di->{storeid}, $di->{snapname}, $opts->{size},
 296                                    "/dev/$di->{lvmvg}/$di->{lvmlv}");
 297
 298         } elsif ($di->{type} eq 'file') {
 299
 300             next if defined ($mounts->{$di->{mountpoint}}); # already mounted
 301
 302             if (-b $di->{snapdev}) {
 303                 $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'");
 304
 305                 $self->cmd_noerr ("umount $di->{mountpoint}");
 306                 $self->snapshot_free ($di->{storeid}, $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->{storeid}, $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 -n -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, $comp) = @_;
 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
 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
 405     my $files = join (' ', map { "'$_'" } @filea);
 406
 407     # no sparse file scan when we use compression
 408     my $sparse = $comp ? '' : '-s';
 409
 410     my $cmd = "/usr/lib/qemu-server/vmtar $sparse $files";
 411     my $bwl = $opts->{bwlimit}*1024; # bandwidth limit for cstream
 412     $cmd .= "|cstream -t $bwl" if $opts->{bwlimit};
 413     $cmd .= "|$comp" if $comp;
 414
 415     if ($opts->{stdout}) {
 416         $self->cmd ($cmd, output => ">&=" . fileno($opts->{stdout}));
 417     } else {
 418         $self->cmd ("$cmd >$filename");
 419     }
 420 }
 421
 422 sub cleanup {
 423     my ($self, $task, $vmid) = @_;
 424
 425    foreach my $di (@{$task->{disks}}) {
 426
 427        if ($di->{snapshot_mount}) {
 428            $self->cmd_noerr ("umount $di->{mountpoint}");
 429        }
 430
 431        if ($di->{cleanup_lvm}) {
 432            if (-b $di->{snapdev}) {
 433                if ($di->{type} eq 'block') {
 434                    $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 435                } elsif ($di->{type} eq 'file') {
 436                    $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 437                }
 438            }
 439        }
 440    }
 441 }
 442
 443 1;