X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FStorage.pm;h=7a65624ee4c2d2d06db90c45ccb6dc788c700b2d;hb=ae36189d26ea64ab0cb174b9991f6ff442554bc7;hp=7845ad174bde6b416e834c3085378a51c3bf5c41;hpb=1597f1f9ad010b7da09ce3535e217e457d1e8744;p=pve-storage.git diff --git a/PVE/Storage.pm b/PVE/Storage.pm index 7845ad1..7a65624 100755 --- a/PVE/Storage.pm +++ b/PVE/Storage.pm @@ -2,17 +2,19 @@ package PVE::Storage; use strict; use warnings; +use Data::Dumper; use POSIX; use IO::Select; use IO::File; +use IO::Socket::IP; use File::Basename; use File::Path; use Cwd 'abs_path'; use Socket; -use PVE::Tools qw(run_command file_read_firstline); -use PVE::Cluster qw(cfs_read_file cfs_lock_file); +use PVE::Tools qw(run_command file_read_firstline dir_glob_foreach $IPV6RE); +use PVE::Cluster qw(cfs_read_file cfs_write_file cfs_lock_file); use PVE::Exception qw(raise_param_exc); use PVE::JSONSchema; use PVE::INotify; @@ -21,6 +23,7 @@ use PVE::RPCEnvironment; use PVE::Storage::Plugin; use PVE::Storage::DirPlugin; use PVE::Storage::LVMPlugin; +use PVE::Storage::LvmThinPlugin; use PVE::Storage::NFSPlugin; use PVE::Storage::ISCSIPlugin; use PVE::Storage::RBDPlugin; @@ -29,10 +32,15 @@ use PVE::Storage::ISCSIDirectPlugin; use PVE::Storage::GlusterfsPlugin; use PVE::Storage::ZFSPoolPlugin; use PVE::Storage::ZFSPlugin; +use PVE::Storage::DRBDPlugin; -# load and initialize all plugins +# Storage API version. Icrement it on changes in storage API interface. +use constant APIVER => 1; + +# load standard plugins PVE::Storage::DirPlugin->register(); PVE::Storage::LVMPlugin->register(); +PVE::Storage::LvmThinPlugin->register(); PVE::Storage::NFSPlugin->register(); PVE::Storage::ISCSIPlugin->register(); PVE::Storage::RBDPlugin->register(); @@ -41,6 +49,35 @@ PVE::Storage::ISCSIDirectPlugin->register(); PVE::Storage::GlusterfsPlugin->register(); PVE::Storage::ZFSPoolPlugin->register(); PVE::Storage::ZFSPlugin->register(); +PVE::Storage::DRBDPlugin->register(); + +# load third-party plugins +if ( -d '/usr/share/perl5/PVE/Storage/Custom' ) { + dir_glob_foreach('/usr/share/perl5/PVE/Storage/Custom', '.*\.pm$', sub { + my ($file) = @_; + my $modname = 'PVE::Storage::Custom::' . $file; + $modname =~ s!\.pm$!!; + $file = 'PVE/Storage/Custom/' . $file; + + eval { + require $file; + }; + if ($@) { + warn $@; + # Check storage API version and that file is really storage plugin. + } elsif ($modname->isa('PVE::Storage::Plugin') && $modname->can('api') && $modname->api() == APIVER) { + eval { + import $file; + $modname->register(); + }; + warn $@ if $@; + } else { + warn "Error loading storage plugin \"$modname\" because of API version mismatch. Please, update it.\n" + } + }); +} + +# initialize all plugins PVE::Storage::Plugin->init(); my $UDEVADM = '/sbin/udevadm'; @@ -51,6 +88,12 @@ sub config { return cfs_read_file("storage.cfg"); } +sub write_config { + my ($cfg) = @_; + + cfs_write_file('storage.cfg', $cfg); +} + sub lock_storage_config { my ($code, $errmsg) = @_; @@ -64,7 +107,7 @@ sub lock_storage_config { sub storage_config { my ($cfg, $storeid, $noerr) = @_; - die "no storage id specified\n" if !$storeid; + die "no storage ID specified\n" if !$storeid; my $scfg = $cfg->{ids}->{$storeid}; @@ -138,39 +181,39 @@ sub volume_resize { my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); return $plugin->volume_resize($scfg, $storeid, $volname, $size, $running); } elsif ($volid =~ m|^(/.+)$| && -e $volid) { - die "resize device is not possible"; + die "resize file/device '$volid' is not possible\n"; } else { - die "can't resize"; + die "unable to parse volume ID '$volid'\n"; } } sub volume_rollback_is_possible { my ($cfg, $volid, $snap) = @_; - + my ($storeid, $volname) = parse_volume_id($volid, 1); if ($storeid) { my $scfg = storage_config($cfg, $storeid); my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); return $plugin->volume_rollback_is_possible($scfg, $storeid, $volname, $snap); } elsif ($volid =~ m|^(/.+)$| && -e $volid) { - die "snapshot rollback device $volid is not possible"; + die "snapshot rollback file/device '$volid' is not possible\n"; } else { - die "can't parse volume id"; + die "unable to parse volume ID '$volid'\n"; } } sub volume_snapshot { - my ($cfg, $volid, $snap, $running) = @_; + my ($cfg, $volid, $snap) = @_; my ($storeid, $volname) = parse_volume_id($volid, 1); if ($storeid) { my $scfg = storage_config($cfg, $storeid); my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); - return $plugin->volume_snapshot($scfg, $storeid, $volname, $snap, $running); + return $plugin->volume_snapshot($scfg, $storeid, $volname, $snap); } elsif ($volid =~ m|^(/.+)$| && -e $volid) { - die "snapshot device is not possible"; + die "snapshot file/device '$volid' is not possible\n"; } else { - die "can't snapshot"; + die "unable to parse volume ID '$volid'\n"; } } @@ -181,11 +224,12 @@ sub volume_snapshot_rollback { if ($storeid) { my $scfg = storage_config($cfg, $storeid); my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + $plugin->volume_rollback_is_possible($scfg, $storeid, $volname, $snap); return $plugin->volume_snapshot_rollback($scfg, $storeid, $volname, $snap); } elsif ($volid =~ m|^(/.+)$| && -e $volid) { - die "snapshot rollback device is not possible"; + die "snapshot rollback file/device '$volid' is not possible\n"; } else { - die "can't snapshot"; + die "unable to parse volume ID '$volid'\n"; } } @@ -198,9 +242,9 @@ sub volume_snapshot_delete { my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); return $plugin->volume_snapshot_delete($scfg, $storeid, $volname, $snap, $running); } elsif ($volid =~ m|^(/.+)$| && -e $volid) { - die "snapshot delete device is not possible"; + die "snapshot delete file/device '$volid' is not possible\n"; } else { - die "can't delete snapshot"; + die "unable to parse volume ID '$volid'\n"; } } @@ -219,6 +263,22 @@ sub volume_has_feature { } } +sub volume_snapshot_list { + my ($cfg, $volid) = @_; + + my ($storeid, $volname) = parse_volume_id($volid, 1); + if ($storeid) { + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + return $plugin->volume_snapshot_list($scfg, $storeid, $volname); + } elsif ($volid =~ m|^(/.+)$| && -e $volid) { + die "send file/device '$volid' is not possible\n"; + } else { + die "unable to parse volume ID '$volid'\n"; + } + # return an empty array if dataset does not exist. +} + sub get_image_dir { my ($cfg, $storeid, $vmid) = @_; @@ -278,6 +338,9 @@ sub parse_vmid { return int($vmid); } +# NOTE: basename and basevmid are always undef for LVM-thin, where the +# clone -> base reference is not encoded in the volume ID. +# see note in PVE::Storage::LvmThinPlugin for details. sub parse_volname { my ($cfg, $volid) = @_; @@ -286,6 +349,9 @@ sub parse_volname { my $scfg = storage_config($cfg, $storeid); my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + + # returns ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) + return $plugin->parse_volname($volname); } @@ -295,25 +361,71 @@ sub parse_volume_id { return PVE::Storage::Plugin::parse_volume_id($volid, $noerr); } -sub volume_is_base { - my ($cfg, $volid) = @_; +# test if we have read access to volid +sub check_volume_access { + my ($rpcenv, $user, $cfg, $vmid, $volid) = @_; my ($sid, $volname) = parse_volume_id($volid, 1); - return 0 if !$sid; - - if (my $scfg = $cfg->{ids}->{$sid}) { - my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); - my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) = - $plugin->parse_volname($volname); - return $isBase ? 1 : 0; - } else { - # stale volid with undefined storage - so we can just guess - if ($volid =~ m/base-/) { - return 1; + if ($sid) { + my ($vtype, undef, $ownervm) = parse_volname($cfg, $volid); + if ($vtype eq 'iso' || $vtype eq 'vztmpl') { + # we simply allow access + } elsif (defined($ownervm) && defined($vmid) && ($ownervm == $vmid)) { + # we are owner - allow access + } elsif ($vtype eq 'backup' && $ownervm) { + $rpcenv->check($user, "/storage/$sid", ['Datastore.AllocateSpace']); + $rpcenv->check($user, "/vms/$ownervm", ['VM.Backup']); + } else { + # allow if we are Datastore administrator + $rpcenv->check($user, "/storage/$sid", ['Datastore.Allocate']); } + } else { + die "Only root can pass arbitrary filesystem paths." + if $user ne 'root@pam'; } + return undef; +} + +my $volume_is_base_and_used__no_lock = sub { + my ($scfg, $storeid, $plugin, $volname) = @_; + + my ($vtype, $name, $vmid, undef, undef, $isBase, undef) = + $plugin->parse_volname($volname); + + if ($isBase) { + my $vollist = $plugin->list_images($storeid, $scfg); + foreach my $info (@$vollist) { + my (undef, $tmpvolname) = parse_volume_id($info->{volid}); + my $basename = undef; + my $basevmid = undef; + + eval{ + (undef, undef, undef, $basename, $basevmid) = + $plugin->parse_volname($tmpvolname); + }; + + if ($basename && defined($basevmid) && $basevmid == $vmid && $basename eq $name) { + return 1; + } + } + } return 0; +}; + +# NOTE: this check does not work for LVM-thin, where the clone -> base +# reference is not encoded in the volume ID. +# see note in PVE::Storage::LvmThinPlugin for details. +sub volume_is_base_and_used { + my ($cfg, $volid) = @_; + + my ($storeid, $volname) = parse_volume_id($volid); + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + + $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { + return &$volume_is_base_and_used__no_lock($scfg, $storeid, $plugin, $volname); + }); } # try to map a filesystem path to a volume identifier @@ -413,7 +525,7 @@ sub abs_filesystem_path { } sub storage_migrate { - my ($cfg, $volid, $target_host, $target_storeid, $target_volname) = @_; + my ($cfg, $volid, $target_sshinfo, $target_storeid, $target_volname, $base_snapshot, $snapshot, $ratelimit_bps, $insecure) = @_; my ($storeid, $volname) = parse_volume_id($volid); $target_volname = $volname if !$target_volname; @@ -427,17 +539,34 @@ sub storage_migrate { my $target_volid = "${target_storeid}:${target_volname}"; - my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_host'"; + my $target_ip = $target_sshinfo->{ip}; + my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_sshinfo->{name}'"; - my $sshoptions = "-o 'BatchMode=yes'"; - my $ssh = "/usr/bin/ssh $sshoptions"; + my $ssh = PVE::Cluster::ssh_info_to_command($target_sshinfo); + my $ssh_base = PVE::Cluster::ssh_info_to_command_base($target_sshinfo); + local $ENV{RSYNC_RSH} = PVE::Tools::cmd2string($ssh_base); + + my $no_incremental = sub { + my ($type) = @_; + die "incremental migration not supported on storage type $type\n" + if defined($base_snapshot); + }; + my $no_snapshot = sub { + my ($type) = @_; + # $snapshot is currently only used by replication + die "replicating storage migration not supported on storage type $type\n" + if defined($snapshot); + }; - local $ENV{RSYNC_RSH} = $ssh; + my @cstream = ([ '/usr/bin/cstream', '-t', $ratelimit_bps ]) + if defined($ratelimit_bps); # only implemented for file system based storage if ($scfg->{path}) { - if ($tcfg->{path}) { + $no_incremental->($scfg->{type}); + $no_snapshot->($scfg->{type}); + if ($tcfg->{path}) { my $src_plugin = PVE::Storage::Plugin->lookup($scfg->{type}); my $dst_plugin = PVE::Storage::Plugin->lookup($tcfg->{type}); my $src = $src_plugin->path($scfg, $volname, $storeid); @@ -452,22 +581,29 @@ sub storage_migrate { run_command(['/bin/cp', $src, $dst]); } else { - - run_command(['/usr/bin/ssh', "root\@${target_host}", - '/bin/mkdir', '-p', $dirname]); + run_command([@$ssh, '/bin/mkdir', '-p', $dirname]); # we use rsync with --sparse, so we can't use --inplace, # so we remove file on the target if it already exists to # save space my ($size, $format) = PVE::Storage::Plugin::file_size_info($src); if ($format && ($format eq 'raw') && $size) { - run_command(['/usr/bin/ssh', "root\@${target_host}", - 'rm', '-f', $dst], + run_command([@$ssh, 'rm', '-f', $dst], outfunc => sub {}); } - my $cmd = ['/usr/bin/rsync', '--progress', '--sparse', '--whole-file', - $src, "root\@${target_host}:$dst"]; + my $cmd; + my @bwlimit = ("--bwlimit=${ratelimit_bps}b") if defined($ratelimit_bps); + if ($format eq 'subvol') { + $cmd = ['/usr/bin/rsync', '--progress', '-X', '-A', '--numeric-ids', + '-aH', '--delete', '--no-whole-file', '--inplace', + '--one-file-system', @bwlimit, + "$src/", "[root\@${target_ip}]:$dst"]; + } else { + $cmd = ['/usr/bin/rsync', '--progress', '--sparse', '--whole-file', + @bwlimit, + $src, "[root\@${target_ip}]:$dst"]; + } my $percent = -1; @@ -489,6 +625,104 @@ sub storage_migrate { } else { die "$errstr - target type '$tcfg->{type}' not implemented\n"; } + + } elsif ($scfg->{type} eq 'zfspool') { + + if ($tcfg->{type} eq 'zfspool') { + + die "$errstr - pool on target does not have the same name as on source!" + if $tcfg->{pool} ne $scfg->{pool}; + + my $migration_snapshot; + if (!defined($snapshot)) { + $migration_snapshot = 1; + $snapshot = '__migration__'; + } + + my (undef, $volname) = parse_volname($cfg, $volid); + my $zfspath = "$scfg->{pool}\/$volname"; + + my @formats = volume_transfer_formats($cfg, $volid, $volid, $snapshot, $base_snapshot, 1); + die "cannot migrate from storage type '$scfg->{type}' to '$tcfg->{type}'\n" if !@formats; + my $format = $formats[0]; + + my @insecurecmd; + if ($insecure) { + @insecurecmd = ('pvecm', 'mtunnel', '-run-command', 1); + if (my $network = $target_sshinfo->{network}) { + push @insecurecmd, '-migration_network', $network; + } + } + + my $send = ['pvesm', 'export', $volid, $format, '-', '-snapshot', $snapshot, '-with-snapshots', '1']; + my $recv = [@$ssh, @insecurecmd, '--', 'pvesm', 'import', $volid, $format, '-', '-with-snapshots', '1']; + if ($migration_snapshot) { + push @$recv, '-delete-snapshot', $snapshot; + } + + if (defined($base_snapshot)) { + # Check if the snapshot exists on the remote side: + push @$send, '-base', $base_snapshot; + push @$recv, '-base', $base_snapshot; + } + + volume_snapshot($cfg, $volid, $snapshot) if $migration_snapshot; + eval { + if ($insecure) { + my $pid = open(my $info, '-|', @$recv) + or die "receive command failed: $!\n"; + my ($ip) = <$info> =~ /^($PVE::Tools::IPRE)$/ or die "no tunnel IP received\n"; + my ($port) = <$info> =~ /^(\d+)$/ or die "no tunnel port received\n"; + my $socket = IO::Socket::IP->new(PeerHost => $ip, PeerPort => $port, Type => SOCK_STREAM) + or die "failed to connect to tunnel at $ip:$port\n"; + run_command([$send, @cstream], output => '>&'.fileno($socket)); + } else { + run_command([$send, @cstream, $recv]); + } + }; + my $err = $@; + warn "send/receive failed, cleaning up snapshot(s)..\n" if $err; + if ($migration_snapshot) { + eval { volume_snapshot_delete($cfg, $volid, $snapshot, 0) }; + warn "could not remove source snapshot: $@\n" if $@; + } + die $err if $err; + } else { + die "$errstr - target type $tcfg->{type} is not valid\n"; + } + + } elsif ($scfg->{type} eq 'lvmthin' || $scfg->{type} eq 'lvm') { + $no_incremental->($scfg->{type}); + $no_snapshot->($scfg->{type}); + + if (($scfg->{type} eq $tcfg->{type}) && + ($tcfg->{type} eq 'lvmthin' || $tcfg->{type} eq 'lvm')) { + + my (undef, $volname, $vmid) = parse_volname($cfg, $volid); + my $size = volume_size_info($cfg, $volid, 5); + my $src = path($cfg, $volid); + my $dst = path($cfg, $target_volid); + + run_command([@$ssh, '--', + 'pvesm', 'alloc', $target_storeid, $vmid, + $target_volname, int($size/1024)]); + + eval { + if ($tcfg->{type} eq 'lvmthin') { + run_command([["dd", "if=$src", "bs=4k"], @cstream, + [@$ssh, "dd", 'conv=sparse', "of=$dst", "bs=4k"]]); + } else { + run_command([["dd", "if=$src", "bs=4k"], @cstream, + [@$ssh, "dd", "of=$dst", "bs=4k"]]); + } + }; + if (my $err = $@) { + run_command([@$ssh, 'pvesm', 'free', $target_volid]); + die $err; + } + } else { + die "$errstr - migrate from source type '$scfg->{type}' to '$tcfg->{type}' not implemented\n"; + } } else { die "$errstr - source type '$scfg->{type}' not implemented\n"; } @@ -533,7 +767,7 @@ sub vdisk_create_base { sub vdisk_alloc { my ($cfg, $storeid, $vmid, $fmt, $name, $size) = @_; - die "no storage id specified\n" if !$storeid; + die "no storage ID specified\n" if !$storeid; PVE::JSONSchema::parse_storage_id($storeid); @@ -553,7 +787,11 @@ sub vdisk_alloc { # lock shared storage return $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { - my $volname = $plugin->alloc_image($storeid, $scfg, $vmid, $fmt, $name, $size); + my $old_umask = umask(umask|0037); + my $volname = eval { $plugin->alloc_image($storeid, $scfg, $vmid, $fmt, $name, $size) }; + my $err = $@; + umask $old_umask; + die $err if $err; return "$storeid:$volname"; }); } @@ -562,9 +800,7 @@ sub vdisk_free { my ($cfg, $volid) = @_; my ($storeid, $volname) = parse_volume_id($volid); - my $scfg = storage_config($cfg, $storeid); - my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); activate_storage($cfg, $storeid); @@ -573,28 +809,13 @@ sub vdisk_free { # lock shared storage $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { + # LVM-thin allows deletion of still referenced base volumes! + die "base volume '$volname' is still in use by linked clones\n" + if &$volume_is_base_and_used__no_lock($scfg, $storeid, $plugin, $volname); - my ($vtype, $name, $vmid, undef, undef, $isBase) = + my (undef, undef, undef, undef, undef, $isBase, $format) = $plugin->parse_volname($volname); - if ($isBase) { - my $vollist = $plugin->list_images($storeid, $scfg); - foreach my $info (@$vollist) { - my (undef, $tmpvolname) = parse_volume_id($info->{volid}); - my $basename = undef; - my $basevmid = undef; - - eval{ - (undef, undef, undef, $basename, $basevmid) = - $plugin->parse_volname($tmpvolname); - }; - - if ($basename && defined($basevmid) && $basevmid == $vmid && $basename eq $name) { - die "base volume '$volname' is still in use " . - "(use by '$tmpvolname')\n"; - } - } - } - my $cleanup_worker = $plugin->free_image($storeid, $scfg, $volname, $isBase); + $cleanup_worker = $plugin->free_image($storeid, $scfg, $volname, $isBase, $format); }); return if !$cleanup_worker; @@ -649,9 +870,9 @@ sub template_list { $info = { volid => "$sid:iso/$1", format => 'iso' }; } elsif ($tt eq 'vztmpl') { - next if $fn !~ m!/([^/]+\.tar\.gz)$!; + next if $fn !~ m!/([^/]+\.tar\.([gx]z))$!; - $info = { volid => "$sid:vztmpl/$1", format => 'tgz' }; + $info = { volid => "$sid:vztmpl/$1", format => "t$2" }; } elsif ($tt eq 'backup') { next if $fn !~ m!/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz|vma|vma\.gz|vma\.lzo))$!; @@ -717,6 +938,44 @@ sub vdisk_list { return $res; } +sub volume_list { + my ($cfg, $storeid, $vmid, $content) = @_; + + my @ctypes = qw(images vztmpl iso backup); + + my $cts = $content ? [ $content ] : [ @ctypes ]; + + my $scfg = PVE::Storage::storage_config($cfg, $storeid); + + my $res = []; + foreach my $ct (@$cts) { + my $data; + if ($ct eq 'images') { + $data = vdisk_list($cfg, $storeid, $vmid); + } elsif ($ct eq 'iso' && !defined($vmid)) { + $data = template_list($cfg, $storeid, 'iso'); + } elsif ($ct eq 'vztmpl'&& !defined($vmid)) { + $data = template_list ($cfg, $storeid, 'vztmpl'); + } elsif ($ct eq 'backup') { + $data = template_list ($cfg, $storeid, 'backup'); + foreach my $item (@{$data->{$storeid}}) { + if (defined($vmid)) { + @{$data->{$storeid}} = grep { $_->{volid} =~ m/\S+-$vmid-\S+/ } @{$data->{$storeid}}; + } + } + } + + next if !$data || !$data->{$storeid}; + + foreach my $item (@{$data->{$storeid}}) { + $item->{content} = $ct; + push @$res, $item; + } + } + + return $res; +} + sub uevent_seqnum { my $filename = "/sys/kernel/uevent_seqnum"; @@ -789,7 +1048,7 @@ sub deactivate_storage { } sub activate_volumes { - my ($cfg, $vollist, $exclusive) = @_; + my ($cfg, $vollist, $snapname) = @_; return if !($vollist && scalar(@$vollist)); @@ -807,12 +1066,12 @@ sub activate_volumes { my ($storeid, $volname) = parse_volume_id($volid); my $scfg = storage_config($cfg, $storeid); my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); - $plugin->activate_volume($storeid, $scfg, $volname, $exclusive, $cache); + $plugin->activate_volume($storeid, $scfg, $volname, $snapname, $cache); } } sub deactivate_volumes { - my ($cfg, $vollist) = @_; + my ($cfg, $vollist, $snapname) = @_; return if !($vollist && scalar(@$vollist)); @@ -826,7 +1085,7 @@ sub deactivate_volumes { my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); eval { - $plugin->deactivate_volume($storeid, $scfg, $volname, $cache); + $plugin->deactivate_volume($storeid, $scfg, $volname, $snapname, $cache); }; if (my $err = $@) { warn $err; @@ -834,7 +1093,7 @@ sub deactivate_volumes { } } - die "volume deativation failed: " . join(' ', @errlist) + die "volume deactivation failed: " . join(' ', @errlist) if scalar(@errlist); } @@ -845,13 +1104,24 @@ sub storage_info { my $info = {}; + my @ctypes = PVE::Tools::split_list($content); + my $slist = []; foreach my $storeid (keys %$ids) { - next if $content && !$ids->{$storeid}->{content}->{$content}; - next if !storage_check_enabled($cfg, $storeid, undef, 1); + if (defined($content)) { + my $want_ctype = 0; + foreach my $ctype (@ctypes) { + if ($ids->{$storeid}->{content}->{$ctype}) { + $want_ctype = 1; + last; + } + } + next if !$want_ctype; + } + my $type = $ids->{$storeid}->{type}; $info->{$storeid} = { @@ -884,9 +1154,9 @@ sub storage_info { eval { ($total, $avail, $used, $active) = $plugin->status($storeid, $scfg, $cache); }; warn $@ if $@; next if !$active; - $info->{$storeid}->{total} = $total; - $info->{$storeid}->{avail} = $avail; - $info->{$storeid}->{used} = $used; + $info->{$storeid}->{total} = int($total); + $info->{$storeid}->{avail} = int($avail); + $info->{$storeid}->{used} = int($used); $info->{$storeid}->{active} = $active; } @@ -896,9 +1166,14 @@ sub storage_info { sub resolv_server { my ($server) = @_; - my $packed_ip = gethostbyname($server); + my ($packed_ip, $family); + eval { + my @res = PVE::Tools::getaddrinfo_all($server); + $family = $res[0]->{family}; + $packed_ip = (PVE::Tools::unpack_sockaddr_in46($res[0]->{addr}))[2]; + }; if (defined $packed_ip) { - return inet_ntoa($packed_ip); + return Socket::inet_ntop($family, $packed_ip); } return undef; } @@ -928,17 +1203,20 @@ sub scan_nfs { sub scan_zfs { - my $cmd = ['zpool', 'list', '-H', '-o', 'name,size,free']; + my $cmd = ['zfs', 'list', '-t', 'filesystem', '-H', '-o', 'name,avail,used']; my $res = []; run_command($cmd, outfunc => sub { my $line = shift; if ($line =~m/^(\S+)\s+(\S+)\s+(\S+)$/) { - my ($pool, $size_str, $free_str) = ($1, $2, $3); + my ($pool, $size_str, $used_str) = ($1, $2, $3); my $size = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($size_str); - my $free = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($free_str); - push @$res, { pool => $pool, size => $size, free => $free }; + my $used = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($used_str); + # ignore subvolumes generated by our ZFSPoolPlugin + return if $pool =~ m!/subvol-\d+-[^/]+$!; + return if $pool =~ m!/basevol-\d+-[^/]+$!; + push @$res, { pool => $pool, size => $size, free => $size-$used }; } }); @@ -948,12 +1226,11 @@ sub scan_zfs { sub resolv_portal { my ($portal, $noerr) = @_; - if ($portal =~ m/^([^:]+)(:(\d+))?$/) { - my $server = $1; - my $port = $3; - + my ($server, $port) = PVE::Tools::parse_host_and_port($portal); + if ($server) { if (my $ip = resolv_server($server)) { $server = $ip; + $server = "[$server]" if $server =~ /^$IPV6RE$/; return $port ? "$server:$port" : $server; } } @@ -1108,4 +1385,240 @@ sub foreach_volid { } } +sub extract_vzdump_config_tar { + my ($archive, $conf_re) = @_; + + die "ERROR: file '$archive' does not exist\n" if ! -f $archive; + + my $pid = open(my $fh, '-|', 'tar', 'tf', $archive) || + die "unable to open file '$archive'\n"; + + my $file; + while (defined($file = <$fh>)) { + if ($file =~ $conf_re) { + $file = $1; # untaint + last; + } + } + + kill 15, $pid; + waitpid $pid, 0; + close $fh; + + die "ERROR: archive contains no configuration file\n" if !$file; + chomp $file; + + my $raw = ''; + my $out = sub { + my $output = shift; + $raw .= "$output\n"; + }; + + PVE::Tools::run_command(['tar', '-xpOf', $archive, $file, '--occurrence'], outfunc => $out); + + return wantarray ? ($raw, $file) : $raw; +} + +sub extract_vzdump_config_vma { + my ($archive, $comp) = @_; + + my $cmd; + my $raw = ''; + my $out = sub { + my $output = shift; + $raw .= "$output\n"; + }; + + + if ($comp) { + my $uncomp; + if ($comp eq 'gz') { + $uncomp = ["zcat", $archive]; + } elsif ($comp eq 'lzo') { + $uncomp = ["lzop", "-d", "-c", $archive]; + } else { + die "unknown compression method '$comp'\n"; + } + $cmd = [$uncomp, ["vma", "config", "-"]]; + + # in some cases, lzop/zcat exits with 1 when its stdout pipe is + # closed early by vma, detect this and ignore the exit code later + my $broken_pipe; + my $errstring; + my $err = sub { + my $output = shift; + if ($output =~ m/lzop: Broken pipe: / || $output =~ m/gzip: stdout: Broken pipe/) { + $broken_pipe = 1; + } elsif (!defined ($errstring) && $output !~ m/^\s*$/) { + $errstring = "Failed to extract config from VMA archive: $output\n"; + } + }; + + # in other cases, the pipeline will exit with exit code 141 + # because of the broken pipe, handle / ignore this as well + my $rc; + eval { + $rc = PVE::Tools::run_command($cmd, outfunc => $out, errfunc => $err, noerr => 1); + }; + my $rerr = $@; + + # use exit code if no stderr output and not just broken pipe + if (!$errstring && !$broken_pipe && $rc != 0 && $rc != 141) { + die "$rerr\n" if $rerr; + die "config extraction failed with exit code $rc\n"; + } + die "$errstring\n" if $errstring; + } else { + # simple case without compression and weird piping behaviour + PVE::Tools::run_command(["vma", "config", $archive], outfunc => $out); + } + + return wantarray ? ($raw, undef) : $raw; +} + +sub extract_vzdump_config { + my ($cfg, $volid) = @_; + + my $archive = abs_filesystem_path($cfg, $volid); + + if ($volid =~ /vzdump-(lxc|openvz)-\d+-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.(tgz|(tar(\.(gz|lzo))?))$/) { + return extract_vzdump_config_tar($archive, qr!^(\./etc/vzdump/(pct|vps)\.conf)$!); + } elsif ($volid =~ /vzdump-qemu-\d+-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.(tgz|((tar|vma)(\.(gz|lzo))?))$/) { + my $format; + my $comp; + if ($7 eq 'tgz') { + $format = 'tar'; + $comp = 'gz'; + } else { + $format = $9; + $comp = $11 if defined($11); + } + + if ($format eq 'tar') { + return extract_vzdump_config_tar($archive, qr!\(\./qemu-server\.conf\)!); + } else { + return extract_vzdump_config_vma($archive, $comp); + } + } else { + die "cannot determine backup guest type for backup archive '$volid'\n"; + } +} + +sub volume_export { + my ($cfg, $fh, $volid, $format, $snapshot, $base_snapshot, $with_snapshots) = @_; + + my ($storeid, $volname) = parse_volume_id($volid, 1); + die "cannot export volume '$volid'\n" if !$storeid; + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + return $plugin->volume_export($scfg, $storeid, $fh, $volname, $format, + $snapshot, $base_snapshot, $with_snapshots); +} + +sub volume_import { + my ($cfg, $fh, $volid, $format, $base_snapshot, $with_snapshots) = @_; + + my ($storeid, $volname) = parse_volume_id($volid, 1); + die "cannot import into volume '$volid'\n" if !$storeid; + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + return $plugin->volume_import($scfg, $storeid, $fh, $volname, $format, + $base_snapshot, $with_snapshots); +} + +sub volume_export_formats { + my ($cfg, $volid, $snapshot, $base_snapshot, $with_snapshots) = @_; + + my ($storeid, $volname) = parse_volume_id($volid, 1); + return if !$storeid; + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + return $plugin->volume_export_formats($scfg, $storeid, $volname, + $snapshot, $base_snapshot, + $with_snapshots); +} + +sub volume_import_formats { + my ($cfg, $volid, $base_snapshot, $with_snapshots) = @_; + + my ($storeid, $volname) = parse_volume_id($volid, 1); + return if !$storeid; + my $scfg = storage_config($cfg, $storeid); + my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); + return $plugin->volume_import_formats($scfg, $storeid, $volname, + $base_snapshot, $with_snapshots); +} + +sub volume_transfer_formats { + my ($cfg, $src_volid, $dst_volid, $snapshot, $base_snapshot, $with_snapshots) = @_; + my @export_formats = volume_export_formats($cfg, $src_volid, $snapshot, $base_snapshot, $with_snapshots); + my @import_formats = volume_import_formats($cfg, $dst_volid, $base_snapshot, $with_snapshots); + my %import_hash = map { $_ => 1 } @import_formats; + my @common = grep { $import_hash{$_} } @export_formats; + return @common; +} + +# bash completion helper + +sub complete_storage { + my ($cmdname, $pname, $cvalue) = @_; + + my $cfg = PVE::Storage::config(); + + return $cmdname eq 'add' ? [] : [ PVE::Storage::storage_ids($cfg) ]; +} + +sub complete_storage_enabled { + my ($cmdname, $pname, $cvalue) = @_; + + my $res = []; + + my $cfg = PVE::Storage::config(); + foreach my $sid (keys %{$cfg->{ids}}) { + next if !storage_check_enabled($cfg, $sid, undef, 1); + push @$res, $sid; + } + return $res; +} + +sub complete_content_type { + my ($cmdname, $pname, $cvalue) = @_; + + return [qw(rootdir images vztmpl iso backup)]; +} + +sub complete_volume { + my ($cmdname, $pname, $cvalue) = @_; + + my $cfg = config(); + + my $storage_list = complete_storage_enabled(); + + if ($cvalue =~ m/^([^:]+):/) { + $storage_list = [ $1 ]; + } else { + if (scalar(@$storage_list) > 1) { + # only list storage IDs to avoid large listings + my $res = []; + foreach my $storeid (@$storage_list) { + # Hack: simply return 2 artificial values, so that + # completions does not finish + push @$res, "$storeid:volname", "$storeid:..."; + } + return $res; + } + } + + my $res = []; + foreach my $storeid (@$storage_list) { + my $vollist = PVE::Storage::volume_list($cfg, $storeid); + + foreach my $item (@$vollist) { + push @$res, $item->{volid}; + } + } + + return $res; +} + 1;