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