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::IPCC;
  10 use PVE::Cluster qw(cfs_read_file);
  11 use PVE::Tools;
  12 use PVE::Storage::Plugin;
  13 use PVE::Storage;
  14 use PVE::QemuServer;
  15 use IO::File;
  16 use IPC::Open3;
  17
  18 use base qw (PVE::VZDump::Plugin);
  19
  20 sub new {
  21     my ($class, $vzdump) = @_;
  22
  23     PVE::VZDump::check_bin('qm');
  24
  25     my $self = bless { vzdump => $vzdump };
  26
  27     $self->{vmlist} = PVE::QemuServer::vzlist();
  28     $self->{storecfg} = PVE::Storage::config();
  29
  30     return $self;
  31 };
  32
  33
  34 sub type {
  35     return 'qemu';
  36 }
  37
  38 sub vmlist {
  39     my ($self) = @_;
  40
  41     return [ keys %{$self->{vmlist}} ];
  42 }
  43
  44 sub prepare {
  45     my ($self, $task, $vmid, $mode) = @_;
  46
  47     $task->{disks} = [];
  48
  49     my $conf = $self->{vmlist}->{$vmid} = PVE::QemuConfig->load_config($vmid);
  50
  51     $self->loginfo("VM Name: $conf->{name}")
  52         if defined($conf->{name});
  53
  54     $self->{vm_was_running} = 1;
  55     if (!PVE::QemuServer::check_running($vmid)) {
  56         $self->{vm_was_running} = 0;
  57     }
  58
  59     $task->{hostname} = $conf->{name};
  60
  61     my $hostname = PVE::INotify::nodename();
  62
  63     my $vollist = [];
  64     my $drivehash = {};
  65     PVE::QemuServer::foreach_drive($conf, sub {
  66         my ($ds, $drive) = @_;
  67
  68         return if PVE::QemuServer::drive_is_cdrom($drive);
  69
  70         if (defined($drive->{backup}) && !$drive->{backup}) {
  71             $self->loginfo("exclude disk '$ds' (backup=no)");
  72             return;
  73         } elsif ($drive->{iothread}) {
  74             die "disk '$ds' (iothread=on) can't use backup feature currently. Please set backup=no for this drive";
  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     foreach my $ds (sort keys %$drivehash) {
  87         my $drive = $drivehash->{$ds};
  88
  89         my $volid = $drive->{file};
  90
  91         my $path;
  92
  93         my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
  94         if ($storeid) {
  95             $path = PVE::Storage::path($self->{storecfg}, $volid);
  96         } else {
  97             $path = $volid;
  98         }
  99
 100         next if !$path;
 101
 102         my $format = undef;
 103         my $size = undef;
 104
 105         eval{
 106             ($size, $format) = PVE::Storage::volume_size_info($self->{storecfg}, $volid, 5);
 107         };
 108         die "no such volume '$volid'\n" if $@;
 109
 110         my $diskinfo = { path => $path , volid => $volid, storeid => $storeid,
 111                          format => $format, virtdev => $ds, qmdevice => "drive-$ds" };
 112
 113         if (-b $path) {
 114             $diskinfo->{type} = 'block';
 115         } else {
 116             $diskinfo->{type} = 'file';
 117         }
 118
 119         push @{$task->{disks}}, $diskinfo;
 120     }
 121 }
 122
 123 sub vm_status {
 124     my ($self, $vmid) = @_;
 125
 126     my $running = PVE::QemuServer::check_running($vmid) ? 1 : 0;
 127
 128     return wantarray ? ($running, $running ? 'running' : 'stopped') : $running;
 129 }
 130
 131 sub lock_vm {
 132     my ($self, $vmid) = @_;
 133
 134     $self->cmd ("qm set $vmid --lock backup");
 135 }
 136
 137 sub unlock_vm {
 138     my ($self, $vmid) = @_;
 139
 140     $self->cmd ("qm unlock $vmid");
 141 }
 142
 143 sub stop_vm {
 144     my ($self, $task, $vmid) = @_;
 145
 146     my $opts = $self->{vzdump}->{opts};
 147
 148     my $wait = $opts->{stopwait} * 60;
 149     # send shutdown and wait
 150     $self->cmd ("qm shutdown $vmid --skiplock --keepActive --timeout $wait");
 151 }
 152
 153 sub start_vm {
 154     my ($self, $task, $vmid) = @_;
 155
 156     $self->cmd ("qm start $vmid --skiplock");
 157 }
 158
 159 sub suspend_vm {
 160     my ($self, $task, $vmid) = @_;
 161
 162     $self->cmd ("qm suspend $vmid --skiplock");
 163 }
 164
 165 sub resume_vm {
 166     my ($self, $task, $vmid) = @_;
 167
 168     $self->cmd ("qm resume $vmid --skiplock");
 169 }
 170
 171 sub assemble {
 172     my ($self, $task, $vmid) = @_;
 173
 174     my $conffile = PVE::QemuConfig->config_file($vmid);
 175
 176     my $outfile = "$task->{tmpdir}/qemu-server.conf";
 177     my $firewall_src = "/etc/pve/firewall/$vmid.fw";
 178     my $firewall_dest = "$task->{tmpdir}/qemu-server.fw";
 179
 180     my $outfd = IO::File->new (">$outfile") ||
 181         die "unable to open '$outfile'";
 182     my $conffd = IO::File->new ($conffile, 'r') ||
 183         die "unable open '$conffile'";
 184
 185     my $found_snapshot;
 186     my $found_pending;
 187     while (defined (my $line = <$conffd>)) {
 188         next if $line =~ m/^\#vzdump\#/; # just to be sure
 189         next if $line =~ m/^\#qmdump\#/; # just to be sure
 190         if ($line =~ m/^\[(.*)\]\s*$/) {
 191             if ($1 =~ m/PENDING/i) {
 192                 $found_pending = 1;
 193             } else {
 194                 $found_snapshot = 1;
 195             }
 196         }
 197
 198         next if $found_snapshot; # skip all snapshots data
 199         next if $found_pending; # skip all pending changes
 200
 201         if ($line =~ m/^unused\d+:\s*(\S+)\s*/) {
 202             $self->loginfo("skip unused drive '$1' (not included into backup)");
 203             next;
 204         }
 205         next if $line =~ m/^lock:/ || $line =~ m/^parent:/;
 206
 207         print $outfd $line;
 208     }
 209
 210     foreach my $di (@{$task->{disks}}) {
 211         if ($di->{type} eq 'block' || $di->{type} eq 'file') {
 212             my $storeid = $di->{storeid} || '';
 213             my $format = $di->{format} || '';
 214             print $outfd "#qmdump#map:$di->{virtdev}:$di->{qmdevice}:$storeid:$format:\n";
 215         } else {
 216             die "internal error";
 217         }
 218     }
 219
 220     if ($found_snapshot) {
 221         $self->loginfo("snapshots found (not included into backup)");
 222     }
 223
 224     if ($found_pending) {
 225         $self->loginfo("pending configuration changes found (not included into backup)");
 226     }
 227
 228     PVE::Tools::file_copy($firewall_src, $firewall_dest) if -f $firewall_src;
 229 }
 230
 231 sub archive {
 232     my ($self, $task, $vmid, $filename, $comp) = @_;
 233
 234     my $conffile = "$task->{tmpdir}/qemu-server.conf";
 235     my $firewall = "$task->{tmpdir}/qemu-server.fw";
 236
 237     my $opts = $self->{vzdump}->{opts};
 238
 239     my $starttime = time ();
 240
 241     my $speed = 0;
 242     if ($opts->{bwlimit}) {
 243         $speed = $opts->{bwlimit}*1024;
 244     }
 245
 246     my $diskcount = scalar(@{$task->{disks}});
 247
 248     if (PVE::QemuConfig->is_template($self->{vmlist}->{$vmid}) || !$diskcount) {
 249         my @pathlist;
 250         foreach my $di (@{$task->{disks}}) {
 251             if ($di->{type} eq 'block' || $di->{type} eq 'file') {
 252                 push @pathlist, "$di->{qmdevice}=$di->{path}";
 253             } else {
 254                 die "implement me";
 255             }
 256         }
 257
 258         if (!$diskcount) {
 259             $self->loginfo("backup contains no disks");
 260         }
 261
 262         my $outcmd;
 263         if ($comp) {
 264             $outcmd = "exec:$comp";
 265         } else {
 266             $outcmd = "exec:cat";
 267         }
 268
 269         $outcmd .= ">$filename" if !$opts->{stdout};
 270
 271         my $cmd = ['/usr/bin/vma', 'create', '-v', '-c', $conffile];
 272         push @$cmd, '-c', $firewall if -e $firewall;
 273         push @$cmd, $outcmd, @pathlist;
 274
 275         $self->loginfo("starting template backup");
 276         $self->loginfo(join(' ', @$cmd));
 277
 278         if ($opts->{stdout}) {
 279             $self->cmd($cmd, output => ">&=" . fileno($opts->{stdout}));
 280         } else {
 281             $self->cmd($cmd);
 282         }
 283
 284         return;
 285     }
 286
 287
 288     my $devlist = '';
 289     foreach my $di (@{$task->{disks}}) {
 290         if ($di->{type} eq 'block' || $di->{type} eq 'file') {
 291             $devlist .= $devlist ? ",$di->{qmdevice}" : $di->{qmdevice};
 292         } else {
 293             die "implement me";
 294         }
 295     }
 296
 297     my $stop_after_backup;
 298     my $resume_on_backup;
 299
 300     my $skiplock = 1;
 301     my $vm_is_running = PVE::QemuServer::check_running($vmid);
 302     if (!$vm_is_running) {
 303         eval {
 304             $self->loginfo("starting kvm to execute backup task");
 305             PVE::QemuServer::vm_start($self->{storecfg}, $vmid, undef,
 306                                       $skiplock, undef, 1);
 307             if ($self->{vm_was_running}) {
 308                 $resume_on_backup = 1;
 309             } else {
 310                 $stop_after_backup = 1;
 311             }
 312         };
 313         if (my $err = $@) {
 314             die $err;
 315         }
 316     }
 317
 318     my $cpid;
 319     my $interrupt_msg = "interrupted by signal\n";
 320     eval {
 321         $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
 322             die $interrupt_msg;
 323         };
 324
 325         my $qmpclient = PVE::QMPClient->new();
 326
 327         my $uuid;
 328
 329         my $backup_cb = sub {
 330             my ($vmid, $resp) = @_;
 331             $uuid = $resp->{return}->{UUID};
 332         };
 333
 334         my $outfh;
 335         if ($opts->{stdout}) {
 336             $outfh = $opts->{stdout};
 337         } else {
 338             $outfh = IO::File->new($filename, "w") ||
 339                 die "unable to open file '$filename' - $!\n";
 340         }
 341
 342         my $outfileno;
 343         if ($comp) {
 344             my @pipefd = POSIX::pipe();
 345             $cpid = fork();
 346             die "unable to fork worker - $!" if !defined($cpid);
 347             if ($cpid == 0) {
 348                 eval {
 349                     POSIX::close($pipefd[1]);
 350                     # redirect STDIN
 351                     my $fd = fileno(STDIN);
 352                     close STDIN;
 353                     POSIX::close(0) if $fd != 0;
 354                     die "unable to redirect STDIN - $!"
 355                         if !open(STDIN, "<&", $pipefd[0]);
 356
 357                     # redirect STDOUT
 358                     $fd = fileno(STDOUT);
 359                     close STDOUT;
 360                     POSIX::close (1) if $fd != 1;
 361
 362                     die "unable to redirect STDOUT - $!"
 363                         if !open(STDOUT, ">&", fileno($outfh));
 364
 365                     exec($comp);
 366                     die "fork compressor '$comp' failed\n";
 367                 };
 368                 if (my $err = $@) {
 369                     $self->logerr($err);
 370                     POSIX::_exit(1);
 371                 }
 372                 POSIX::_exit(0);
 373                 kill(-9, $$);
 374             } else {
 375                 POSIX::close($pipefd[0]);
 376                 $outfileno = $pipefd[1];
 377             }
 378         } else {
 379             $outfileno = fileno($outfh);
 380         }
 381
 382         my $add_fd_cb = sub {
 383             my ($vmid, $resp) = @_;
 384
 385             my $params = {
 386                 'backup-file' => "/dev/fdname/backup",
 387                 speed => $speed,
 388                 'config-file' => $conffile,
 389                 devlist => $devlist
 390             };
 391
 392             $params->{'firewall-file'} = $firewall if -e $firewall;
 393             $qmpclient->queue_cmd($vmid, $backup_cb, 'backup', %$params);
 394         };
 395
 396         $qmpclient->queue_cmd($vmid, $add_fd_cb, 'getfd',
 397                               fd => $outfileno, fdname => "backup");
 398
 399         if ($self->{vmlist}->{$vmid}->{agent} && $vm_is_running){
 400             eval { PVE::QemuServer::vm_mon_cmd($vmid, "guest-fsfreeze-freeze"); };
 401             if (my $err = $@) {
 402                 $self->logerr($err);
 403             }
 404         }
 405
 406         $qmpclient->queue_execute();
 407
 408         if ($self->{vmlist}->{$vmid}->{agent} && $vm_is_running ){
 409             eval { PVE::QemuServer::vm_mon_cmd($vmid, "guest-fsfreeze-thaw"); };
 410             if (my $err = $@) {
 411                 $self->logerr($err);
 412             }
 413         }
 414         die $qmpclient->{errors}->{$vmid} if $qmpclient->{errors}->{$vmid};
 415
 416         if ($cpid) {
 417             POSIX::close($outfileno) == 0 ||
 418                 die "close output file handle failed\n";
 419         }
 420
 421         die "got no uuid for backup task\n" if !$uuid;
 422
 423         $self->loginfo("started backup task '$uuid'");
 424
 425         if ($resume_on_backup) {
 426             $self->loginfo("resume VM");
 427             PVE::QemuServer::vm_mon_cmd($vmid, 'cont');
 428         }
 429
 430         my $status;
 431         my $starttime = time ();
 432         my $last_per = -1;
 433         my $last_total = 0;
 434         my $last_zero = 0;
 435         my $last_transferred = 0;
 436         my $last_time = time();
 437         my $transferred;
 438
 439         while(1) {
 440             $status = PVE::QemuServer::vm_mon_cmd($vmid, 'query-backup');
 441             my $total = $status->{total} || 0;
 442             $transferred = $status->{transferred} || 0;
 443             my $per = $total ? int(($transferred * 100)/$total) : 0;
 444             my $zero = $status->{'zero-bytes'} || 0;
 445             my $zero_per = $total ? int(($zero * 100)/$total) : 0;
 446
 447             die "got unexpected uuid\n" if !$status->{uuid} || ($status->{uuid} ne $uuid);
 448
 449             my $ctime = time();
 450             my $duration = $ctime - $starttime;
 451
 452             my $rbytes = $transferred - $last_transferred;
 453             my $wbytes = $rbytes - ($zero - $last_zero);
 454
 455             my $timediff = ($ctime - $last_time) || 1; # fixme
 456             my $mbps_read = ($rbytes > 0) ?
 457                 int(($rbytes/$timediff)/(1000*1000)) : 0;
 458             my $mbps_write = ($wbytes > 0) ?
 459                 int(($wbytes/$timediff)/(1000*1000)) : 0;
 460
 461             my $statusline = "status: $per% ($transferred/$total), " .
 462                 "sparse ${zero_per}% ($zero), duration $duration, " .
 463                 "$mbps_read/$mbps_write MB/s";
 464             my $res = $status->{status} || 'unknown';
 465             if ($res ne 'active') {
 466                 $self->loginfo($statusline);
 467                 die(($status->{errmsg} || "unknown error") . "\n")
 468                     if $res eq 'error';
 469                 die "got unexpected status '$res'\n"
 470                     if $res ne 'done';
 471                 die "got wrong number of transfered bytes ($total != $transferred)\n"
 472                     if ($res eq 'done') && ($total != $transferred);
 473
 474                 last;
 475             }
 476             if ($per != $last_per && ($timediff > 2)) {
 477                 $self->loginfo($statusline);
 478                 $last_per = $per;
 479                 $last_total = $total if $total;
 480                 $last_zero = $zero if $zero;
 481                 $last_transferred = $transferred if $transferred;
 482                 $last_time = $ctime;
 483             }
 484             sleep(1);
 485         }
 486
 487         my $duration = time() - $starttime;
 488         if ($transferred && $duration) {
 489             my $mb = int($transferred/(1000*1000));
 490             my $mbps = int(($transferred/$duration)/(1000*1000));
 491             $self->loginfo("transferred $mb MB in $duration seconds ($mbps MB/s)");
 492         }
 493     };
 494     my $err = $@;
 495
 496     if ($err) {
 497         $self->logerr($err);
 498         $self->loginfo("aborting backup job");
 499         eval { PVE::QemuServer::vm_mon_cmd($vmid, 'backup-cancel'); };
 500         if (my $err1 = $@) {
 501             $self->logerr($err1);
 502         }
 503     }
 504
 505     if ($stop_after_backup) {
 506         # stop if not running
 507         eval {
 508             my $resp = PVE::QemuServer::vm_mon_cmd($vmid, 'query-status');
 509             my $status = $resp && $resp->{status} ?  $resp->{status} : 'unknown';
 510             if ($status eq 'prelaunch') {
 511                 $self->loginfo("stopping kvm after backup task");
 512                 PVE::QemuServer::vm_stop($self->{storecfg}, $vmid, $skiplock);
 513             } else {
 514                 $self->loginfo("kvm status changed after backup ('$status')" .
 515                                " - keep VM running");
 516             }
 517         }
 518     }
 519
 520     if ($err) {
 521         if ($cpid) {
 522             kill(9, $cpid);
 523             waitpid($cpid, 0);
 524         }
 525         die $err;
 526     }
 527
 528     if ($cpid && (waitpid($cpid, 0) > 0)) {
 529         my $stat = $?;
 530         my $ec = $stat >> 8;
 531         my $signal = $stat & 127;
 532         if ($ec || $signal) {
 533             die "$comp failed - wrong exit status $ec" .
 534                 ($signal ? " (signal $signal)\n" : "\n");
 535         }
 536     }
 537 }
 538
 539 sub snapshot {
 540     my ($self, $task, $vmid) = @_;
 541
 542     # nothing to do
 543 }
 544
 545 sub cleanup {
 546     my ($self, $task, $vmid) = @_;
 547
 548     # nothing to do ?
 549 }
 550
 551 1;