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     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
 172     my $running = PVE::QemuServer::check_running($vmid) ? 1 : 0;
 173
 174     return wantarray ? ($running, $running ? 'running' : 'stopped') : $running;
 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
 186     $self->cmd ("qm unlock $vmid");
 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
 196     $self->cmd ("qm shutdown $vmid --skiplock --timeout $wait");
 197 }
 198
 199 sub start_vm {
 200     my ($self, $task, $vmid) = @_;
 201
 202     $self->cmd ("qm start $vmid --skiplock");
 203 }
 204
 205 sub suspend_vm {
 206     my ($self, $task, $vmid) = @_;
 207
 208     $self->cmd ("qm suspend $vmid --skiplock");
 209 }
 210
 211 sub resume_vm {
 212     my ($self, $task, $vmid) = @_;
 213
 214     $self->cmd ("qm resume $vmid --skiplock");
 215 }
 216
 217 sub snapshot_alloc {
 218     my ($self, $storeid, $name, $size, $srcdev) = @_;
 219
 220     my $cmd = "lvcreate --size ${size}M --snapshot --name '$name' '$srcdev'";
 221
 222     if ($storeid) {
 223
 224         my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid);
 225
 226         # lock shared storage
 227         return PVE::Storage::cluster_lock_storage ($storeid, $scfg->{shared}, undef, sub {
 228                 $self->cmd ($cmd);
 229         });
 230     } else {
 231         $self->cmd ($cmd);
 232     }
 233 }
 234
 235 sub snapshot_free {
 236     my ($self, $storeid, $name, $snapdev, $noerr) = @_;
 237
 238     my $cmd = ['lvremove', '-f', $snapdev];
 239
 240     # loop, because we often get 'LV in use: not deactivating'
 241     # we use run_command() because we do not want to log errors here
 242     my $wait = 1;
 243     while(-b $snapdev) {
 244         eval {
 245             if ($storeid) {
 246                 my $scfg = PVE::Storage::storage_config ($self->{storecfg}, $storeid);
 247                 # lock shared storage
 248                 return PVE::Storage::cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
 249                     PVE::Tools::run_command($cmd, outfunc => sub {}, errfunc => {});
 250                 });
 251             } else {
 252                 PVE::Tools::run_command($cmd, outfunc => sub {}, errfunc => {});
 253             }
 254         };
 255         my $err = $@;
 256         last if !$err;
 257         if ($wait >= 64) {
 258             $self->logerr($err);
 259             die $@ if !$noerr;
 260             last;
 261         }
 262         $self->loginfo("lvremove failed - trying again in $wait seconds") if $wait >= 8;
 263         sleep($wait);
 264         $wait = $wait*2;
 265     }
 266 }
 267
 268 sub snapshot {
 269     my ($self, $task, $vmid) = @_;
 270
 271     my $opts = $self->{vzdump}->{opts};
 272
 273     my $mounts = {};
 274
 275     foreach my $di (@{$task->{disks}}) {
 276         if ($di->{type} eq 'block') {
 277
 278             if (-b $di->{snapdev}) {
 279                 $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'");
 280                 $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 281             }
 282
 283             $di->{cleanup_lvm} = 1;
 284             $self->snapshot_alloc ($di->{storeid}, $di->{snapname}, $opts->{size},
 285                                    "/dev/$di->{lvmvg}/$di->{lvmlv}");
 286
 287         } elsif ($di->{type} eq 'file') {
 288
 289             next if defined ($mounts->{$di->{mountpoint}}); # already mounted
 290
 291             if (-b $di->{snapdev}) {
 292                 $self->loginfo ("trying to remove stale snapshot '$di->{snapdev}'");
 293
 294                 $self->cmd_noerr ("umount $di->{mountpoint}");
 295                 $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 296             }
 297
 298             mkpath $di->{mountpoint}; # create mount point for lvm snapshot
 299
 300             $di->{cleanup_lvm} = 1;
 301
 302             $self->snapshot_alloc ($di->{storeid}, $di->{snapname}, $opts->{size},
 303                                    "/dev/$di->{lvmvg}/$di->{lvmlv}");
 304
 305             my $mopts = $di->{fstype} eq 'xfs' ? "-o nouuid" : '';
 306
 307             $di->{snapshot_mount} = 1;
 308
 309             $self->cmd ("mount -t $di->{fstype} $mopts $di->{snapdev} $di->{mountpoint}");
 310
 311             $mounts->{$di->{mountpoint}} = 1;
 312
 313         } else {
 314             die "implement me";
 315         }
 316     }
 317 }
 318
 319 sub get_size {
 320     my $path = shift;
 321
 322     if (-f $path) {
 323         return -s $path;
 324     } elsif (-b $path) {
 325         my $fh = IO::File->new ($path, "r");
 326         die "unable to open '$path' to detect device size\n" if !$fh;
 327         my $size = sysseek $fh, 0, 2;
 328         $fh->close();
 329         die "unable to detect device size for '$path'\n" if !$size;
 330         return $size;
 331     }
 332 }
 333
 334 sub assemble {
 335     my ($self, $task, $vmid) = @_;
 336
 337     my $conffile = PVE::QemuServer::config_file ($vmid);
 338
 339     my $outfile = "$task->{tmpdir}/qemu-server.conf";
 340
 341     my $outfd;
 342     my $conffd;
 343
 344     eval {
 345
 346         $outfd = IO::File->new (">$outfile") ||
 347             die "unable to open '$outfile'";
 348         $conffd = IO::File->new ($conffile, 'r') ||
 349             die "unable open '$conffile'";
 350
 351         while (defined (my $line = <$conffd>)) {
 352             next if $line =~ m/^\#vzdump\#/; # just to be sure
 353             print $outfd $line;
 354         }
 355
 356         foreach my $di (@{$task->{disks}}) {
 357             if ($di->{type} eq 'block' || $di->{type} eq 'file') {
 358                 my $size = get_size ($di->{snappath});
 359                 my $storeid = $di->{storeid} || '';
 360                 print $outfd "#vzdump#map:$di->{virtdev}:$di->{filename}:$size:$storeid:\n";
 361             } else {
 362                 die "internal error";
 363             }
 364         }
 365     };
 366     my $err = $@;
 367
 368     close ($outfd) if $outfd;
 369     close ($conffd) if $conffd;
 370
 371     die $err if $err;
 372 }
 373
 374 sub archive {
 375     my ($self, $task, $vmid, $filename) = @_;
 376
 377     my $conffile = "$task->{tmpdir}/qemu-server.conf";
 378
 379     my $opts = $self->{vzdump}->{opts};
 380
 381     my $starttime = time ();
 382
 383     my $fh;
 384
 385     my @filea = ($conffile, 'qemu-server.conf'); # always first file in tar
 386     foreach my $di (@{$task->{disks}}) {
 387         if ($di->{type} eq 'block' || $di->{type} eq 'file') {
 388             push @filea, $di->{snappath}, $di->{filename};
 389         } else {
 390             die "implement me";
 391         }
 392     }
 393
 394     my $files = join (' ', map { "'$_'" } @filea);
 395
 396     my $cmd = "/usr/lib/qemu-server/vmtar $files";
 397     my $bwl = $opts->{bwlimit}*1024; # bandwidth limit for cstream
 398     $cmd .= "|cstream -t $bwl" if $opts->{bwlimit};
 399     $cmd .= "|gzip" if $opts->{compress};
 400
 401     if ($opts->{stdout}) {
 402         $self->cmd ($cmd, output => ">&=" . fileno($opts->{stdout}));
 403     } else {
 404         $self->cmd ("$cmd >$filename");
 405     }
 406 }
 407
 408 sub cleanup {
 409     my ($self, $task, $vmid) = @_;
 410
 411    foreach my $di (@{$task->{disks}}) {
 412
 413        if ($di->{snapshot_mount}) {
 414            $self->cmd_noerr ("umount $di->{mountpoint}");
 415        }
 416
 417        if ($di->{cleanup_lvm}) {
 418            if (-b $di->{snapdev}) {
 419                if ($di->{type} eq 'block') {
 420                    $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 421                } elsif ($di->{type} eq 'file') {
 422                    $self->snapshot_free ($di->{storeid}, $di->{snapname}, $di->{snapdev}, 1);
 423                }
 424            }
 425        }
 426    }
 427 }
 428
 429 1;