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