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 Time::Local qw(timelocal);
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::DataCenterConfig;
use PVE::Exception qw(raise_param_exc);
use PVE::JSONSchema;
use PVE::INotify;
use PVE::RPCEnvironment;
+use PVE::SSHInfo;
use PVE::Storage::Plugin;
use PVE::Storage::DirPlugin;
use PVE::Storage::LVMPlugin;
use PVE::Storage::LvmThinPlugin;
use PVE::Storage::NFSPlugin;
+use PVE::Storage::CIFSPlugin;
use PVE::Storage::ISCSIPlugin;
use PVE::Storage::RBDPlugin;
-use PVE::Storage::SheepdogPlugin;
+use PVE::Storage::CephFSPlugin;
use PVE::Storage::ISCSIDirectPlugin;
use PVE::Storage::GlusterfsPlugin;
use PVE::Storage::ZFSPoolPlugin;
use PVE::Storage::ZFSPlugin;
use PVE::Storage::DRBDPlugin;
+use PVE::Storage::PBSPlugin;
# Storage API version. Icrement it on changes in storage API interface.
-use constant APIVER => 1;
+use constant APIVER => 5;
+# Age is the number of versions we're backward compatible with.
+# This is like having 'current=APIVER' and age='APIAGE' in libtool,
+# see https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html
+use constant APIAGE => 4;
# load standard plugins
PVE::Storage::DirPlugin->register();
PVE::Storage::LVMPlugin->register();
PVE::Storage::LvmThinPlugin->register();
PVE::Storage::NFSPlugin->register();
+PVE::Storage::CIFSPlugin->register();
PVE::Storage::ISCSIPlugin->register();
PVE::Storage::RBDPlugin->register();
-PVE::Storage::SheepdogPlugin->register();
+PVE::Storage::CephFSPlugin->register();
PVE::Storage::ISCSIDirectPlugin->register();
PVE::Storage::GlusterfsPlugin->register();
PVE::Storage::ZFSPoolPlugin->register();
PVE::Storage::ZFSPlugin->register();
PVE::Storage::DRBDPlugin->register();
+PVE::Storage::PBSPlugin->register();
# load third-party plugins
if ( -d '/usr/share/perl5/PVE/Storage/Custom' ) {
eval {
require $file;
+
+ # Check perl interface:
+ die "not derived from PVE::Storage::Plugin\n"
+ if !$modname->isa('PVE::Storage::Plugin');
+ die "does not provide an api() method\n"
+ if !$modname->can('api');
+ # Check storage API version and that file is really storage plugin.
+ my $version = $modname->api();
+ die "implements an API version newer than current ($version > " . APIVER . ")\n"
+ if $version > APIVER;
+ my $min_version = (APIVER - APIAGE);
+ die "API version too old, please update the plugin ($version < $min_version)\n"
+ if $version < $min_version;
+ import $file;
+ $modname->register();
+
+ # If we got this far and the API version is not the same, make some
+ # noise:
+ warn "Plugin \"$modname\" is implementing an older storage API, an upgrade is recommended\n"
+ if $version != APIVER;
};
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"
+ warn "Error loading storage plugin \"$modname\": $@";
}
});
}
my $UDEVADM = '/sbin/udevadm';
+our $iso_extension_re = qr/\.(?:iso|img)/i;
+
# PVE::Storage utility functions
sub config {
my $scfg = $cfg->{ids}->{$storeid};
- die "storage '$storeid' does not exists\n" if (!$noerr && !$scfg);
+ die "storage '$storeid' does not exist\n" if (!$noerr && !$scfg);
return $scfg;
}
return storage_check_node($cfg, $storeid, $node, $noerr);
}
+# storage_can_replicate:
+# return true if storage supports replication
+# (volumes alocated with vdisk_alloc() has replication feature)
+sub storage_can_replicate {
+ my ($cfg, $storeid, $format) = @_;
+
+ my $scfg = storage_config($cfg, $storeid);
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
+ return $plugin->storage_can_replicate($scfg, $storeid, $format);
+}
+
sub storage_ids {
my ($cfg) = @_;
sub volume_resize {
my ($cfg, $volid, $size, $running) = @_;
+ my $padding = (1024 - $size % 1024) % 1024;
+ $size = $size + $padding;
+
my ($storeid, $volname) = parse_volume_id($volid, 1);
if ($storeid) {
my $scfg = storage_config($cfg, $storeid);
}
}
+# check if a volume or snapshot supports a given feature
+# $feature - one of:
+# clone - linked clone is possible
+# copy - full clone is possible
+# replicate - replication is possible
+# snapshot - taking a snapshot is possible
+# sparseinit - volume is sparsely initialized
+# template - conversion to base image is possible
+# $snap - check if the feature is supported for a given snapshot
+# $running - if the guest owning the volume is running
+# $opts - hash with further options:
+# valid_target_formats - list of formats for the target of a copy/clone
+# operation that the caller could work with. The
+# format of $volid is always considered valid and if
+# no list is specified, all formats are considered valid.
sub volume_has_feature {
- my ($cfg, $feature, $volid, $snap, $running) = @_;
+ my ($cfg, $feature, $volid, $snap, $running, $opts) = @_;
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_has_feature($scfg, $feature, $storeid, $volname, $snap, $running);
+ return $plugin->volume_has_feature($scfg, $feature, $storeid, $volname, $snap, $running, $opts);
} elsif ($volid =~ m|^(/.+)$| && -e $volid) {
return undef;
} else {
}
sub volume_snapshot_list {
- my ($cfg, $volid, $prefix) = @_;
+ 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, $prefix);
+ 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.
- # youngest snap first
}
sub get_image_dir {
if ($sid) {
my ($vtype, undef, $ownervm) = parse_volname($cfg, $volid);
if ($vtype eq 'iso' || $vtype eq 'vztmpl') {
- # we simply allow access
+ # require at least read access to storage, (custom) templates/ISOs could be sensitive
+ $rpcenv->check_any($user, "/storage/$sid", ['Datastore.AllocateSpace', 'Datastore.Audit']);
} elsif (defined($ownervm) && defined($vmid) && ($ownervm == $vmid)) {
# we are owner - allow access
} elsif ($vtype eq 'backup' && $ownervm) {
my $tmpldir = $plugin->get_subdir($scfg, 'vztmpl');
my $backupdir = $plugin->get_subdir($scfg, 'backup');
my $privatedir = $plugin->get_subdir($scfg, 'rootdir');
+ my $snippetsdir = $plugin->get_subdir($scfg, 'snippets');
if ($path =~ m!^$imagedir/(\d+)/([^/\s]+)$!) {
my $vmid = $1;
return ('images', $info->{volid});
}
}
- } elsif ($path =~ m!^$isodir/([^/]+\.[Ii][Ss][Oo])$!) {
+ } elsif ($path =~ m!^$isodir/([^/]+$iso_extension_re)$!) {
my $name = $1;
return ('iso', "$sid:iso/$name");
} elsif ($path =~ m!^$tmpldir/([^/]+\.tar\.gz)$!) {
} elsif ($path =~ m!^$privatedir/(\d+)$!) {
my $vmid = $1;
return ('rootdir', "$sid:rootdir/$vmid");
- } elsif ($path =~ m!^$backupdir/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz|vma|vma\.gz|vma\.lzo))$!) {
+ } elsif ($path =~ m!^$backupdir/([^/]+\.(?:tgz|(?:(?:tar|vma)(?:\.(?:${\PVE::Storage::Plugin::COMPRESSOR_RE}))?)))$!) {
+ my $name = $1;
+ return ('backup', "$sid:backup/$name");
+ } elsif ($path =~ m!^$snippetsdir/([^/]+)$!) {
my $name = $1;
- return ('iso', "$sid:backup/$name");
+ return ('snippets', "$sid:snippets/$name");
}
}
my ($cfg, $volid) = @_;
my $path;
- if (PVE::Storage::parse_volume_id ($volid, 1)) {
- PVE::Storage::activate_volumes($cfg, [ $volid ]);
+ if (parse_volume_id ($volid, 1)) {
+ activate_volumes($cfg, [ $volid ]);
$path = PVE::Storage::path($cfg, $volid);
} else {
if (-f $volid) {
return $path;
}
-sub storage_migrate {
- my ($cfg, $volid, $target_host, $target_storeid, $target_volname, $base_snapshot) = @_;
-
- my ($storeid, $volname) = parse_volume_id($volid);
- $target_volname = $volname if !$target_volname;
-
- my $scfg = storage_config($cfg, $storeid);
-
- # no need to migrate shared content
- return if $storeid eq $target_storeid && $scfg->{shared};
+my $volname_for_storage = sub {
+ my ($cfg, $volid, $target_storeid) = @_;
- my $tcfg = storage_config($cfg, $target_storeid);
+ my (undef, $name, $vmid, undef, undef, undef, $format) = parse_volname($cfg, $volid);
+ my $target_scfg = storage_config($cfg, $target_storeid);
- my $target_volid = "${target_storeid}:${target_volname}";
+ my (undef, $valid_formats) = PVE::Storage::Plugin::default_format($target_scfg);
+ my $format_is_valid = grep { $_ eq $format } @$valid_formats;
+ die "unsupported format '$format' for storage type $target_scfg->{type}\n" if !$format_is_valid;
- my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_host'";
+ (my $name_without_extension = $name) =~ s/\.$format$//;
- my $sshoptions = "-o 'BatchMode=yes'";
- my $ssh = "/usr/bin/ssh $sshoptions";
+ if ($target_scfg->{path}) {
+ return "$vmid/$name_without_extension.$format";
+ } else {
+ return "$name_without_extension";
+ }
+};
- local $ENV{RSYNC_RSH} = $ssh;
+sub storage_migrate {
+ my ($cfg, $volid, $target_sshinfo, $target_storeid, $opts, $logfunc) = @_;
- my $no_incremental = sub {
- my ($type) = @_;
- die "incremental migration not supported on storage type $type\n"
- if defined($base_snapshot);
- };
+ my $base_snapshot = $opts->{base_snapshot};
+ my $snapshot = $opts->{snapshot};
+ my $ratelimit_bps = $opts->{ratelimit_bps};
+ my $insecure = $opts->{insecure};
+ my $with_snapshots = $opts->{with_snapshots} ? 1 : 0;
+ my $allow_rename = $opts->{allow_rename} ? 1 : 0;
- # only implemented for file system based storage
- if ($scfg->{path}) {
- $no_incremental->($scfg->{type});
+ my ($storeid, $volname) = parse_volume_id($volid);
- 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);
- my $dst = $dst_plugin->path($tcfg, $target_volname, $target_storeid);
+ my $scfg = storage_config($cfg, $storeid);
- my $dirname = dirname($dst);
+ # no need to migrate shared content
+ return $volid if $storeid eq $target_storeid && $scfg->{shared};
- if ($tcfg->{shared}) { # we can do a local copy
+ my $tcfg = storage_config($cfg, $target_storeid);
- run_command(['/bin/mkdir', '-p', $dirname]);
+ my $target_volname;
+ if ($opts->{target_volname}) {
+ $target_volname = $opts->{target_volname};
+ } elsif ($scfg->{type} eq $tcfg->{type}) {
+ $target_volname = $volname;
+ } else {
+ $target_volname = $volname_for_storage->($cfg, $volid, $target_storeid);
+ }
- run_command(['/bin/cp', $src, $dst]);
+ my $target_volid = "${target_storeid}:${target_volname}";
- } else {
- run_command(['/usr/bin/ssh', "root\@${target_host}",
- '/bin/mkdir', '-p', $dirname]);
+ my $target_ip = $target_sshinfo->{ip};
- # 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],
- outfunc => sub {});
- }
+ my $ssh = PVE::SSHInfo::ssh_info_to_command($target_sshinfo);
+ my $ssh_base = PVE::SSHInfo::ssh_info_to_command_base($target_sshinfo);
+ local $ENV{RSYNC_RSH} = PVE::Tools::cmd2string($ssh_base);
- my $cmd;
- if ($format eq 'subvol') {
- $cmd = ['/usr/bin/rsync', '--progress', '-X', '-A', '--numeric-ids',
- '-aH', '--delete', '--no-whole-file', '--inplace',
- '--one-file-system', "$src/", "[root\@${target_host}]:$dst"];
- } else {
- $cmd = ['/usr/bin/rsync', '--progress', '--sparse', '--whole-file',
- $src, "[root\@${target_host}]:$dst"];
- }
+ my @cstream = ([ '/usr/bin/cstream', '-t', $ratelimit_bps ])
+ if defined($ratelimit_bps);
- my $percent = -1;
+ my $migration_snapshot;
+ if (!defined($snapshot)) {
+ if ($scfg->{type} eq 'zfspool') {
+ $migration_snapshot = 1;
+ $snapshot = '__migration__';
+ }
+ }
- run_command($cmd, outfunc => sub {
- my $line = shift;
+ my @formats = volume_transfer_formats($cfg, $volid, $target_volid, $snapshot, $base_snapshot, $with_snapshots);
+ die "cannot migrate from storage type '$scfg->{type}' to '$tcfg->{type}'\n" if !@formats;
+ my $format = $formats[0];
- if ($line =~ m/^\s*(\d+\s+(\d+)%\s.*)$/) {
- if ($2 > $percent) {
- $percent = $2;
- print "rsync status: $1\n";
- *STDOUT->flush();
- }
- } else {
- print "$line\n";
- *STDOUT->flush();
- }
- });
- }
- } else {
- die "$errstr - target type '$tcfg->{type}' not implemented\n";
- }
+ my $import_fn = '-'; # let pvesm import read from stdin per default
+ if ($insecure) {
+ my $net = $target_sshinfo->{network} // $target_sshinfo->{ip};
+ $import_fn = "tcp://$net";
+ }
- } elsif ($scfg->{type} eq 'zfspool') {
+ my $target_apiver = 1; # if there is no apiinfo call, assume 1
+ my $get_api_version = [@$ssh, 'pvesm', 'apiinfo'];
+ my $match_api_version = sub { $target_apiver = $1 if $_[0] =~ m!^APIVER (\d+)$!; };
+ eval { run_command($get_api_version, logfunc => $match_api_version); };
- if ($tcfg->{type} eq 'zfspool') {
+ my $send = ['pvesm', 'export', $volid, $format, '-', '-with-snapshots', $with_snapshots];
+ my $recv = [@$ssh, '--', 'pvesm', 'import', $target_volid, $format, $import_fn, '-with-snapshots', $with_snapshots];
+ if (defined($snapshot)) {
+ push @$send, '-snapshot', $snapshot
+ }
+ if ($migration_snapshot) {
+ push @$recv, '-delete-snapshot', $snapshot;
+ }
+ push @$recv, '-allow-rename', $allow_rename if $target_apiver >= 5;
- die "$errstr - pool on target does not have the same name as on source!"
- if $tcfg->{pool} ne $scfg->{pool};
+ if (defined($base_snapshot)) {
+ # Check if the snapshot exists on the remote side:
+ push @$send, '-base', $base_snapshot;
+ push @$recv, '-base', $base_snapshot;
+ }
- my (undef, $volname) = parse_volname($cfg, $volid);
- my $zfspath = "$scfg->{pool}\/$volname";
+ my $new_volid;
+ my $pattern = volume_imported_message(undef, 1);
+ my $match_volid_and_log = sub {
+ my $line = shift;
- my @formats = volume_transfer_formats($cfg, $volid, $volid, '__migration__', $base_snapshot, 1);
- die "cannot migrate from storage type '$scfg->{type}' to '$tcfg->{type}'\n" if !@formats;
- my $format = $formats[0];
+ $new_volid = $1 if ($line =~ $pattern);
- my $send = ['pvesm', 'export', $volid, $format, '-', '-snapshot', '__migration__', '-with-snapshots', '1'];
- my $recv = ['ssh', "root\@$target_host", '--', 'pvesm', 'import', $volid, $format, '-', '-with-snapshots', '1'];
- my $free = ['ssh', "root\@$target_host", '--', 'pvesm', 'free', $volid, '-snapshot', '__migration__'];
+ if ($logfunc) {
+ chomp($line);
+ $logfunc->($line);
+ }
+ };
- 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) {
+ 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";
+ # we won't be reading from the socket
+ shutdown($socket, 0);
+ run_command([$send, @cstream], output => '>&'.fileno($socket), errfunc => $logfunc);
+ # don't close the connection entirely otherwise the receiving end
+ # might not get all buffered data (and fails with 'connection reset by peer')
+ shutdown($socket, 1);
+
+ # wait for the remote process to finish
+ while (my $line = <$info>) {
+ $match_volid_and_log->("[$target_sshinfo->{name}] $line");
}
- volume_snapshot($cfg, $volid, '__migration__');
- eval {
- run_command([$send, $recv]);
- };
- my $err = $@;
- warn "send/receive failed, cleaning up snapshot(s)..\n" if $err;
- eval { volume_snapshot_delete($cfg, $volid, '__migration__', 0) };
- warn "could not remove source snapshot: $@\n" if $@;
- eval { run_command($free) };
- warn "could not remove target 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});
-
- 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(['/usr/bin/ssh', "root\@${target_host}",
- 'pvesm', 'alloc', $target_storeid, $vmid,
- $target_volname, int($size/1024)]);
-
- eval {
- if ($tcfg->{type} eq 'lvmthin') {
- run_command([["dd", "if=$src", "bs=4k"],["/usr/bin/ssh", "root\@${target_host}",
- "dd", 'conv=sparse', "of=$dst", "bs=4k"]]);
- } else {
- run_command([["dd", "if=$src", "bs=4k"],["/usr/bin/ssh", "root\@${target_host}",
- "dd", "of=$dst", "bs=4k"]]);
- }
- };
- if (my $err = $@) {
- run_command(['/usr/bin/ssh', "root\@${target_host}",
- 'pvesm', 'free', $target_volid]);
- die $err;
+ # now close the socket
+ close($socket);
+ if (!close($info)) { # does waitpid()
+ die "import failed: $!\n" if $!;
+ die "import failed: exit code ".($?>>8)."\n";
}
} else {
- die "$errstr - migrate from source type '$scfg->{type}' to '$tcfg->{type}' not implemented\n";
+ run_command([$send, @cstream, $recv], logfunc => $match_volid_and_log);
}
- } else {
- die "$errstr - source type '$scfg->{type}' not implemented\n";
+
+ die "unable to get ID of the migrated volume\n"
+ if !defined($new_volid) && $target_apiver >= 5;
+ };
+ 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;
+
+ return $new_volid // $target_volid;
}
sub vdisk_clone {
});
}
+sub map_volume {
+ my ($cfg, $volid, $snapname) = @_;
+
+ my ($storeid, $volname) = parse_volume_id($volid);
+
+ my $scfg = storage_config($cfg, $storeid);
+
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
+
+ return $plugin->map_volume($storeid, $scfg, $volname, $snapname);
+}
+
+sub unmap_volume {
+ my ($cfg, $volid, $snapname) = @_;
+
+ my ($storeid, $volname) = parse_volume_id($volid);
+
+ my $scfg = storage_config($cfg, $storeid);
+
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
+
+ return $plugin->unmap_volume($storeid, $scfg, $volname, $snapname);
+}
+
sub vdisk_alloc {
my ($cfg, $storeid, $vmid, $fmt, $name, $size) = @_;
$rpcenv->fork_worker('imgdel', undef, $authuser, $cleanup_worker);
}
-#list iso or openvz template ($tt = <iso|vztmpl|backup>)
-sub template_list {
- my ($cfg, $storeid, $tt) = @_;
-
- die "unknown template type '$tt'\n"
- if !($tt eq 'iso' || $tt eq 'vztmpl' || $tt eq 'backup');
-
- my $ids = $cfg->{ids};
-
- storage_check_enabled($cfg, $storeid) if ($storeid);
-
- my $res = {};
-
- # query the storage
-
- foreach my $sid (keys %$ids) {
- next if $storeid && $storeid ne $sid;
-
- my $scfg = $ids->{$sid};
- my $type = $scfg->{type};
-
- next if !storage_check_enabled($cfg, $sid, undef, 1);
-
- next if $tt eq 'iso' && !$scfg->{content}->{iso};
- next if $tt eq 'vztmpl' && !$scfg->{content}->{vztmpl};
- next if $tt eq 'backup' && !$scfg->{content}->{backup};
-
- activate_storage($cfg, $sid);
-
- if ($scfg->{path}) {
- my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
-
- my $path = $plugin->get_subdir($scfg, $tt);
-
- foreach my $fn (<$path/*>) {
-
- my $info;
-
- if ($tt eq 'iso') {
- next if $fn !~ m!/([^/]+\.[Ii][Ss][Oo])$!;
-
- $info = { volid => "$sid:iso/$1", format => 'iso' };
-
- } elsif ($tt eq 'vztmpl') {
- next if $fn !~ m!/([^/]+\.tar\.([gx]z))$!;
-
- $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))$!;
-
- $info = { volid => "$sid:backup/$1", format => $2 };
- }
-
- $info->{size} = -s $fn;
-
- push @{$res->{$sid}}, $info;
- }
-
- }
-
- @{$res->{$sid}} = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @{$res->{$sid}} if $res->{$sid};
- }
-
- return $res;
-}
-
-
sub vdisk_list {
my ($cfg, $storeid, $vmid, $vollist) = @_;
return $res;
}
+sub template_list {
+ my ($cfg, $storeid, $tt) = @_;
+
+ die "unknown template type '$tt'\n"
+ if !($tt eq 'iso' || $tt eq 'vztmpl' || $tt eq 'backup' || $tt eq 'snippets');
+
+ my $ids = $cfg->{ids};
+
+ storage_check_enabled($cfg, $storeid) if ($storeid);
+
+ my $res = {};
+
+ # query the storage
+ foreach my $sid (keys %$ids) {
+ next if $storeid && $storeid ne $sid;
+
+ my $scfg = $ids->{$sid};
+ my $type = $scfg->{type};
+
+ next if !$scfg->{content}->{$tt};
+
+ next if !storage_check_enabled($cfg, $sid, undef, 1);
+
+ $res->{$sid} = volume_list($cfg, $sid, undef, $tt);
+ }
+
+ return $res;
+}
+
sub volume_list {
my ($cfg, $storeid, $vmid, $content) = @_;
- my @ctypes = qw(images vztmpl iso backup);
+ my @ctypes = qw(rootdir images vztmpl iso backup snippets);
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}};
- }
- }
- }
+ $cts = [ grep { defined($scfg->{content}->{$_}) } @$cts ];
- next if !$data || !$data->{$storeid};
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
- foreach my $item (@{$data->{$storeid}}) {
- $item->{content} = $ct;
- push @$res, $item;
- }
- }
+ activate_storage($cfg, $storeid);
+
+ my $res = $plugin->list_volumes($storeid, $scfg, $vmid, $cts);
+
+ @$res = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @$res;
return $res;
}
}
sub storage_info {
- my ($cfg, $content) = @_;
+ my ($cfg, $content, $includeformat) = @_;
my $ids = $cfg->{ids};
my $slist = [];
foreach my $storeid (keys %$ids) {
-
- next if !storage_check_enabled($cfg, $storeid, undef, 1);
+ my $storage_enabled = defined(storage_check_enabled($cfg, $storeid, undef, 1));
if (defined($content)) {
my $want_ctype = 0;
last;
}
}
- next if !$want_ctype;
+ next if !$want_ctype || !$storage_enabled;
}
my $type = $ids->{$storeid}->{type};
shared => $ids->{$storeid}->{shared} ? 1 : 0,
content => PVE::Storage::Plugin::content_hash_to_string($ids->{$storeid}->{content}),
active => 0,
+ enabled => $storage_enabled ? 1 : 0,
};
push @$slist, $storeid;
foreach my $storeid (keys %$ids) {
my $scfg = $ids->{$storeid};
+
next if !$info->{$storeid};
+ next if !$info->{$storeid}->{enabled};
+
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
+ if ($includeformat) {
+ my $pd = $plugin->plugindata();
+ $info->{$storeid}->{format} = $pd->{format}
+ if $pd->{format};
+ $info->{$storeid}->{select_existing} = $pd->{select_existing}
+ if $pd->{select_existing};
+ }
eval { activate_storage($cfg, $storeid, $cache); };
if (my $err = $@) {
next;
}
- my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
- my ($total, $avail, $used, $active);
- eval { ($total, $avail, $used, $active) = $plugin->status($storeid, $scfg, $cache); };
+ my ($total, $avail, $used, $active) = eval { $plugin->status($storeid, $scfg, $cache); };
warn $@ if $@;
next if !$active;
$info->{$storeid}->{total} = int($total);
return $res;
}
+sub scan_cifs {
+ my ($server_in, $user, $password, $domain) = @_;
+
+ my $server;
+ if (!($server = resolv_server ($server_in))) {
+ die "unable to resolve address for server '${server_in}'\n";
+ }
+
+ # we support only Windows grater than 2012 cifsscan so use smb3
+ my $cmd = ['/usr/bin/smbclient', '-m', 'smb3', '-d', '0', '-L', $server];
+ if (defined($user)) {
+ die "password is required" if !defined($password);
+ push @$cmd, '-U', "$user\%$password";
+ push @$cmd, '-W', $domain if defined($domain);
+ } else {
+ push @$cmd, '-N';
+ }
+
+ my $res = {};
+ run_command($cmd,
+ outfunc => sub {
+ my $line = shift;
+ if ($line =~ m/(\S+)\s*Disk\s*(\S*)/) {
+ $res->{$1} = $2;
+ } elsif ($line =~ m/(NT_STATUS_(\S*))/) {
+ $res->{$1} = '';
+ }
+ },
+ errfunc => sub {},
+ noerr => 1
+ );
+
+ return $res;
+}
+
sub scan_zfs {
- my $cmd = ['zfs', 'list', '-t', 'filesystem', '-H', '-o', 'name,avail,used'];
+ my $cmd = ['zfs', 'list', '-t', 'filesystem', '-Hp', '-o', 'name,avail,used'];
my $res = [];
run_command($cmd, outfunc => sub {
if ($line =~m/^(\S+)\s+(\S+)\s+(\S+)$/) {
my ($pool, $size_str, $used_str) = ($1, $2, $3);
- my $size = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($size_str);
- my $used = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($used_str);
+ my $size = $size_str + 0;
+ my $used = $used_str + 0;
# ignore subvolumes generated by our ZFSPoolPlugin
return if $pool =~ m!/subvol-\d+-[^/]+$!;
return if $pool =~ m!/basevol-\d+-[^/]+$!;
raise_param_exc({ portal => "unable to resolve portal address '$portal'" });
}
-# idea is from usbutils package (/usr/bin/usb-devices) script
-sub __scan_usb_device {
- my ($res, $devpath, $parent, $level) = @_;
-
- return if ! -d $devpath;
- return if $level && $devpath !~ m/^.*[-.](\d+)$/;
- my $port = $level ? int($1 - 1) : 0;
-
- my $busnum = int(file_read_firstline("$devpath/busnum"));
- my $devnum = int(file_read_firstline("$devpath/devnum"));
-
- my $d = {
- port => $port,
- level => $level,
- busnum => $busnum,
- devnum => $devnum,
- speed => file_read_firstline("$devpath/speed"),
- class => hex(file_read_firstline("$devpath/bDeviceClass")),
- vendid => file_read_firstline("$devpath/idVendor"),
- prodid => file_read_firstline("$devpath/idProduct"),
- };
-
- if ($level) {
- my $usbpath = $devpath;
- $usbpath =~ s|^.*/\d+\-||;
- $d->{usbpath} = $usbpath;
- }
-
- my $product = file_read_firstline("$devpath/product");
- $d->{product} = $product if $product;
-
- my $manu = file_read_firstline("$devpath/manufacturer");
- $d->{manufacturer} = $manu if $manu;
-
- my $serial => file_read_firstline("$devpath/serial");
- $d->{serial} = $serial if $serial;
-
- push @$res, $d;
-
- foreach my $subdev (<$devpath/$busnum-*>) {
- next if $subdev !~ m|/$busnum-[0-9]+(\.[0-9]+)*$|;
- __scan_usb_device($res, $subdev, $devnum, $level + 1);
- }
-
-};
-
-sub scan_usb {
-
- my $devlist = [];
-
- foreach my $device (</sys/bus/usb/devices/usb*>) {
- __scan_usb_device($devlist, $device, 0, 0);
- }
-
- return $devlist;
-}
sub scan_iscsi {
my ($portal_in) = @_;
}
}
+sub decompressor_info {
+ my ($format, $comp) = @_;
+
+ if ($format eq 'tgz' && !defined($comp)) {
+ ($format, $comp) = ('tar', 'gz');
+ }
+
+ my $decompressor = {
+ tar => {
+ gz => ['tar', '-z'],
+ lzo => ['tar', '--lzop'],
+ zst => ['tar', '--zstd'],
+ },
+ vma => {
+ gz => ['zcat'],
+ lzo => ['lzop', '-d', '-c'],
+ zst => ['zstd', '-q', '-d', '-c'],
+ },
+ };
+
+ die "ERROR: archive format not defined\n"
+ if !defined($decompressor->{$format});
+
+ my $decomp = $decompressor->{$format}->{$comp} if $comp;
+
+ my $info = {
+ format => $format,
+ compression => $comp,
+ decompressor => $decomp,
+ };
+
+ return $info;
+}
+
+sub archive_info {
+ my ($archive) = shift;
+ my $info;
+
+ my $volid = basename($archive);
+ if ($volid =~ /^(vzdump-(lxc|openvz|qemu)-\d+-.+\.(tgz$|tar|vma)(?:\.(${\PVE::Storage::Plugin::COMPRESSOR_RE}))?)$/) {
+ my $filename = "$1"; # untaint
+ my ($type, $format, $comp) = ($2, $3, $4);
+ my $format_re = defined($comp) ? "$format.$comp" : "$format";
+ $info = decompressor_info($format, $comp);
+ $info->{filename} = $filename;
+ $info->{type} = $type;
+
+ if ($volid =~ /^(vzdump-${type}-([1-9][0-9]{2,8})-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2}))\.${format_re}$/) {
+ $info->{logfilename} = "$1.log";
+ $info->{vmid} = int($2);
+ $info->{ctime} = timelocal($8, $7, $6, $5, $4 - 1, $3 - 1900);
+ $info->{is_std_name} = 1;
+ } else {
+ $info->{is_std_name} = 0;
+ }
+ } else {
+ die "ERROR: couldn't determine archive info from '$archive'\n";
+ }
+
+ return $info;
+}
+
sub extract_vzdump_config_tar {
my ($archive, $conf_re) = @_;
$raw .= "$output\n";
};
- PVE::Tools::run_command(['tar', '-xpOf', $archive, $file, '--occurrence'], outfunc => $out);
+ 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";
- };
+ my $out = sub { $raw .= "$_[0]\n"; };
+ my $info = archive_info($archive);
+ $comp //= $info->{compression};
+ my $decompressor = $info->{decompressor};
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", "-"]];
+ my $cmd = [ [@$decompressor, $archive], ["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
+ # lzop/zcat exits with 1 when the 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: <stdout>/ || $output =~ m/gzip: stdout: Broken pipe/) {
+ if ($output =~ m/lzop: Broken pipe: <stdout>/ || $output =~ m/gzip: stdout: Broken pipe/ || $output =~ m/zstd: error 70 : Write error : 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 $rc = eval { 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) {
+ $broken_pipe ||= $rc == 141; # broken pipe from vma POV
+
+ if (!$errstring && !$broken_pipe && $rc != 0) {
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);
+ run_command(["vma", "config", $archive], outfunc => $out);
}
return wantarray ? ($raw, undef) : $raw;
sub extract_vzdump_config {
my ($cfg, $volid) = @_;
+ my ($storeid, $volname) = parse_volume_id($volid);
+ if (defined($storeid)) {
+ my $scfg = storage_config($cfg, $storeid);
+ if ($scfg->{type} eq 'pbs') {
+ storage_check_enabled($cfg, $storeid);
+ return PVE::Storage::PBSPlugin->extract_vzdump_config($scfg, $volname, $storeid);
+ }
+ }
+
my $archive = abs_filesystem_path($cfg, $volid);
+ my $info = archive_info($archive);
+ my $format = $info->{format};
+ my $comp = $info->{compression};
+ my $type = $info->{type};
- if ($volid =~ /vzdump-(lxc|openvz)-\d+-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.(tgz|(tar(\.(gz|lzo))?))$/) {
+ if ($type eq 'lxc' || $type eq 'openvz') {
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);
- }
-
+ } elsif ($type eq 'qemu') {
if ($format eq 'tar') {
return extract_vzdump_config_tar($archive, qr!\(\./qemu-server\.conf\)!);
} else {
}
sub volume_import {
- my ($cfg, $fh, $volid, $format, $base_snapshot, $with_snapshots) = @_;
+ my ($cfg, $fh, $volid, $format, $base_snapshot, $with_snapshots, $allow_rename) = @_;
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);
+ $base_snapshot, $with_snapshots, $allow_rename) // $volid;
}
sub volume_export_formats {
my $scfg = storage_config($cfg, $storeid);
my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
return $plugin->volume_export_formats($scfg, $storeid, $volname,
- $base_snapshot, $with_snapshots);
+ $snapshot, $base_snapshot,
+ $with_snapshots);
}
sub volume_import_formats {
return @common;
}
+sub volume_imported_message {
+ my ($volid, $want_pattern) = @_;
+
+ if ($want_pattern) {
+ return qr/successfully imported '([^']*)'$/;
+ } else {
+ return "successfully imported '$volid'\n";
+ }
+}
+
# bash completion helper
sub complete_storage {
sub complete_content_type {
my ($cmdname, $pname, $cvalue) = @_;
- return [qw(rootdir images vztmpl iso backup)];
+ return [qw(rootdir images vztmpl iso backup snippets)];
}
sub complete_volume {
return $res;
}
+# Various io-heavy operations require io/bandwidth limits which can be
+# configured on multiple levels: The global defaults in datacenter.cfg, and
+# per-storage overrides. When we want to do a restore from storage A to storage
+# B, we should take the smaller limit defined for storages A and B, and if no
+# such limit was specified, use the one from datacenter.cfg.
+sub get_bandwidth_limit {
+ my ($operation, $storage_list, $override) = @_;
+
+ # called for each limit (global, per-storage) with the 'default' and the
+ # $operation limit and should udpate $override for every limit affecting
+ # us.
+ my $use_global_limits = 0;
+ my $apply_limit = sub {
+ my ($bwlimit) = @_;
+ if (defined($bwlimit)) {
+ my $limits = PVE::JSONSchema::parse_property_string('bwlimit', $bwlimit);
+ my $limit = $limits->{$operation} // $limits->{default};
+ if (defined($limit)) {
+ if (!$override || $limit < $override) {
+ $override = $limit;
+ }
+ return;
+ }
+ }
+ # If there was no applicable limit, try to apply the global ones.
+ $use_global_limits = 1;
+ };
+
+ my ($rpcenv, $authuser);
+ if (defined($override)) {
+ $rpcenv = PVE::RPCEnvironment->get();
+ $authuser = $rpcenv->get_user();
+ }
+
+ # Apply per-storage limits - if there are storages involved.
+ if (defined($storage_list) && @$storage_list) {
+ my $config = config();
+
+ # The Datastore.Allocate permission allows us to modify the per-storage
+ # limits, therefore it also allows us to override them.
+ # Since we have most likely multiple storages to check, do a quick check on
+ # the general '/storage' path to see if we can skip the checks entirely:
+ return $override if $rpcenv && $rpcenv->check($authuser, '/storage', ['Datastore.Allocate'], 1);
+
+ my %done;
+ foreach my $storage (@$storage_list) {
+ next if !defined($storage);
+ # Avoid duplicate checks:
+ next if $done{$storage};
+ $done{$storage} = 1;
+
+ # Otherwise we may still have individual /storage/$ID permissions:
+ if (!$rpcenv || !$rpcenv->check($authuser, "/storage/$storage", ['Datastore.Allocate'], 1)) {
+ # And if not: apply the limits.
+ my $storecfg = storage_config($config, $storage);
+ $apply_limit->($storecfg->{bwlimit});
+ }
+ }
+
+ # Storage limits take precedence over the datacenter defaults, so if
+ # a limit was applied:
+ return $override if !$use_global_limits;
+ }
+
+ # Sys.Modify on '/' means we can change datacenter.cfg which contains the
+ # global default limits.
+ if (!$rpcenv || !$rpcenv->check($authuser, '/', ['Sys.Modify'], 1)) {
+ # So if we cannot modify global limits, apply them to our currently
+ # requested override.
+ my $dc = cfs_read_file('datacenter.cfg');
+ $apply_limit->($dc->{bwlimit});
+ }
+
+ return $override;
+}
+
+# checks if the storage id is available and dies if not
+sub assert_sid_unused {
+ my ($sid) = @_;
+
+ my $cfg = config();
+ if (my $scfg = storage_config($cfg, $sid, 1)) {
+ die "storage ID '$sid' already defined\n";
+ }
+
+ return undef;
+}
+
1;
projects / pve-storage.git / blobdiff