PVE/Storage.pm

   1 package PVE::Storage;
   2
   3 use strict;
   4 use POSIX;
   5 use IO::Select;
   6 use IO::Dir;
   7 use IO::File;
   8 use Fcntl ':flock';
   9 use File::stat;
  10 use File::Basename;
  11 use File::Path;
  12 use IPC::Open2;
  13 use Cwd 'abs_path';
  14 use Getopt::Long qw(GetOptionsFromArray);
  15 use Socket;
  16 use Digest::SHA;
  17 use Net::Ping;
  18
  19 use PVE::Tools qw(run_command file_read_firstline trim dir_glob_regex dir_glob_foreach);
  20 use PVE::Cluster qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
  21 use PVE::Exception qw(raise_param_exc);
  22 use PVE::JSONSchema;
  23 use PVE::INotify;
  24 use PVE::RPCEnvironment;
  25
  26 my $ISCSIADM = '/usr/bin/iscsiadm';
  27 my $UDEVADM = '/sbin/udevadm';
  28
  29 $ISCSIADM = undef if ! -X $ISCSIADM;
  30
  31 # fixme: always_call_parser => 1 ??
  32 cfs_register_file ('storage.cfg',
  33                    \&parse_config,
  34                    \&write_config);
  35
  36 # generic utility function
  37
  38 sub config {
  39     return cfs_read_file("storage.cfg");
  40 }
  41
  42 sub check_iscsi_support {
  43     my $noerr = shift;
  44
  45     if (!$ISCSIADM) {
  46         my $msg = "no iscsi support - please install open-iscsi";
  47         if ($noerr) {
  48             warn "warning: $msg\n";
  49             return 0;
  50         }
  51
  52         die "error: $msg\n";
  53     }
  54
  55     return 1;
  56 }
  57
  58 sub load_stable_scsi_paths {
  59
  60     my $stable_paths = {};
  61
  62     my $stabledir = "/dev/disk/by-id";
  63
  64     if (my $dh = IO::Dir->new($stabledir)) {
  65        while (defined(my $tmp = $dh->read)) {
  66            # exclude filenames with part in name (same disk but partitions)
  67            # use only filenames with scsi(with multipath i have the same device
  68            # with dm-uuid-mpath , dm-name and scsi in name)
  69            if($tmp !~ m/-part\d+$/ && $tmp =~ m/^scsi-/) {
  70                  my $path = "$stabledir/$tmp";
  71                  my $bdevdest = readlink($path);
  72                  if ($bdevdest && $bdevdest =~ m|^../../([^/]+)|) {
  73                      $stable_paths->{$1}=$tmp;
  74                  }
  75            }
  76        }
  77        $dh->close;
  78     }
  79     return $stable_paths;
  80 }
  81
  82 sub read_proc_mounts {
  83
  84     local $/; # enable slurp mode
  85
  86     my $data = "";
  87     if (my $fd = IO::File->new ("/proc/mounts", "r")) {
  88         $data = <$fd>;
  89         close ($fd);
  90     }
  91
  92     return $data;
  93 }
  94
  95 #  PVE::Storage utility functions
  96
  97 sub lock_storage_config {
  98     my ($code, $errmsg) = @_;
  99
 100     cfs_lock_file("storage.cfg", undef, $code);
 101     my $err = $@;
 102     if ($err) {
 103         $errmsg ? die "$errmsg: $err" : die $err;
 104     }
 105 }
 106
 107 my $confvars = {
 108     path => 'path',
 109     shared => 'bool',
 110     disable => 'bool',
 111     saferemove => 'bool',
 112     format => 'format',
 113     content => 'content',
 114     server => 'server',
 115     export => 'path',
 116     vgname => 'vgname',
 117     base   => 'volume',
 118     portal => 'portal',
 119     target => 'target',
 120     nodes => 'nodes',
 121     options => 'options',
 122     maxfiles => 'natural',
 123 };
 124
 125 my $required_config = {
 126     dir => ['path'],
 127     nfs => ['path', 'server', 'export'],
 128     lvm => ['vgname'],
 129     iscsi => ['portal', 'target'],
 130 };
 131
 132 my $fixed_config = {
 133     dir => ['path'],
 134     nfs => ['path', 'server', 'export'],
 135     lvm => ['vgname', 'base'],
 136     iscsi => ['portal', 'target'],
 137 };
 138
 139 my $default_config = {
 140     dir => {
 141         path => 1,
 142         nodes => 0,
 143         shared => 0,
 144         disable => 0,
 145         maxfiles => 0,
 146         content => [ { images => 1, rootdir => 1, vztmpl => 1, iso => 1, backup => 1, none => 1 },
 147                      { images => 1,  rootdir => 1 }],
 148         format => [ { raw => 1, qcow2 => 1, vmdk => 1 } , 'raw' ],
 149     },
 150
 151     nfs => {
 152         path => 1,
 153         nodes => 0,
 154         disable => 0,
 155         server => 1,
 156         export => 1,
 157         options => 0,
 158         maxfiles => 0,
 159         content => [ { images => 1, rootdir => 1, vztmpl => 1, iso => 1, backup => 1},
 160                      { images => 1 }],
 161         format => [ { raw => 1, qcow2 => 1, vmdk => 1 } , 'raw' ],
 162     },
 163
 164     lvm => {
 165         vgname => 1,
 166         nodes => 0,
 167         shared => 0,
 168         disable => 0,
 169         saferemove => 0,
 170         content => [ {images => 1}, { images => 1 }],
 171         base => 1,
 172     },
 173
 174     iscsi => {
 175         portal => 1,
 176         target => 1,
 177         nodes => 0,
 178         disable => 0,
 179         content => [ {images => 1, none => 1}, { images => 1 }],
 180     },
 181 };
 182
 183 sub valid_content_types {
 184     my ($stype) = @_;
 185
 186     my $def = $default_config->{$stype};
 187
 188     return {} if !$def;
 189
 190     return $def->{content}->[0];
 191 }
 192
 193 sub content_hash_to_string {
 194     my $hash = shift;
 195
 196     my @cta;
 197     foreach my $ct (keys %$hash) {
 198         push @cta, $ct if $hash->{$ct};
 199     }
 200
 201     return join(',', @cta);
 202 }
 203
 204 PVE::JSONSchema::register_format('pve-storage-path', \&verify_path);
 205 sub verify_path {
 206     my ($path, $noerr) = @_;
 207
 208     # fixme: exclude more shell meta characters?
 209     # we need absolute paths
 210     if ($path !~ m|^/[^;\(\)]+|) {
 211         return undef if $noerr;
 212         die "value does not look like a valid absolute path\n";
 213     }
 214     return $path;
 215 }
 216
 217 PVE::JSONSchema::register_format('pve-storage-server', \&verify_server);
 218 sub verify_server {
 219     my ($server, $noerr) = @_;
 220
 221     # fixme: use better regex ?
 222     # IP or DNS name
 223     if ($server !~ m/^[[:alnum:]\-\.]+$/) {
 224         return undef if $noerr;
 225         die "value does not look like a valid server name or IP address\n";
 226     }
 227     return $server;
 228 }
 229
 230 PVE::JSONSchema::register_format('pve-storage-portal', \&verify_portal);
 231 sub verify_portal {
 232     my ($portal, $noerr) = @_;
 233
 234     # IP with optional port
 235     if ($portal !~ m/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d+)?$/) {
 236         return undef if $noerr;
 237         die "value does not look like a valid portal address\n";
 238     }
 239     return $portal;
 240 }
 241
 242 PVE::JSONSchema::register_format('pve-storage-portal-dns', \&verify_portal_dns);
 243 sub verify_portal_dns {
 244     my ($portal, $noerr) = @_;
 245
 246     # IP or DNS name with optional port
 247     if ($portal !~ m/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|[[:alnum:]\-\.]+)(:\d+)?$/) {
 248         return undef if $noerr;
 249         die "value does not look like a valid portal address\n";
 250     }
 251     return $portal;
 252 }
 253
 254 PVE::JSONSchema::register_format('pve-storage-content', \&verify_content);
 255 sub verify_content {
 256     my ($ct, $noerr) = @_;
 257
 258     my $valid_content = valid_content_types('dir'); # dir includes all types
 259
 260     if (!$valid_content->{$ct}) {
 261         return undef if $noerr;
 262         die "invalid content type '$ct'\n";
 263     }
 264
 265     return $ct;
 266 }
 267
 268 PVE::JSONSchema::register_format('pve-storage-format', \&verify_format);
 269 sub verify_format {
 270     my ($fmt, $noerr) = @_;
 271
 272     if ($fmt !~ m/(raw|qcow2|vmdk)/) {
 273         return undef if $noerr;
 274         die "invalid format '$fmt'\n";
 275     }
 276
 277     return $fmt;
 278 }
 279
 280 PVE::JSONSchema::register_format('pve-storage-options', \&verify_options);
 281 sub verify_options {
 282     my ($value, $noerr) = @_;
 283
 284     # mount options (see man fstab)
 285     if ($value !~ m/^\S+$/) {
 286         return undef if $noerr;
 287         die "invalid options '$value'\n";
 288     }
 289
 290     return $value;
 291 }
 292
 293 sub check_type {
 294     my ($stype, $ct, $key, $value, $storeid, $noerr) = @_;
 295
 296     my $def = $default_config->{$stype};
 297
 298     if (!$def) { # should not happen
 299         return undef if $noerr;
 300         die "unknown storage type '$stype'\n";
 301     }
 302
 303     if (!defined($def->{$key})) {
 304         return undef if $noerr;
 305         die "unexpected property\n";
 306     }
 307
 308     if (!defined ($value)) {
 309         return undef if $noerr;
 310         die "got undefined value\n";
 311     }
 312
 313     if ($value =~ m/[\n\r]/) {
 314         return undef if $noerr;
 315         die "property contains a line feed\n";
 316     }
 317
 318     if ($ct eq 'bool') {
 319         return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
 320         return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
 321         return undef if $noerr;
 322         die "type check ('boolean') failed - got '$value'\n";
 323     } elsif ($ct eq 'options') {
 324         return verify_options($value, $noerr);
 325     } elsif ($ct eq 'path') {
 326         return verify_path($value, $noerr);
 327     } elsif ($ct eq 'server') {
 328         return verify_server($value, $noerr);
 329     } elsif ($ct eq 'vgname') {
 330         return parse_lvm_name ($value, $noerr);
 331     } elsif ($ct eq 'portal') {
 332         return verify_portal($value, $noerr);
 333     } elsif ($ct eq 'natural') {
 334         return int($value) if $value =~ m/^\d+$/;
 335         return undef if $noerr;
 336         die "type check ('natural') failed - got '$value'\n";
 337     } elsif ($ct eq 'nodes') {
 338         my $res = {};
 339
 340         foreach my $node (PVE::Tools::split_list($value)) {
 341             if (PVE::JSONSchema::pve_verify_node_name($node, $noerr)) {
 342                 $res->{$node} = 1;
 343             }
 344         }
 345
 346         # no node restrictions for local storage
 347         if ($storeid && $storeid eq 'local' && scalar(keys(%$res))) {
 348             return undef if $noerr;
 349             die "storage '$storeid' does not allow node restrictions\n";
 350         }
 351
 352         return $res;
 353     } elsif ($ct eq 'target') {
 354         return $value;
 355     } elsif ($ct eq 'string') {
 356         return $value;
 357     } elsif ($ct eq 'format') {
 358         my $valid_formats = $def->{format}->[0];
 359
 360         if (!$valid_formats->{$value}) {
 361             return undef if $noerr;
 362             die "storage does not support format '$value'\n";
 363         }
 364
 365         return $value;
 366
 367     } elsif ($ct eq 'content') {
 368         my $valid_content = $def->{content}->[0];
 369
 370         my $res = {};
 371
 372         foreach my $c (PVE::Tools::split_list($value)) {
 373             if (!$valid_content->{$c}) {
 374                 return undef if $noerr;
 375                 die "storage does not support content type '$c'\n";
 376             }
 377             $res->{$c} = 1;
 378         }
 379
 380         if ($res->{none} && scalar (keys %$res) > 1) {
 381                 return undef if $noerr;
 382                 die "unable to combine 'none' with other content types\n";
 383         }
 384
 385         return $res;
 386     } elsif ($ct eq 'volume') {
 387         return $value if parse_volume_id ($value, $noerr);
 388     }
 389
 390     return undef if $noerr;
 391     die "type check not implemented - internal error\n";
 392 }
 393
 394 sub parse_config {
 395     my ($filename, $raw) = @_;
 396
 397     my $ids = {};
 398
 399     my $digest = Digest::SHA::sha1_hex(defined($raw) ? $raw : '');
 400
 401     my $pri = 0;
 402
 403     while ($raw && $raw =~ s/^(.*?)(\n|$)//) {
 404         my $line = $1;
 405
 406         next if $line =~ m/^\#/;
 407         next if $line =~ m/^\s*$/;
 408
 409         if ($line =~ m/^(\S+):\s*(\S+)\s*$/) {
 410             my $storeid = $2;
 411             my $type = $1;
 412             my $ignore = 0;
 413
 414             if (!PVE::JSONSchema::parse_storage_id($storeid, 1)) {
 415                 $ignore = 1;
 416                 warn "ignoring storage '$storeid' - (illegal characters)\n";
 417             } elsif (!$default_config->{$type}) {
 418                 $ignore = 1;
 419                 warn "ignoring storage '$storeid' (unsupported type '$type')\n";
 420             } else {
 421                 $ids->{$storeid}->{type} = $type;
 422                 $ids->{$storeid}->{priority} = $pri++;
 423             }
 424
 425             while ($raw && $raw =~ s/^(.*?)(\n|$)//) {
 426                 $line = $1;
 427
 428                 next if $line =~ m/^\#/;
 429                 last if $line =~ m/^\s*$/;
 430
 431                 next if $ignore; # skip
 432
 433                 if ($line =~ m/^\s+(\S+)(\s+(.*\S))?\s*$/) {
 434                     my ($k, $v) = ($1, $3);
 435                     if (my $ct = $confvars->{$k}) {
 436                         $v = 1 if $ct eq 'bool' && !defined($v);
 437                         eval {
 438                             $ids->{$storeid}->{$k} = check_type ($type, $ct, $k, $v, $storeid);
 439                         };
 440                         warn "storage '$storeid' - unable to parse value of '$k': $@" if $@;
 441                     } else {
 442                         warn "storage '$storeid' - unable to parse value of '$k'\n";
 443                     }
 444
 445                 } else {
 446                     warn "storage '$storeid' - ignore config line: $line\n";
 447                 }
 448             }
 449         } else {
 450             warn "ignore config line: $line\n";
 451         }
 452     }
 453
 454     # make sure we have a reasonable 'local:' storage
 455     # openvz expects things to be there
 456     if (!$ids->{local} || $ids->{local}->{type} ne 'dir' ||
 457         $ids->{local}->{path} ne '/var/lib/vz') {
 458         $ids->{local} = {
 459             type => 'dir',
 460             priority => $pri++,
 461             path => '/var/lib/vz',
 462             maxfiles => 0,
 463             content => { images => 1, rootdir => 1, vztmpl => 1, iso => 1},
 464         };
 465     }
 466
 467     # we always need this for OpenVZ
 468     $ids->{local}->{content}->{rootdir} = 1;
 469     $ids->{local}->{content}->{vztmpl} = 1;
 470     delete ($ids->{local}->{disable});
 471
 472     # remove node restrictions for local storage
 473     delete($ids->{local}->{nodes});
 474
 475     foreach my $storeid (keys %$ids) {
 476         my $d = $ids->{$storeid};
 477
 478         my $req_keys = $required_config->{$d->{type}};
 479         foreach my $k (@$req_keys) {
 480             if (!defined ($d->{$k})) {
 481                 warn "ignoring storage '$storeid' - missing value " .
 482                     "for required option '$k'\n";
 483                 delete $ids->{$storeid};
 484                 next;
 485             }
 486         }
 487
 488         my $def = $default_config->{$d->{type}};
 489
 490         if ($def->{content}) {
 491             $d->{content} = $def->{content}->[1] if !$d->{content};
 492         }
 493
 494         if ($d->{type} eq 'iscsi' || $d->{type} eq 'nfs') {
 495             $d->{shared} = 1;
 496         }
 497     }
 498
 499     my $cfg = { ids => $ids, digest => $digest};
 500
 501     return $cfg;
 502 }
 503
 504 sub parse_options {
 505     my ($storeid, $stype, $param, $create) = @_;
 506
 507     my $settings = { type => $stype };
 508
 509     die "unknown storage type '$stype'\n"
 510         if !$default_config->{$stype};
 511
 512     foreach my $opt (keys %$param) {
 513         my $value = $param->{$opt};
 514
 515         my $ct = $confvars->{$opt};
 516         if (defined($value)) {
 517             eval {
 518                 $settings->{$opt} = check_type ($stype, $ct, $opt, $value, $storeid);
 519             };
 520             raise_param_exc({ $opt => $@ }) if $@;
 521         } else {
 522             raise_param_exc({ $opt => "got undefined value" });
 523         }
 524     }
 525
 526     if ($create) {
 527         my $req_keys = $required_config->{$stype};
 528         foreach my $k (@$req_keys) {
 529
 530             if ($stype eq 'nfs' && !$settings->{path}) {
 531                 $settings->{path} = "/mnt/pve/$storeid";
 532             }
 533
 534             # check if we have a value for all required options
 535             if (!defined ($settings->{$k})) {
 536                 raise_param_exc({ $k => "property is missing and it is not optional" });
 537             }
 538         }
 539     } else {
 540         my $fixed_keys = $fixed_config->{$stype};
 541         foreach my $k (@$fixed_keys) {
 542
 543             # only allow to change non-fixed values
 544
 545             if (defined ($settings->{$k})) {
 546                 raise_param_exc({$k => "can't change value (fixed parameter)"});
 547             }
 548         }
 549     }
 550
 551     return $settings;
 552 }
 553
 554 sub cluster_lock_storage {
 555     my ($storeid, $shared, $timeout, $func, @param) = @_;
 556
 557     my $res;
 558     if (!$shared) {
 559         my $lockid = "pve-storage-$storeid";
 560         my $lockdir = "/var/lock/pve-manager";
 561         mkdir $lockdir;
 562         $res = PVE::Tools::lock_file("$lockdir/$lockid", $timeout, $func, @param);
 563         die $@ if $@;
 564     } else {
 565         $res = PVE::Cluster::cfs_lock_storage($storeid, $timeout, $func, @param);
 566         die $@ if $@;
 567     }
 568     return $res;
 569 }
 570
 571 sub storage_config {
 572     my ($cfg, $storeid, $noerr) = @_;
 573
 574     die "no storage id specified\n" if !$storeid;
 575
 576     my $scfg = $cfg->{ids}->{$storeid};
 577
 578     die "storage '$storeid' does not exists\n" if (!$noerr && !$scfg);
 579
 580     return $scfg;
 581 }
 582
 583 sub storage_check_node {
 584     my ($cfg, $storeid, $node, $noerr) = @_;
 585
 586     my $scfg = storage_config ($cfg, $storeid);
 587
 588     if ($scfg->{nodes}) {
 589         $node = PVE::INotify::nodename() if !$node || ($node eq 'localhost');
 590         if (!$scfg->{nodes}->{$node}) {
 591             die "storage '$storeid' is not available on node '$node'\n" if !$noerr;
 592             return undef;
 593         }
 594     }
 595
 596     return $scfg;
 597 }
 598
 599 sub storage_check_enabled {
 600     my ($cfg, $storeid, $node, $noerr) = @_;
 601
 602     my $scfg = storage_config ($cfg, $storeid);
 603
 604     if ($scfg->{disable}) {
 605         die "storage '$storeid' is disabled\n" if !$noerr;
 606         return undef;
 607     }
 608
 609     return storage_check_node($cfg, $storeid, $node, $noerr);
 610 }
 611
 612 sub storage_ids {
 613     my ($cfg) = @_;
 614
 615     my $ids = $cfg->{ids};
 616
 617     my @sa = sort {$ids->{$a}->{priority} <=> $ids->{$b}->{priority}} keys %$ids;
 618
 619     return @sa;
 620 }
 621
 622 sub assert_if_modified {
 623     my ($cfg, $digest) = @_;
 624
 625     if ($digest && ($cfg->{digest} ne $digest)) {
 626         die "detected modified storage configuration - try again\n";
 627     }
 628 }
 629
 630 sub sprint_config_line {
 631     my ($k, $v) = @_;
 632
 633     my $ct = $confvars->{$k};
 634
 635     if ($ct eq 'bool') {
 636         return $v ? "\t$k\n" : '';
 637     } elsif ($ct eq 'nodes') {
 638         my $nlist = join(',', keys(%$v));
 639         return $nlist ? "\tnodes $nlist\n" : '';
 640     } elsif ($ct eq 'content') {
 641         my $clist = content_hash_to_string($v);
 642         if ($clist) {
 643             return "\t$k $clist\n";
 644         } else {
 645             return "\t$k none\n";
 646         }
 647     } else {
 648         return "\t$k $v\n";
 649     }
 650 }
 651
 652 sub write_config {
 653     my ($filename, $cfg) = @_;
 654
 655     my $out = '';
 656
 657     my $ids = $cfg->{ids};
 658
 659     my $maxpri = 0;
 660     foreach my $storeid (keys %$ids) {
 661         my $pri = $ids->{$storeid}->{priority};
 662         $maxpri = $pri if $pri && $pri > $maxpri;
 663     }
 664     foreach my $storeid (keys %$ids) {
 665         if (!defined ($ids->{$storeid}->{priority})) {
 666             $ids->{$storeid}->{priority} = ++$maxpri;
 667         }
 668     }
 669
 670     foreach my $storeid (sort {$ids->{$a}->{priority} <=> $ids->{$b}->{priority}} keys %$ids) {
 671         my $scfg = $ids->{$storeid};
 672         my $type = $scfg->{type};
 673         my $def = $default_config->{$type};
 674
 675         die "unknown storage type '$type'\n" if !$def;
 676
 677         my $data = "$type: $storeid\n";
 678
 679         $data .= "\tdisable\n" if $scfg->{disable};
 680
 681         my $done_hash = { disable => 1};
 682         foreach my $k (@{$required_config->{$type}}) {
 683             $done_hash->{$k} = 1;
 684             my $v =  $ids->{$storeid}->{$k};
 685             die "storage '$storeid' - missing value for required option '$k'\n"
 686                 if !defined ($v);
 687             $data .= sprint_config_line ($k, $v);
 688         }
 689
 690         foreach my $k (keys %$def) {
 691             next if defined ($done_hash->{$k});
 692             my $v = $ids->{$storeid}->{$k};
 693             next if !defined($v);
 694             $data .= sprint_config_line ($k, $v);
 695         }
 696
 697         $out .= "$data\n";
 698     }
 699
 700     return $out;
 701 }
 702
 703 sub get_image_dir {
 704     my ($cfg, $storeid, $vmid) = @_;
 705
 706     my $path = $cfg->{ids}->{$storeid}->{path};
 707     return $vmid ? "$path/images/$vmid" : "$path/images";
 708 }
 709
 710 sub get_private_dir {
 711     my ($cfg, $storeid, $vmid) = @_;
 712
 713     my $path = $cfg->{ids}->{$storeid}->{path};
 714     return $vmid ? "$path/private/$vmid" : "$path/private";
 715 }
 716
 717 sub get_iso_dir {
 718     my ($cfg, $storeid) = @_;
 719
 720     my $isodir =  $cfg->{ids}->{$storeid}->{path};
 721     $isodir .= '/template/iso';
 722
 723     return $isodir;
 724 }
 725
 726 sub get_vztmpl_dir {
 727     my ($cfg, $storeid) = @_;
 728
 729     my $tmpldir =  $cfg->{ids}->{$storeid}->{path};
 730     $tmpldir .= '/template/cache';
 731
 732     return $tmpldir;
 733 }
 734
 735 sub get_backup_dir {
 736     my ($cfg, $storeid) = @_;
 737
 738     my $dir =  $cfg->{ids}->{$storeid}->{path};
 739     $dir .= '/dump';
 740
 741     return $dir;
 742 }
 743
 744 # iscsi utility functions
 745
 746 sub iscsi_session_list {
 747
 748     check_iscsi_support ();
 749
 750     my $cmd = [$ISCSIADM, '--mode', 'session'];
 751
 752     my $res = {};
 753
 754     run_command($cmd, outfunc => sub {
 755         my $line = shift;
 756
 757         if ($line =~ m/^tcp:\s+\[(\S+)\]\s+\S+\s+(\S+)\s*$/) {
 758             my ($session, $target) = ($1, $2);
 759             # there can be several sessions per target (multipath)
 760             push @{$res->{$target}}, $session;
 761
 762         }
 763     });
 764
 765     return $res;
 766 }
 767
 768 sub iscsi_test_portal {
 769     my ($portal) = @_;
 770
 771     my ($server, $port) = split(':', $portal);
 772     my $p = Net::Ping->new("tcp", 2);
 773     $p->port_number($port || 3260);
 774     return $p->ping($server);
 775 }
 776
 777 sub iscsi_discovery {
 778     my ($portal) = @_;
 779
 780     check_iscsi_support ();
 781
 782     my $cmd = [$ISCSIADM, '--mode', 'discovery', '--type', 'sendtargets',
 783                '--portal', $portal];
 784
 785     my $res = {};
 786
 787     return $res if !iscsi_test_portal($portal); # fixme: raise exception here?
 788
 789     run_command($cmd, outfunc => sub {
 790         my $line = shift;
 791
 792         if ($line =~ m/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+)\,\S+\s+(\S+)\s*$/) {
 793             my $portal = $1;
 794             my $target = $2;
 795             # one target can have more than one portal (multipath).
 796             push @{$res->{$target}}, $portal;
 797         }
 798     });
 799
 800     return $res;
 801 }
 802
 803 sub iscsi_login {
 804     my ($target, $portal_in) = @_;
 805
 806     check_iscsi_support ();
 807
 808     eval { iscsi_discovery ($portal_in); };
 809     warn $@ if $@;
 810
 811     my $cmd = [$ISCSIADM, '--mode', 'node', '--targetname',  $target, '--login'];
 812     run_command($cmd);
 813 }
 814
 815 sub iscsi_logout {
 816     my ($target, $portal) = @_;
 817
 818     check_iscsi_support ();
 819
 820     my $cmd = [$ISCSIADM, '--mode', 'node', '--targetname', $target, '--logout'];
 821     run_command($cmd);
 822 }
 823
 824 my $rescan_filename = "/var/run/pve-iscsi-rescan.lock";
 825
 826 sub iscsi_session_rescan {
 827     my $session_list = shift;
 828
 829     check_iscsi_support ();
 830
 831     my $rstat = stat ($rescan_filename);
 832
 833     if (!$rstat) {
 834         if (my $fh = IO::File->new ($rescan_filename, "a")) {
 835             utime undef, undef, $fh;
 836             close ($fh);
 837         }
 838     } else {
 839         my $atime = $rstat->atime;
 840         my $tdiff = time() - $atime;
 841         # avoid frequent rescans
 842         return if !($tdiff < 0 || $tdiff > 10);
 843         utime undef, undef, $rescan_filename;
 844     }
 845
 846     foreach my $session (@$session_list) {
 847         my $cmd = [$ISCSIADM, '--mode', 'session', '-r', $session, '-R'];
 848         eval { run_command($cmd, outfunc => sub {}); };
 849         warn $@ if $@;
 850     }
 851 }
 852
 853 sub iscsi_device_list {
 854
 855     my $res = {};
 856
 857     my $dirname = '/sys/class/iscsi_session';
 858
 859     my $stable_paths = load_stable_scsi_paths();
 860
 861     dir_glob_foreach ($dirname, 'session(\d+)', sub {
 862         my ($ent, $session) = @_;
 863
 864         my $target = file_read_firstline ("$dirname/$ent/targetname");
 865         return if !$target;
 866
 867         my (undef, $host) = dir_glob_regex ("$dirname/$ent/device", 'target(\d+):.*');
 868         return if !defined($host);
 869
 870         dir_glob_foreach ("/sys/bus/scsi/devices", "$host:" . '(\d+):(\d+):(\d+)', sub {
 871             my ($tmp, $channel, $id, $lun) = @_;
 872
 873             my $type = file_read_firstline ("/sys/bus/scsi/devices/$tmp/type");
 874             return if !defined($type) || $type ne '0'; # list disks only
 875
 876             my $bdev;
 877             if (-d "/sys/bus/scsi/devices/$tmp/block") { # newer kernels
 878                 (undef, $bdev) = dir_glob_regex ("/sys/bus/scsi/devices/$tmp/block/", '([A-Za-z]\S*)');
 879             } else {
 880                 (undef, $bdev) = dir_glob_regex ("/sys/bus/scsi/devices/$tmp", 'block:(\S+)');
 881             }
 882             return if !$bdev;
 883
 884             #check multipath
 885             if (-d "/sys/block/$bdev/holders") {
 886                 my $multipathdev = dir_glob_regex ("/sys/block/$bdev/holders", '[A-Za-z]\S*');
 887                 $bdev = $multipathdev if $multipathdev;
 888             }
 889
 890             my $blockdev = $stable_paths->{$bdev};
 891             return if !$blockdev;
 892
 893             my $size = file_read_firstline ("/sys/block/$bdev/size");
 894             return if !$size;
 895
 896             my $volid = "$channel.$id.$lun.$blockdev";
 897
 898             $res->{$target}->{$volid} = {
 899                 'format' => 'raw',
 900                 'size' => int($size * 512),
 901                 'vmid' => 0, # not assigned to any vm
 902                 'channel' => int($channel),
 903                 'id' => int($id),
 904                 'lun' => int($lun),
 905             };
 906
 907             #print "TEST: $target $session $host,$bus,$tg,$lun $blockdev\n";
 908         });
 909
 910     });
 911
 912     return $res;
 913 }
 914
 915 # library implementation
 916
 917 PVE::JSONSchema::register_format('pve-storage-vgname', \&parse_lvm_name);
 918 sub parse_lvm_name {
 919     my ($name, $noerr) = @_;
 920
 921     if ($name !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
 922         return undef if $noerr;
 923         die "lvm name '$name' contains illegal characters\n";
 924     }
 925
 926     return $name;
 927 }
 928
 929 sub parse_vmid {
 930     my $vmid = shift;
 931
 932     die "VMID '$vmid' contains illegal characters\n" if $vmid !~ m/^\d+$/;
 933
 934     return int($vmid);
 935 }
 936
 937 PVE::JSONSchema::register_format('pve-volume-id', \&parse_volume_id);
 938 sub parse_volume_id {
 939     my ($volid, $noerr) = @_;
 940
 941     if ($volid =~ m/^([a-z][a-z0-9\-\_\.]*[a-z0-9]):(.+)$/i) {
 942         return wantarray ? ($1, $2) : $1;
 943     }
 944     return undef if $noerr;
 945     die "unable to parse volume ID '$volid'\n";
 946 }
 947
 948 sub parse_name_dir {
 949     my $name = shift;
 950
 951     if ($name =~ m!^([^/\s]+\.(raw|qcow2|vmdk))$!) {
 952         return ($1, $2);
 953     }
 954
 955     die "unable to parse volume filename '$name'\n";
 956 }
 957
 958 sub parse_volname_dir {
 959     my $volname = shift;
 960
 961     if ($volname =~ m!^(\d+)/(\S+)$!) {
 962         my ($vmid, $name) = ($1, $2);
 963         parse_name_dir ($name);
 964         return ('image', $name, $vmid);
 965     } elsif ($volname =~ m!^iso/([^/]+\.[Ii][Ss][Oo])$!) {
 966         return ('iso', $1);
 967     } elsif ($volname =~ m!^vztmpl/([^/]+\.tar\.gz)$!) {
 968         return ('vztmpl', $1);
 969     } elsif ($volname =~ m!^rootdir/(\d+)$!) {
 970         return ('rootdir', $1, $1);
 971     } elsif ($volname =~ m!^backup/([^/]+(\.(tar|tar\.gz|tar\.lzo|tgz)))$!) {
 972         my $fn = $1;
 973         if ($fn =~ m/^vzdump-(openvz|qemu)-(\d+)-.+/) {
 974             return ('backup', $fn, $2);
 975         }
 976         return ('backup', $fn);
 977    }
 978     die "unable to parse directory volume name '$volname'\n";
 979 }
 980
 981 sub parse_volname_lvm {
 982     my $volname = shift;
 983
 984     parse_lvm_name ($volname);
 985
 986     if ($volname =~ m/^(vm-(\d+)-\S+)$/) {
 987         return ($1, $2);
 988     }
 989
 990     die "unable to parse lvm volume name '$volname'\n";
 991 }
 992
 993 sub parse_volname_iscsi {
 994     my $volname = shift;
 995
 996     if ($volname =~ m!^\d+\.\d+\.\d+\.(\S+)$!) {
 997         my $byid = $1;
 998         return $byid;
 999     }
1000
1001     die "unable to parse iscsi volume name '$volname'\n";
1002 }
1003
1004 # try to map a filesystem path to a volume identifier
1005 sub path_to_volume_id {
1006     my ($cfg, $path) = @_;
1007
1008     my $ids = $cfg->{ids};
1009
1010     my ($sid, $volname) = parse_volume_id ($path, 1);
1011     if ($sid) {
1012         if ($ids->{$sid} && (my $type = $ids->{$sid}->{type})) {
1013             if ($type eq 'dir' || $type eq 'nfs') {
1014                 my ($vtype, $name, $vmid) = parse_volname_dir ($volname);
1015                 return ($vtype, $path);
1016             }
1017         }
1018         return ('');
1019     }
1020
1021     $path = abs_path ($path);
1022
1023     foreach my $sid (keys %$ids) {
1024         my $type = $ids->{$sid}->{type};
1025         next if !($type eq 'dir' || $type eq 'nfs');
1026
1027         my $imagedir = get_image_dir($cfg, $sid);
1028         my $isodir = get_iso_dir($cfg, $sid);
1029         my $tmpldir = get_vztmpl_dir($cfg, $sid);
1030         my $backupdir = get_backup_dir($cfg, $sid);
1031         my $privatedir = get_private_dir($cfg, $sid);
1032
1033         if ($path =~ m!^$imagedir/(\d+)/([^/\s]+)$!) {
1034             my $vmid = $1;
1035             my $name = $2;
1036             return ('image', "$sid:$vmid/$name");
1037         } elsif ($path =~ m!^$isodir/([^/]+\.[Ii][Ss][Oo])$!) {
1038             my $name = $1;
1039             return ('iso', "$sid:iso/$name");
1040         } elsif ($path =~ m!^$tmpldir/([^/]+\.tar\.gz)$!) {
1041             my $name = $1;
1042             return ('vztmpl', "$sid:vztmpl/$name");
1043         } elsif ($path =~ m!^$privatedir/(\d+)$!) {
1044             my $vmid = $1;
1045             return ('rootdir', "$sid:rootdir/$vmid");
1046         } elsif ($path =~ m!^$backupdir/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz))$!) {
1047             my $name = $1;
1048             return ('iso', "$sid:backup/$name");
1049         }
1050     }
1051
1052     # can't map path to volume id
1053     return ('');
1054 }
1055
1056 sub path {
1057     my ($cfg, $volid) = @_;
1058
1059     my ($storeid, $volname) = parse_volume_id ($volid);
1060
1061     my $scfg = storage_config ($cfg, $storeid);
1062
1063     my $path;
1064     my $owner;
1065     my $vtype = 'image';
1066
1067     if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs') {
1068         my ($name, $vmid);
1069         ($vtype, $name, $vmid) = parse_volname_dir ($volname);
1070         $owner = $vmid;
1071
1072         my $imagedir = get_image_dir($cfg, $storeid, $vmid);
1073         my $isodir = get_iso_dir($cfg, $storeid);
1074         my $tmpldir = get_vztmpl_dir($cfg, $storeid);
1075         my $backupdir = get_backup_dir($cfg, $storeid);
1076         my $privatedir = get_private_dir($cfg, $storeid);
1077
1078         if ($vtype eq 'image') {
1079             $path = "$imagedir/$name";
1080         } elsif ($vtype eq 'iso') {
1081             $path = "$isodir/$name";
1082         } elsif ($vtype eq 'vztmpl') {
1083             $path = "$tmpldir/$name";
1084         } elsif ($vtype eq 'rootdir') {
1085             $path = "$privatedir/$name";
1086         } elsif ($vtype eq 'backup') {
1087             $path = "$backupdir/$name";
1088         } else {
1089             die "should not be reached";
1090         }
1091
1092     } elsif ($scfg->{type} eq 'lvm') {
1093
1094         my $vg = $scfg->{vgname};
1095
1096         my ($name, $vmid) = parse_volname_lvm ($volname);
1097         $owner = $vmid;
1098
1099         $path = "/dev/$vg/$name";
1100
1101     } elsif ($scfg->{type} eq 'iscsi') {
1102         my $byid = parse_volname_iscsi ($volname);
1103         $path = "/dev/disk/by-id/$byid";
1104     } else {
1105         die "unknown storage type '$scfg->{type}'";
1106     }
1107
1108     return wantarray ? ($path, $owner, $vtype) : $path;
1109 }
1110
1111 sub storage_migrate {
1112     my ($cfg, $volid, $target_host, $target_storeid, $target_volname) = @_;
1113
1114     my ($storeid, $volname) = parse_volume_id ($volid);
1115     $target_volname = $volname if !$target_volname;
1116
1117     my $scfg = storage_config ($cfg, $storeid);
1118
1119     # no need to migrate shared content
1120     return if $storeid eq $target_storeid && $scfg->{shared};
1121
1122     my $tcfg = storage_config ($cfg, $target_storeid);
1123
1124     my $target_volid = "${target_storeid}:${target_volname}";
1125
1126     my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_host'";
1127
1128     # blowfish is a fast block cipher, much faster then 3des
1129     my $sshoptions = "-c blowfish -o 'BatchMode=yes'";
1130     my $ssh = "/usr/bin/ssh $sshoptions";
1131
1132     local $ENV{RSYNC_RSH} = $ssh;
1133
1134     if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs') {
1135         if ($tcfg->{type} eq 'dir' || $tcfg->{type} eq 'nfs') {
1136
1137             my $src = path ($cfg, $volid);
1138             my $dst = path ($cfg, $target_volid);
1139
1140             my $dirname = dirname ($dst);
1141
1142             if ($tcfg->{shared}) { # we can do a local copy
1143
1144                 run_command(['/bin/mkdir', '-p', $dirname]);
1145
1146                 run_command(['/bin/cp', $src, $dst]);
1147
1148             } else {
1149
1150                 run_command(['/usr/bin/ssh', "root\@${target_host}",
1151                              '/bin/mkdir', '-p', $dirname]);
1152
1153                 # we use rsync with --sparse, so we can't use --inplace,
1154                 # so we remove file on the target if it already exists to
1155                 # save space
1156                 my ($size, $format) = file_size_info($src);
1157                 if ($format && ($format eq 'raw') && $size) {
1158                     run_command(['/usr/bin/ssh', "root\@${target_host}",
1159                                  'rm', '-f', $dst],
1160                                 outfunc => sub {});
1161                 }
1162
1163                 my $cmd = ['/usr/bin/rsync', '--progress', '--sparse', '--whole-file',
1164                            $src, "root\@${target_host}:$dst"];
1165
1166                 my $percent = -1;
1167
1168                 run_command($cmd, outfunc => sub {
1169                     my $line = shift;
1170
1171                     if ($line =~ m/^\s*(\d+\s+(\d+)%\s.*)$/) {
1172                         if ($2 > $percent) {
1173                             $percent = $2;
1174                             print "rsync status: $1\n";
1175                             *STDOUT->flush();
1176                         }
1177                     } else {
1178                         print "$line\n";
1179                         *STDOUT->flush();
1180                     }
1181                 });
1182             }
1183
1184
1185         } else {
1186
1187             die "$errstr - target type '$tcfg->{type}' not implemented\n";
1188         }
1189
1190     } else {
1191         die "$errstr - source type '$scfg->{type}' not implemented\n";
1192     }
1193 }
1194
1195 sub vdisk_alloc {
1196     my ($cfg, $storeid, $vmid, $fmt, $name, $size) = @_;
1197
1198     die "no storage id specified\n" if !$storeid;
1199
1200     PVE::JSONSchema::parse_storage_id($storeid);
1201
1202     my $scfg = storage_config($cfg, $storeid);
1203
1204     die "no VMID specified\n" if !$vmid;
1205
1206     $vmid = parse_vmid ($vmid);
1207
1208     my $defformat = storage_default_format ($cfg, $storeid);
1209
1210     $fmt = $defformat if !$fmt;
1211
1212     activate_storage ($cfg, $storeid);
1213
1214     # lock shared storage
1215     return cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
1216
1217         if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs') {
1218
1219             my $imagedir = get_image_dir ($cfg, $storeid, $vmid);
1220
1221             mkpath $imagedir;
1222
1223             if (!$name) {
1224
1225                 for (my $i = 1; $i < 100; $i++) {
1226                     my @gr = <$imagedir/vm-$vmid-disk-$i.*>;
1227                     if (!scalar(@gr)) {
1228                         $name = "vm-$vmid-disk-$i.$fmt";
1229                         last;
1230                     }
1231                 }
1232             }
1233
1234             die "unable to allocate an image name for VM $vmid in storage '$storeid'\n"
1235                 if !$name;
1236
1237             my (undef, $tmpfmt) = parse_name_dir ($name);
1238
1239             die "illegal name '$name' - wrong extension for format ('$tmpfmt != '$fmt')\n"
1240                 if $tmpfmt ne $fmt;
1241
1242             my $path = "$imagedir/$name";
1243
1244             die "disk image '$path' already exists\n" if -e $path;
1245
1246             run_command("/usr/bin/qemu-img create -f $fmt '$path' ${size}K",
1247                         errmsg => "unable to create image");
1248
1249             return "$storeid:$vmid/$name";
1250
1251         } elsif ($scfg->{type} eq 'lvm') {
1252
1253             die "unsupported format '$fmt'" if $fmt ne 'raw';
1254
1255             die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
1256                 if  $name && $name !~ m/^vm-$vmid-/;
1257
1258             my $vgs = lvm_vgs ();
1259
1260             my $vg = $scfg->{vgname};
1261
1262             die "no such volume gruoup '$vg'\n" if !defined ($vgs->{$vg});
1263
1264             my $free = int ($vgs->{$vg}->{free});
1265
1266             die "not enough free space ($free < $size)\n" if $free < $size;
1267
1268             if (!$name) {
1269                 my $lvs = lvm_lvs ($vg);
1270
1271                 for (my $i = 1; $i < 100; $i++) {
1272                     my $tn = "vm-$vmid-disk-$i";
1273                     if (!defined ($lvs->{$vg}->{$tn})) {
1274                         $name = $tn;
1275                         last;
1276                     }
1277                 }
1278             }
1279
1280             die "unable to allocate an image name for VM $vmid in storage '$storeid'\n"
1281                 if !$name;
1282
1283             my $cmd = ['/sbin/lvcreate', '-aly', '--addtag', "pve-vm-$vmid", '--size', "${size}k", '--name', $name, $vg];
1284
1285             run_command($cmd, errmsg => "lvcreate '$vg/pve-vm-$vmid' error");
1286
1287             return "$storeid:$name";
1288
1289         } elsif ($scfg->{type} eq 'iscsi') {
1290             die "can't allocate space in iscsi storage\n";
1291         } else {
1292             die "unknown storage type '$scfg->{type}'";
1293         }
1294     });
1295 }
1296
1297 sub vdisk_free {
1298     my ($cfg, $volid) = @_;
1299
1300     my ($storeid, $volname) = parse_volume_id ($volid);
1301
1302     my $scfg = storage_config ($cfg, $storeid);
1303
1304     activate_storage ($cfg, $storeid);
1305
1306     # we need to zero out LVM data for security reasons
1307     # and to allow thin provisioning
1308
1309     my $vg;
1310
1311     # lock shared storage
1312     cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
1313
1314         if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs') {
1315             my $path = path ($cfg, $volid);
1316
1317             if (! -f $path) {
1318                 warn "disk image '$path' does not exists\n";
1319             } else {
1320                 unlink $path;
1321             }
1322         } elsif ($scfg->{type} eq 'lvm') {
1323
1324             if ($scfg->{saferemove}) {
1325                 # avoid long running task, so we only rename here
1326                 $vg = $scfg->{vgname};
1327                 my $cmd = ['/sbin/lvrename', $vg, $volname, "del-$volname"];
1328                 run_command($cmd, errmsg => "lvrename '$vg/$volname' error");
1329             } else {
1330                 my $tmpvg = $scfg->{vgname};
1331                 my $cmd = ['/sbin/lvremove', '-f', "$tmpvg/$volname"];
1332                 run_command($cmd, errmsg => "lvremove '$tmpvg/$volname' error");
1333             }
1334
1335         } elsif ($scfg->{type} eq 'iscsi') {
1336             die "can't free space in iscsi storage\n";
1337         } else {
1338             die "unknown storage type '$scfg->{type}'";
1339         }
1340     });
1341
1342     return if !$vg;
1343
1344     my $zero_out_worker = sub {
1345         print "zero-out data on image $volname\n";
1346         my $cmd = ['dd', "if=/dev/zero", "of=/dev/$vg/del-$volname", "bs=1M"];
1347         eval { run_command($cmd, errmsg => "zero out failed"); };
1348         warn $@ if $@;
1349
1350         cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
1351             my $cmd = ['/sbin/lvremove', '-f', "$vg/del-$volname"];
1352             run_command($cmd, errmsg => "lvremove '$vg/del-$volname' error");
1353         });
1354         print "successfully removed volume $volname\n";
1355     };
1356
1357     my $rpcenv = PVE::RPCEnvironment::get();
1358     my $authuser = $rpcenv->get_user();
1359
1360     $rpcenv->fork_worker('imgdel', undef, $authuser, $zero_out_worker);
1361 }
1362
1363 # lvm utility functions
1364
1365 sub lvm_pv_info {
1366     my ($device) = @_;
1367
1368     die "no device specified" if !$device;
1369
1370     my $has_label = 0;
1371
1372     my $cmd = ['/usr/bin/file', '-L', '-s', $device];
1373     run_command($cmd, outfunc => sub {
1374         my $line = shift;
1375         $has_label = 1 if $line =~ m/LVM2/;
1376     });
1377
1378     return undef if !$has_label;
1379
1380     $cmd = ['/sbin/pvs', '--separator', ':', '--noheadings', '--units', 'k',
1381             '--unbuffered', '--nosuffix', '--options',
1382             'pv_name,pv_size,vg_name,pv_uuid', $device];
1383
1384     my $pvinfo;
1385     run_command($cmd, outfunc => sub {
1386         my $line = shift;
1387
1388         $line = trim($line);
1389
1390         my ($pvname, $size, $vgname, $uuid) = split (':', $line);
1391
1392         die "found multiple pvs entries for device '$device'\n"
1393             if $pvinfo;
1394
1395         $pvinfo = {
1396             pvname => $pvname,
1397             size => $size,
1398             vgname => $vgname,
1399             uuid => $uuid,
1400         };
1401     });
1402
1403     return $pvinfo;
1404 }
1405
1406 sub clear_first_sector {
1407     my ($dev) = shift;
1408
1409     if (my $fh = IO::File->new ($dev, "w")) {
1410         my $buf = 0 x 512;
1411         syswrite $fh, $buf;
1412         $fh->close();
1413     }
1414 }
1415
1416 sub lvm_create_volume_group {
1417     my ($device, $vgname, $shared) = @_;
1418
1419     my $res = lvm_pv_info ($device);
1420
1421     if ($res->{vgname}) {
1422         return if $res->{vgname} eq $vgname; # already created
1423         die "device '$device' is already used by volume group '$res->{vgname}'\n";
1424     }
1425
1426     clear_first_sector ($device); # else pvcreate fails
1427
1428     # we use --metadatasize 250k, which reseults in "pe_start = 512"
1429     # so pe_start is aligned on a 128k boundary (advantage for SSDs)
1430     my $cmd = ['/sbin/pvcreate', '--metadatasize', '250k', $device];
1431
1432     run_command($cmd, errmsg => "pvcreate '$device' error");
1433
1434     $cmd = ['/sbin/vgcreate', $vgname, $device];
1435     # push @$cmd, '-c', 'y' if $shared; # we do not use this yet
1436
1437     run_command($cmd, errmsg => "vgcreate $vgname $device error");
1438 }
1439
1440 sub lvm_vgs {
1441
1442     my $cmd = ['/sbin/vgs', '--separator', ':', '--noheadings', '--units', 'b',
1443                '--unbuffered', '--nosuffix', '--options',
1444                'vg_name,vg_size,vg_free'];
1445
1446     my $vgs = {};
1447     eval {
1448         run_command($cmd, outfunc => sub {
1449             my $line = shift;
1450
1451             $line = trim($line);
1452
1453             my ($name, $size, $free) = split (':', $line);
1454
1455             $vgs->{$name} = { size => int ($size), free => int ($free) };
1456         });
1457     };
1458     my $err = $@;
1459
1460     # just warn (vgs return error code 5 if clvmd does not run)
1461     # but output is still OK (list without clustered VGs)
1462     warn $err if $err;
1463
1464     return $vgs;
1465 }
1466
1467 sub lvm_lvs {
1468     my ($vgname) = @_;
1469
1470     my $cmd = ['/sbin/lvs', '--separator', ':', '--noheadings', '--units', 'b',
1471                '--unbuffered', '--nosuffix', '--options',
1472                'vg_name,lv_name,lv_size,uuid,tags'];
1473
1474     push @$cmd, $vgname if $vgname;
1475
1476     my $lvs = {};
1477     run_command($cmd, outfunc => sub {
1478         my $line = shift;
1479
1480         $line = trim($line);
1481
1482         my ($vg, $name, $size, $uuid, $tags) = split (':', $line);
1483
1484         return if $name !~ m/^vm-(\d+)-/;
1485         my $nid = $1;
1486
1487         my $owner;
1488         foreach my $tag (split (/,/, $tags)) {
1489             if ($tag =~ m/^pve-vm-(\d+)$/) {
1490                 $owner = $1;
1491                 last;
1492             }
1493         }
1494
1495         if ($owner) {
1496             if ($owner ne $nid) {
1497                 warn "owner mismatch name = $name, owner = $owner\n";
1498             }
1499
1500             $lvs->{$vg}->{$name} = { format => 'raw', size => $size,
1501                                      uuid => $uuid,  tags => $tags,
1502                                      vmid => $owner };
1503         }
1504     });
1505
1506     return $lvs;
1507 }
1508
1509 #list iso or openvz template ($tt = <iso|vztmpl|backup>)
1510 sub template_list {
1511     my ($cfg, $storeid, $tt) = @_;
1512
1513     die "unknown template type '$tt'\n" if !($tt eq 'iso' || $tt eq 'vztmpl' || $tt eq 'backup');
1514
1515     my $ids = $cfg->{ids};
1516
1517     storage_check_enabled($cfg, $storeid) if ($storeid);
1518
1519     my $res = {};
1520
1521     # query the storage
1522
1523     foreach my $sid (keys %$ids) {
1524         next if $storeid && $storeid ne $sid;
1525
1526         my $scfg = $ids->{$sid};
1527         my $type = $scfg->{type};
1528
1529         next if !storage_check_enabled($cfg, $sid, undef, 1);
1530
1531         next if $tt eq 'iso' && !$scfg->{content}->{iso};
1532         next if $tt eq 'vztmpl' && !$scfg->{content}->{vztmpl};
1533         next if $tt eq 'backup' && !$scfg->{content}->{backup};
1534
1535         activate_storage ($cfg, $sid);
1536
1537         if ($type eq 'dir' || $type eq 'nfs') {
1538
1539             my $path;
1540             if ($tt eq 'iso') {
1541                 $path = get_iso_dir($cfg, $sid);
1542             } elsif ($tt eq 'vztmpl') {
1543                 $path = get_vztmpl_dir($cfg, $sid);
1544             } elsif ($tt eq 'backup') {
1545                 $path = get_backup_dir($cfg, $sid);
1546             } else {
1547                 die "unknown template type '$tt'\n";
1548             }
1549
1550             foreach my $fn (<$path/*>) {
1551
1552                 my $info;
1553
1554                 if ($tt eq 'iso') {
1555                     next if $fn !~ m!/([^/]+\.[Ii][Ss][Oo])$!;
1556
1557                     $info = { volid => "$sid:iso/$1", format => 'iso' };
1558
1559                 } elsif ($tt eq 'vztmpl') {
1560                     next if $fn !~ m!/([^/]+\.tar\.gz)$!;
1561
1562                     $info = { volid => "$sid:vztmpl/$1", format => 'tgz' };
1563
1564                 } elsif ($tt eq 'backup') {
1565                     next if $fn !~ m!/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz))$!;
1566
1567                     $info = { volid => "$sid:backup/$1", format => $2 };
1568                 }
1569
1570                 $info->{size} = -s $fn;
1571
1572                 push @{$res->{$sid}}, $info;
1573             }
1574
1575         }
1576
1577         @{$res->{$sid}} = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @{$res->{$sid}} if $res->{$sid};
1578     }
1579
1580     return $res;
1581 }
1582
1583 sub file_size_info {
1584     my ($filename, $timeout) = @_;
1585
1586     my $cmd = ['/usr/bin/qemu-img', 'info', $filename];
1587
1588     my $format;
1589     my $size = 0;
1590     my $used = 0;
1591
1592     eval {
1593         run_command($cmd, timeout => $timeout, outfunc => sub {
1594             my $line = shift;
1595
1596             if ($line =~ m/^file format:\s+(\S+)\s*$/) {
1597                 $format = $1;
1598             } elsif ($line =~ m/^virtual size:\s\S+\s+\((\d+)\s+bytes\)$/) {
1599                 $size = int($1);
1600             } elsif ($line =~ m/^disk size:\s+(\d+(.\d+)?)([KMGT])\s*$/) {
1601                 $used = $1;
1602                 my $u = $3;
1603
1604                 $used *= 1024 if $u eq 'K';
1605                 $used *= (1024*1024) if $u eq 'M';
1606                 $used *= (1024*1024*1024) if $u eq 'G';
1607                 $used *= (1024*1024*1024*1024) if $u eq 'T';
1608
1609                 $used = int($used);
1610             }
1611         });
1612     };
1613
1614     return wantarray ? ($size, $format, $used) : $size;
1615 }
1616
1617 sub vdisk_list {
1618     my ($cfg, $storeid, $vmid, $vollist) = @_;
1619
1620     my $ids = $cfg->{ids};
1621
1622     storage_check_enabled($cfg, $storeid) if ($storeid);
1623
1624     my $res = {};
1625
1626     # prepare/activate/refresh all storages
1627
1628     my $stypes = {};
1629
1630     my $storage_list = [];
1631     if ($vollist) {
1632         foreach my $volid (@$vollist) {
1633             my ($sid, undef) = parse_volume_id ($volid);
1634             next if !defined ($ids->{$sid});
1635             next if !storage_check_enabled($cfg, $sid, undef, 1);
1636             push @$storage_list, $sid;
1637             $stypes->{$ids->{$sid}->{type}} = 1;
1638         }
1639     } else {
1640         foreach my $sid (keys %$ids) {
1641             next if $storeid && $storeid ne $sid;
1642             next if !storage_check_enabled($cfg, $sid, undef, 1);
1643             push @$storage_list, $sid;
1644             $stypes->{$ids->{$sid}->{type}} = 1;
1645         }
1646     }
1647
1648     activate_storage_list ($cfg, $storage_list);
1649
1650     my $lvs = $stypes->{lvm} ? lvm_lvs () : {};
1651
1652     my $iscsi_devices = iscsi_device_list() if $stypes->{iscsi};
1653
1654     # query the storage
1655
1656     foreach my $sid (keys %$ids) {
1657         if ($storeid) {
1658             next if $storeid ne $sid;
1659             next if !storage_check_enabled($cfg, $sid, undef, 1);
1660         }
1661         my $scfg = $ids->{$sid};
1662         my $type = $scfg->{type};
1663
1664         if ($type eq 'dir' || $type eq 'nfs') {
1665
1666             my $path = $scfg->{path};
1667
1668             my $fmts = join ('|', keys %{$default_config->{$type}->{format}->[0]});
1669
1670             foreach my $fn (<$path/images/[0-9][0-9]*/*>) {
1671
1672                 next if $fn !~ m!^(/.+/images/(\d+)/([^/]+\.($fmts)))$!;
1673                 $fn = $1; # untaint
1674
1675                 my $owner = $2;
1676                 my $name = $3;
1677                 my $volid = "$sid:$owner/$name";
1678
1679                 if ($vollist) {
1680                     my $found = grep { $_ eq $volid } @$vollist;
1681                     next if !$found;
1682                 } else {
1683                     next if defined ($vmid) && ($owner ne $vmid);
1684                 }
1685
1686                 my ($size, $format, $used) = file_size_info ($fn);
1687
1688                 if ($format && $size) {
1689                     push @{$res->{$sid}}, {
1690                         volid => $volid, format => $format,
1691                         size => $size, vmid => $owner, used => $used };
1692                 }
1693
1694             }
1695
1696         } elsif ($type eq 'lvm') {
1697
1698             my $vgname = $scfg->{vgname};
1699
1700             if (my $dat = $lvs->{$vgname}) {
1701
1702                 foreach my $volname (keys %$dat) {
1703
1704                     my $owner = $dat->{$volname}->{vmid};
1705
1706                     my $volid = "$sid:$volname";
1707
1708                     if ($vollist) {
1709                         my $found = grep { $_ eq $volid } @$vollist;
1710                         next if !$found;
1711                     } else {
1712                         next if defined ($vmid) && ($owner ne $vmid);
1713                     }
1714
1715                     my $info = $dat->{$volname};
1716                     $info->{volid} = $volid;
1717
1718                     push @{$res->{$sid}}, $info;
1719                 }
1720             }
1721
1722         } elsif ($type eq 'iscsi') {
1723
1724             # we have no owner for iscsi devices
1725
1726             my $target = $scfg->{target};
1727
1728             if (my $dat = $iscsi_devices->{$target}) {
1729
1730                 foreach my $volname (keys %$dat) {
1731
1732                     my $volid = "$sid:$volname";
1733
1734                     if ($vollist) {
1735                         my $found = grep { $_ eq $volid } @$vollist;
1736                         next if !$found;
1737                     } else {
1738                         next if !($storeid && ($storeid eq $sid));
1739                     }
1740
1741                     my $info = $dat->{$volname};
1742                     $info->{volid} = $volid;
1743
1744                     push @{$res->{$sid}}, $info;
1745                 }
1746             }
1747
1748         } else {
1749             die "implement me";
1750         }
1751
1752         @{$res->{$sid}} = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @{$res->{$sid}} if $res->{$sid};
1753     }
1754
1755     return $res;
1756 }
1757
1758 sub nfs_is_mounted {
1759     my ($server, $export, $mountpoint, $mountdata) = @_;
1760
1761     my $source = "$server:$export";
1762
1763     $mountdata = read_proc_mounts() if !$mountdata;
1764
1765     if ($mountdata =~ m|^$source/?\s$mountpoint\snfs|m) {
1766         return $mountpoint;
1767     }
1768
1769     return undef;
1770 }
1771
1772 sub nfs_mount {
1773     my ($server, $export, $mountpoint, $options) = @_;
1774
1775     my $source = "$server:$export";
1776
1777     my $cmd = ['/bin/mount', '-t', 'nfs', $source, $mountpoint];
1778     if ($options) {
1779         push @$cmd, '-o', $options;
1780     }
1781
1782     run_command($cmd, errmsg => "mount error");
1783 }
1784
1785 sub uevent_seqnum {
1786
1787     my $filename = "/sys/kernel/uevent_seqnum";
1788
1789     my $seqnum = 0;
1790     if (my $fh = IO::File->new ($filename, "r")) {
1791         my $line = <$fh>;
1792         if ($line =~ m/^(\d+)$/) {
1793             $seqnum = int ($1);
1794         }
1795         close ($fh);
1796     }
1797     return $seqnum;
1798 }
1799
1800 sub __activate_storage_full {
1801     my ($cfg, $storeid, $session) = @_;
1802
1803     my $scfg = storage_check_enabled($cfg, $storeid);
1804
1805     return if $session->{activated}->{$storeid};
1806
1807     if (!$session->{mountdata}) {
1808         $session->{mountdata} = read_proc_mounts();
1809     }
1810
1811     if (!$session->{uevent_seqnum}) {
1812         $session->{uevent_seqnum} = uevent_seqnum ();
1813     }
1814
1815     my $mountdata = $session->{mountdata};
1816
1817     my $type = $scfg->{type};
1818
1819     if ($type eq 'dir' || $type eq 'nfs') {
1820
1821         my $path = $scfg->{path};
1822
1823         if ($type eq 'nfs') {
1824             my $server = $scfg->{server};
1825             my $export = $scfg->{export};
1826
1827             if (!nfs_is_mounted ($server, $export, $path, $mountdata)) {
1828
1829                 # NOTE: only call mkpath when not mounted (avoid hang
1830                 # when NFS server is offline
1831
1832                 mkpath $path;
1833
1834                 die "unable to activate storage '$storeid' - " .
1835                     "directory '$path' does not exist\n" if ! -d $path;
1836
1837                 nfs_mount ($server, $export, $path, $scfg->{options});
1838             }
1839
1840         } else {
1841
1842             mkpath $path;
1843
1844             die "unable to activate storage '$storeid' - " .
1845                 "directory '$path' does not exist\n" if ! -d $path;
1846         }
1847
1848         my $imagedir = get_image_dir($cfg, $storeid);
1849         my $isodir = get_iso_dir($cfg, $storeid);
1850         my $tmpldir = get_vztmpl_dir($cfg, $storeid);
1851         my $backupdir = get_backup_dir($cfg, $storeid);
1852         my $privatedir = get_private_dir($cfg, $storeid);
1853
1854         if (defined($scfg->{content})) {
1855             mkpath $imagedir if $scfg->{content}->{images} &&
1856                 $imagedir ne $path;
1857             mkpath $isodir if $scfg->{content}->{iso} &&
1858                 $isodir ne $path;
1859             mkpath $tmpldir if $scfg->{content}->{vztmpl} &&
1860                 $tmpldir ne $path;
1861             mkpath $privatedir if $scfg->{content}->{rootdir} &&
1862                 $privatedir ne $path;
1863             mkpath $backupdir if $scfg->{content}->{backup} &&
1864                 $backupdir ne $path;
1865         }
1866
1867     } elsif ($type eq 'lvm') {
1868
1869         if ($scfg->{base}) {
1870             my ($baseid, undef) = parse_volume_id ($scfg->{base});
1871             __activate_storage_full ($cfg, $baseid, $session);
1872         }
1873
1874         if (!$session->{vgs}) {
1875             $session->{vgs} = lvm_vgs();
1876         }
1877
1878         # In LVM2, vgscans take place automatically;
1879         # this is just to be sure
1880         if ($session->{vgs} && !$session->{vgscaned} &&
1881             !$session->{vgs}->{$scfg->{vgname}}) {
1882             $session->{vgscaned} = 1;
1883             my $cmd = ['/sbin/vgscan', '--ignorelockingfailure', '--mknodes'];
1884             eval { run_command($cmd, outfunc => sub {}); };
1885             warn $@ if $@;
1886         }
1887
1888         # we do not acticate any volumes here ('vgchange -aly')
1889         # instead, volumes are activate individually later
1890
1891     } elsif ($type eq 'iscsi') {
1892
1893         return if !check_iscsi_support(1);
1894
1895         $session->{iscsi_sessions} = iscsi_session_list()
1896             if !$session->{iscsi_sessions};
1897
1898         my $iscsi_sess = $session->{iscsi_sessions}->{$scfg->{target}};
1899         if (!defined ($iscsi_sess)) {
1900             eval { iscsi_login ($scfg->{target}, $scfg->{portal}); };
1901             warn $@ if $@;
1902         } else {
1903             # make sure we get all devices
1904             iscsi_session_rescan ($iscsi_sess);
1905         }
1906
1907     } else {
1908         die "implement me";
1909     }
1910
1911     my $newseq = uevent_seqnum ();
1912
1913     # only call udevsettle if there are events
1914     if ($newseq > $session->{uevent_seqnum}) {
1915         my $timeout = 30;
1916         system ("$UDEVADM settle --timeout=$timeout"); # ignore errors
1917         $session->{uevent_seqnum} = $newseq;
1918     }
1919
1920     $session->{activated}->{$storeid} = 1;
1921 }
1922
1923 sub activate_storage_list {
1924     my ($cfg, $storeid_list, $session) = @_;
1925
1926     $session = {} if !$session;
1927
1928     foreach my $storeid (@$storeid_list) {
1929         __activate_storage_full ($cfg, $storeid, $session);
1930     }
1931 }
1932
1933 sub activate_storage {
1934     my ($cfg, $storeid) = @_;
1935
1936     my $session = {};
1937
1938     __activate_storage_full ($cfg, $storeid, $session);
1939 }
1940
1941 sub activate_volumes {
1942     my ($cfg, $vollist, $exclusive) = @_;
1943
1944     return if !($vollist && scalar(@$vollist));
1945
1946     my $lvm_activate_mode = $exclusive ? 'ey' : 'ly';
1947
1948     my $storagehash = {};
1949     foreach my $volid (@$vollist) {
1950         my ($storeid, undef) = parse_volume_id ($volid);
1951         $storagehash->{$storeid} = 1;
1952     }
1953
1954     activate_storage_list ($cfg, [keys %$storagehash]);
1955
1956     foreach my $volid (@$vollist) {
1957         my ($storeid, $volname) = parse_volume_id ($volid);
1958
1959         my $scfg = storage_config ($cfg, $storeid);
1960
1961         my $path = path ($cfg, $volid);
1962
1963         if ($scfg->{type} eq 'lvm') {
1964             my $cmd = ['/sbin/lvchange', "-a$lvm_activate_mode", $path];
1965             run_command($cmd, errmsg => "can't activate LV '$volid'");
1966         }
1967
1968         # check is volume exists
1969         if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs') {
1970             die "volume '$volid' does not exist\n" if ! -e $path;
1971         } else {
1972             die "volume '$volid' does not exist\n" if ! -b $path;
1973         }
1974     }
1975 }
1976
1977 sub deactivate_volumes {
1978     my ($cfg, $vollist) = @_;
1979
1980     return if !($vollist && scalar(@$vollist));
1981
1982     my $lvs = lvm_lvs ();
1983
1984     my @errlist = ();
1985     foreach my $volid (@$vollist) {
1986         my ($storeid, $volname) = parse_volume_id ($volid);
1987
1988         my $scfg = storage_config ($cfg, $storeid);
1989
1990         if ($scfg->{type} eq 'lvm') {
1991             my ($name) = parse_volname_lvm ($volname);
1992
1993             if ($lvs->{$scfg->{vgname}}->{$name}) {
1994                 my $path = path ($cfg, $volid);
1995                 my $cmd = ['/sbin/lvchange', '-aln', $path];
1996                 eval { run_command($cmd, errmsg => "can't deactivate LV '$volid'"); };
1997                 if (my $err = $@) {
1998                     warn $err;
1999                     push @errlist, $volid;
2000                 }
2001             }
2002         }
2003     }
2004
2005     die "volume deativation failed: " . join(' ', @errlist)
2006         if scalar(@errlist);
2007 }
2008
2009 sub deactivate_storage {
2010     my ($cfg, $storeid) = @_;
2011
2012     my $iscsi_sessions;
2013
2014     my $scfg = storage_config ($cfg, $storeid);
2015
2016     my $type = $scfg->{type};
2017
2018     if ($type eq 'dir') {
2019         # nothing to do
2020     } elsif ($type eq 'nfs') {
2021         my $mountdata = read_proc_mounts();
2022         my $server = $scfg->{server};
2023         my $export = $scfg->{export};
2024         my $path = $scfg->{path};
2025
2026         my $cmd = ['/bin/umount', $path];
2027
2028         run_command($cmd, errmsg => 'umount error')
2029             if nfs_is_mounted ($server, $export, $path, $mountdata);
2030
2031     } elsif ($type eq 'lvm') {
2032         my $cmd = ['/sbin/vgchange', '-aln', $scfg->{vgname}];
2033         run_command($cmd, errmsg => "can't deactivate VG '$scfg->{vgname}'");
2034     } elsif ($type eq 'iscsi') {
2035         my $portal = $scfg->{portal};
2036         my $target = $scfg->{target};
2037
2038         my $iscsi_sessions = iscsi_session_list();
2039         iscsi_logout ($target, $portal)
2040             if defined ($iscsi_sessions->{$target});
2041
2042     } else {
2043         die "implement me";
2044     }
2045 }
2046
2047 sub storage_info {
2048     my ($cfg, $content) = @_;
2049
2050     my $ids = $cfg->{ids};
2051
2052     my $info = {};
2053     my $stypes = {};
2054
2055     my $slist = [];
2056     foreach my $storeid (keys %$ids) {
2057
2058         next if $content && !$ids->{$storeid}->{content}->{$content};
2059
2060         next if !storage_check_enabled($cfg, $storeid, undef, 1);
2061
2062         my $type = $ids->{$storeid}->{type};
2063
2064         $info->{$storeid} = {
2065             type => $type,
2066             total => 0,
2067             avail => 0,
2068             used => 0,
2069             shared => $ids->{$storeid}->{shared} ? 1 : 0,
2070             content => content_hash_to_string($ids->{$storeid}->{content}),
2071             active => 0,
2072         };
2073
2074         $stypes->{$type} = 1;
2075
2076         push @$slist, $storeid;
2077     }
2078
2079     my $session = {};
2080     my $mountdata = '';
2081     my $iscsi_sessions = {};
2082     my $vgs = {};
2083
2084     if ($stypes->{lvm}) {
2085         $session->{vgs} = lvm_vgs();
2086         $vgs = $session->{vgs};
2087     }
2088     if ($stypes->{nfs}) {
2089         $mountdata = read_proc_mounts();
2090         $session->{mountdata} = $mountdata;
2091     }
2092     if ($stypes->{iscsi}) {
2093         $iscsi_sessions = iscsi_session_list();
2094         $session->{iscsi_sessions} = $iscsi_sessions;
2095     }
2096
2097     eval { activate_storage_list ($cfg, $slist, $session); };
2098
2099     foreach my $storeid (keys %$ids) {
2100         my $scfg = $ids->{$storeid};
2101
2102         next if !$info->{$storeid};
2103
2104         my $type = $scfg->{type};
2105
2106         if ($type eq 'dir' || $type eq 'nfs') {
2107
2108             my $path = $scfg->{path};
2109
2110             if ($type eq 'nfs') {
2111                 my $server = $scfg->{server};
2112                 my $export = $scfg->{export};
2113
2114                 next if !nfs_is_mounted ($server, $export, $path, $mountdata);
2115             }
2116
2117             my $timeout = 2;
2118             my $res = PVE::Tools::df($path, $timeout);
2119
2120             next if !$res || !$res->{total};
2121
2122             $info->{$storeid}->{total} = $res->{total};
2123             $info->{$storeid}->{avail} = $res->{avail};
2124             $info->{$storeid}->{used} = $res->{used};
2125             $info->{$storeid}->{active} = 1;
2126
2127         } elsif ($type eq 'lvm') {
2128
2129             my $vgname = $scfg->{vgname};
2130
2131             my $total = 0;
2132             my $free = 0;
2133
2134             if (defined ($vgs->{$vgname})) {
2135                 $total = $vgs->{$vgname}->{size};
2136                 $free = $vgs->{$vgname}->{free};
2137
2138                 $info->{$storeid}->{total} = $total;
2139                 $info->{$storeid}->{avail} = $free;
2140                 $info->{$storeid}->{used} = $total - $free;
2141                 $info->{$storeid}->{active} = 1;
2142             }
2143
2144         } elsif ($type eq 'iscsi') {
2145
2146             $info->{$storeid}->{total} = 0;
2147             $info->{$storeid}->{avail} = 0;
2148             $info->{$storeid}->{used} = 0;
2149             $info->{$storeid}->{active} =
2150                 defined ($iscsi_sessions->{$scfg->{target}});
2151
2152         } else {
2153             die "implement me";
2154         }
2155     }
2156
2157     return $info;
2158 }
2159
2160 sub resolv_server {
2161     my ($server) = @_;
2162
2163     my $packed_ip = gethostbyname($server);
2164     if (defined $packed_ip) {
2165         return inet_ntoa($packed_ip);
2166     }
2167     return undef;
2168 }
2169
2170 sub scan_nfs {
2171     my ($server_in) = @_;
2172
2173     my $server;
2174     if (!($server = resolv_server ($server_in))) {
2175         die "unable to resolve address for server '${server_in}'\n";
2176     }
2177
2178     my $cmd = ['/sbin/showmount',  '--no-headers', '--exports', $server];
2179
2180     my $res = {};
2181     run_command($cmd, outfunc => sub {
2182         my $line = shift;
2183
2184         # note: howto handle white spaces in export path??
2185         if ($line =~ m!^(/\S+)\s+(.+)$!) {
2186             $res->{$1} = $2;
2187         }
2188     });
2189
2190     return $res;
2191 }
2192
2193 sub resolv_portal {
2194     my ($portal, $noerr) = @_;
2195
2196     if ($portal =~ m/^([^:]+)(:(\d+))?$/) {
2197         my $server = $1;
2198         my $port = $3;
2199
2200         if (my $ip = resolv_server($server)) {
2201             $server = $ip;
2202             return $port ? "$server:$port" : $server;
2203         }
2204     }
2205     return undef if $noerr;
2206
2207     raise_param_exc({ portal => "unable to resolve portal address '$portal'" });
2208 }
2209
2210 # idea is from usbutils package (/usr/bin/usb-devices) script
2211 sub __scan_usb_device {
2212     my ($res, $devpath, $parent, $level) = @_;
2213
2214     return if ! -d $devpath;
2215     return if $level && $devpath !~ m/^.*[-.](\d+)$/;
2216     my $port = $level ? int($1 - 1) : 0;
2217
2218     my $busnum = int(file_read_firstline("$devpath/busnum"));
2219     my $devnum = int(file_read_firstline("$devpath/devnum"));
2220
2221     my $d = {
2222         port => $port,
2223         level => $level,
2224         busnum => $busnum,
2225         devnum => $devnum,
2226         speed => file_read_firstline("$devpath/speed"),
2227         class => hex(file_read_firstline("$devpath/bDeviceClass")),
2228         vendid => file_read_firstline("$devpath/idVendor"),
2229         prodid => file_read_firstline("$devpath/idProduct"),
2230     };
2231
2232     if ($level) {
2233         my $usbpath = $devpath;
2234         $usbpath =~ s|^.*/\d+\-||;
2235         $d->{usbpath} = $usbpath;
2236     }
2237
2238     my $product = file_read_firstline("$devpath/product");
2239     $d->{product} = $product if $product;
2240
2241     my $manu = file_read_firstline("$devpath/manufacturer");
2242     $d->{manufacturer} = $manu if $manu;
2243
2244     my $serial => file_read_firstline("$devpath/serial");
2245     $d->{serial} = $serial if $serial;
2246
2247     push @$res, $d;
2248
2249     foreach my $subdev (<$devpath/$busnum-*>) {
2250         next if $subdev !~ m|/$busnum-[0-9]+(\.[0-9]+)*$|;
2251         __scan_usb_device($res, $subdev, $devnum, $level + 1);
2252     }
2253
2254 };
2255
2256 sub scan_usb {
2257
2258     my $devlist = [];
2259
2260     foreach my $device (</sys/bus/usb/devices/usb*>) {
2261         __scan_usb_device($devlist, $device, 0, 0);
2262     }
2263
2264     return $devlist;
2265 }
2266
2267 sub scan_iscsi {
2268     my ($portal_in) = @_;
2269
2270     my $portal;
2271     if (!($portal = resolv_portal ($portal_in))) {
2272         die "unable to parse/resolve portal address '${portal_in}'\n";
2273     }
2274
2275     return iscsi_discovery($portal);
2276 }
2277
2278 sub storage_default_format {
2279     my ($cfg, $storeid) = @_;
2280
2281     my $scfg = storage_config ($cfg, $storeid);
2282
2283     my $def = $default_config->{$scfg->{type}};
2284
2285     my $def_format = 'raw';
2286     my $valid_formats = [ $def_format ];
2287
2288     if (defined ($def->{format})) {
2289         $def_format = $scfg->{format} || $def->{format}->[1];
2290         $valid_formats = [ sort keys %{$def->{format}->[0]} ];
2291     }
2292
2293     return wantarray ? ($def_format, $valid_formats) : $def_format;
2294 }
2295
2296 sub vgroup_is_used {
2297     my ($cfg, $vgname) = @_;
2298
2299     foreach my $storeid (keys %{$cfg->{ids}}) {
2300         my $scfg = storage_config ($cfg, $storeid);
2301         if ($scfg->{type} eq 'lvm' && $scfg->{vgname} eq $vgname) {
2302             return 1;
2303         }
2304     }
2305
2306     return undef;
2307 }
2308
2309 sub target_is_used {
2310     my ($cfg, $target) = @_;
2311
2312     foreach my $storeid (keys %{$cfg->{ids}}) {
2313         my $scfg = storage_config ($cfg, $storeid);
2314         if ($scfg->{type} eq 'iscsi' && $scfg->{target} eq $target) {
2315             return 1;
2316         }
2317     }
2318
2319     return undef;
2320 }
2321
2322 sub volume_is_used {
2323     my ($cfg, $volid) = @_;
2324
2325     foreach my $storeid (keys %{$cfg->{ids}}) {
2326         my $scfg = storage_config ($cfg, $storeid);
2327         if ($scfg->{base} && $scfg->{base} eq $volid) {
2328             return 1;
2329         }
2330     }
2331
2332     return undef;
2333 }
2334
2335 sub storage_is_used {
2336     my ($cfg, $storeid) = @_;
2337
2338     foreach my $sid (keys %{$cfg->{ids}}) {
2339         my $scfg = storage_config ($cfg, $sid);
2340         next if !$scfg->{base};
2341         my ($st) = parse_volume_id ($scfg->{base});
2342         return 1 if $st && $st eq $storeid;
2343     }
2344
2345     return undef;
2346 }
2347
2348 sub foreach_volid {
2349     my ($list, $func) = @_;
2350
2351     return if !$list;
2352
2353     foreach my $sid (keys %$list) {
2354        foreach my $info (@{$list->{$sid}}) {
2355            my $volid = $info->{volid};
2356            my ($sid1, $volname) = parse_volume_id ($volid, 1);
2357            if ($sid1 && $sid1 eq $sid) {
2358                &$func ($volid, $sid, $info);
2359            } else {
2360                warn "detected strange volid '$volid' in volume list for '$sid'\n";
2361            }
2362        }
2363     }
2364 }
2365
2366 1;