| | 1 | package PVE::Storage; |
| | 2 | |
| | 3 | use strict; |
| | 4 | use warnings; |
| | 5 | |
| | 6 | use POSIX; |
| | 7 | use IO::Select; |
| | 8 | use IO::File; |
| | 9 | use File::Basename; |
| | 10 | use File::Path; |
| | 11 | use Cwd 'abs_path'; |
| | 12 | use Socket; |
| | 13 | |
| | 14 | use PVE::Tools qw(run_command file_read_firstline); |
| | 15 | use PVE::Cluster qw(cfs_read_file cfs_lock_file); |
| | 16 | use PVE::Exception qw(raise_param_exc); |
| | 17 | use PVE::JSONSchema; |
| | 18 | use PVE::INotify; |
| | 19 | use PVE::RPCEnvironment; |
| | 20 | |
| | 21 | use PVE::Storage::Plugin; |
| | 22 | use PVE::Storage::DirPlugin; |
| | 23 | use PVE::Storage::LVMPlugin; |
| | 24 | use PVE::Storage::NFSPlugin; |
| | 25 | use PVE::Storage::ISCSIPlugin; |
| | 26 | use PVE::Storage::RBDPlugin; |
| | 27 | use PVE::Storage::SheepdogPlugin; |
| | 28 | use PVE::Storage::ISCSIDirectPlugin; |
| | 29 | use PVE::Storage::GlusterfsPlugin; |
| | 30 | use PVE::Storage::ZFSPoolPlugin; |
| | 31 | use PVE::Storage::ZFSPlugin; |
| | 32 | use PVE::Storage::DRBDPlugin; |
| | 33 | |
| | 34 | # load and initialize all plugins |
| | 35 | PVE::Storage::DirPlugin->register(); |
| | 36 | PVE::Storage::LVMPlugin->register(); |
| | 37 | PVE::Storage::NFSPlugin->register(); |
| | 38 | PVE::Storage::ISCSIPlugin->register(); |
| | 39 | PVE::Storage::RBDPlugin->register(); |
| | 40 | PVE::Storage::SheepdogPlugin->register(); |
| | 41 | PVE::Storage::ISCSIDirectPlugin->register(); |
| | 42 | PVE::Storage::GlusterfsPlugin->register(); |
| | 43 | PVE::Storage::ZFSPoolPlugin->register(); |
| | 44 | PVE::Storage::ZFSPlugin->register(); |
| | 45 | PVE::Storage::DRBDPlugin->register(); |
| | 46 | PVE::Storage::Plugin->init(); |
| | 47 | |
| | 48 | my $UDEVADM = '/sbin/udevadm'; |
| | 49 | |
| | 50 | # PVE::Storage utility functions |
| | 51 | |
| | 52 | sub config { |
| | 53 | return cfs_read_file("storage.cfg"); |
| | 54 | } |
| | 55 | |
| | 56 | sub lock_storage_config { |
| | 57 | my ($code, $errmsg) = @_; |
| | 58 | |
| | 59 | cfs_lock_file("storage.cfg", undef, $code); |
| | 60 | my $err = $@; |
| | 61 | if ($err) { |
| | 62 | $errmsg ? die "$errmsg: $err" : die $err; |
| | 63 | } |
| | 64 | } |
| | 65 | |
| | 66 | sub storage_config { |
| | 67 | my ($cfg, $storeid, $noerr) = @_; |
| | 68 | |
| | 69 | die "no storage id specified\n" if !$storeid; |
| | 70 | |
| | 71 | my $scfg = $cfg->{ids}->{$storeid}; |
| | 72 | |
| | 73 | die "storage '$storeid' does not exists\n" if (!$noerr && !$scfg); |
| | 74 | |
| | 75 | return $scfg; |
| | 76 | } |
| | 77 | |
| | 78 | sub storage_check_node { |
| | 79 | my ($cfg, $storeid, $node, $noerr) = @_; |
| | 80 | |
| | 81 | my $scfg = storage_config($cfg, $storeid); |
| | 82 | |
| | 83 | if ($scfg->{nodes}) { |
| | 84 | $node = PVE::INotify::nodename() if !$node || ($node eq 'localhost'); |
| | 85 | if (!$scfg->{nodes}->{$node}) { |
| | 86 | die "storage '$storeid' is not available on node '$node'\n" if !$noerr; |
| | 87 | return undef; |
| | 88 | } |
| | 89 | } |
| | 90 | |
| | 91 | return $scfg; |
| | 92 | } |
| | 93 | |
| | 94 | sub storage_check_enabled { |
| | 95 | my ($cfg, $storeid, $node, $noerr) = @_; |
| | 96 | |
| | 97 | my $scfg = storage_config($cfg, $storeid); |
| | 98 | |
| | 99 | if ($scfg->{disable}) { |
| | 100 | die "storage '$storeid' is disabled\n" if !$noerr; |
| | 101 | return undef; |
| | 102 | } |
| | 103 | |
| | 104 | return storage_check_node($cfg, $storeid, $node, $noerr); |
| | 105 | } |
| | 106 | |
| | 107 | sub storage_ids { |
| | 108 | my ($cfg) = @_; |
| | 109 | |
| | 110 | return keys %{$cfg->{ids}}; |
| | 111 | } |
| | 112 | |
| | 113 | sub file_size_info { |
| | 114 | my ($filename, $timeout) = @_; |
| | 115 | |
| | 116 | return PVE::Storage::Plugin::file_size_info($filename, $timeout); |
| | 117 | } |
| | 118 | |
| | 119 | sub volume_size_info { |
| | 120 | my ($cfg, $volid, $timeout) = @_; |
| | 121 | |
| | 122 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 123 | if ($storeid) { |
| | 124 | my $scfg = storage_config($cfg, $storeid); |
| | 125 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 126 | return $plugin->volume_size_info($scfg, $storeid, $volname, $timeout); |
| | 127 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 128 | return file_size_info($volid, $timeout); |
| | 129 | } else { |
| | 130 | return 0; |
| | 131 | } |
| | 132 | } |
| | 133 | |
| | 134 | sub volume_resize { |
| | 135 | my ($cfg, $volid, $size, $running) = @_; |
| | 136 | |
| | 137 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 138 | if ($storeid) { |
| | 139 | my $scfg = storage_config($cfg, $storeid); |
| | 140 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 141 | return $plugin->volume_resize($scfg, $storeid, $volname, $size, $running); |
| | 142 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 143 | die "resize file/device '$volid' is not possible\n"; |
| | 144 | } else { |
| | 145 | die "unable to parse volume ID '$volid'\n"; |
| | 146 | } |
| | 147 | } |
| | 148 | |
| | 149 | sub volume_rollback_is_possible { |
| | 150 | my ($cfg, $volid, $snap) = @_; |
| | 151 | |
| | 152 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 153 | if ($storeid) { |
| | 154 | my $scfg = storage_config($cfg, $storeid); |
| | 155 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 156 | return $plugin->volume_rollback_is_possible($scfg, $storeid, $volname, $snap); |
| | 157 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 158 | die "snapshot rollback file/device '$volid' is not possible\n"; |
| | 159 | } else { |
| | 160 | die "unable to parse volume ID '$volid'\n"; |
| | 161 | } |
| | 162 | } |
| | 163 | |
| | 164 | sub volume_snapshot { |
| | 165 | my ($cfg, $volid, $snap) = @_; |
| | 166 | |
| | 167 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 168 | if ($storeid) { |
| | 169 | my $scfg = storage_config($cfg, $storeid); |
| | 170 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 171 | return $plugin->volume_snapshot($scfg, $storeid, $volname, $snap); |
| | 172 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 173 | die "snapshot file/device '$volid' is not possible\n"; |
| | 174 | } else { |
| | 175 | die "unable to parse volume ID '$volid'\n"; |
| | 176 | } |
| | 177 | } |
| | 178 | |
| | 179 | sub volume_snapshot_rollback { |
| | 180 | my ($cfg, $volid, $snap) = @_; |
| | 181 | |
| | 182 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 183 | if ($storeid) { |
| | 184 | my $scfg = storage_config($cfg, $storeid); |
| | 185 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 186 | $plugin->volume_rollback_is_possible($scfg, $storeid, $volname, $snap); |
| | 187 | return $plugin->volume_snapshot_rollback($scfg, $storeid, $volname, $snap); |
| | 188 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 189 | die "snapshot rollback file/device '$volid' is not possible\n"; |
| | 190 | } else { |
| | 191 | die "unable to parse volume ID '$volid'\n"; |
| | 192 | } |
| | 193 | } |
| | 194 | |
| | 195 | sub volume_snapshot_delete { |
| | 196 | my ($cfg, $volid, $snap, $running) = @_; |
| | 197 | |
| | 198 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 199 | if ($storeid) { |
| | 200 | my $scfg = storage_config($cfg, $storeid); |
| | 201 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 202 | return $plugin->volume_snapshot_delete($scfg, $storeid, $volname, $snap, $running); |
| | 203 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 204 | die "snapshot delete file/device '$volid' is not possible\n"; |
| | 205 | } else { |
| | 206 | die "unable to parse volume ID '$volid'\n"; |
| | 207 | } |
| | 208 | } |
| | 209 | |
| | 210 | sub volume_has_feature { |
| | 211 | my ($cfg, $feature, $volid, $snap, $running) = @_; |
| | 212 | |
| | 213 | my ($storeid, $volname) = parse_volume_id($volid, 1); |
| | 214 | if ($storeid) { |
| | 215 | my $scfg = storage_config($cfg, $storeid); |
| | 216 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 217 | return $plugin->volume_has_feature($scfg, $feature, $storeid, $volname, $snap, $running); |
| | 218 | } elsif ($volid =~ m|^(/.+)$| && -e $volid) { |
| | 219 | return undef; |
| | 220 | } else { |
| | 221 | return undef; |
| | 222 | } |
| | 223 | } |
| | 224 | |
| | 225 | sub get_image_dir { |
| | 226 | my ($cfg, $storeid, $vmid) = @_; |
| | 227 | |
| | 228 | my $scfg = storage_config($cfg, $storeid); |
| | 229 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 230 | |
| | 231 | my $path = $plugin->get_subdir($scfg, 'images'); |
| | 232 | |
| | 233 | return $vmid ? "$path/$vmid" : $path; |
| | 234 | } |
| | 235 | |
| | 236 | sub get_private_dir { |
| | 237 | my ($cfg, $storeid, $vmid) = @_; |
| | 238 | |
| | 239 | my $scfg = storage_config($cfg, $storeid); |
| | 240 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 241 | |
| | 242 | my $path = $plugin->get_subdir($scfg, 'rootdir'); |
| | 243 | |
| | 244 | return $vmid ? "$path/$vmid" : $path; |
| | 245 | } |
| | 246 | |
| | 247 | sub get_iso_dir { |
| | 248 | my ($cfg, $storeid) = @_; |
| | 249 | |
| | 250 | my $scfg = storage_config($cfg, $storeid); |
| | 251 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 252 | |
| | 253 | return $plugin->get_subdir($scfg, 'iso'); |
| | 254 | } |
| | 255 | |
| | 256 | sub get_vztmpl_dir { |
| | 257 | my ($cfg, $storeid) = @_; |
| | 258 | |
| | 259 | my $scfg = storage_config($cfg, $storeid); |
| | 260 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 261 | |
| | 262 | return $plugin->get_subdir($scfg, 'vztmpl'); |
| | 263 | } |
| | 264 | |
| | 265 | sub get_backup_dir { |
| | 266 | my ($cfg, $storeid) = @_; |
| | 267 | |
| | 268 | my $scfg = storage_config($cfg, $storeid); |
| | 269 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 270 | |
| | 271 | return $plugin->get_subdir($scfg, 'backup'); |
| | 272 | } |
| | 273 | |
| | 274 | # library implementation |
| | 275 | |
| | 276 | sub parse_vmid { |
| | 277 | my $vmid = shift; |
| | 278 | |
| | 279 | die "VMID '$vmid' contains illegal characters\n" if $vmid !~ m/^\d+$/; |
| | 280 | |
| | 281 | return int($vmid); |
| | 282 | } |
| | 283 | |
| | 284 | sub parse_volname { |
| | 285 | my ($cfg, $volid) = @_; |
| | 286 | |
| | 287 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 288 | |
| | 289 | my $scfg = storage_config($cfg, $storeid); |
| | 290 | |
| | 291 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 292 | return $plugin->parse_volname($volname); |
| | 293 | } |
| | 294 | |
| | 295 | sub parse_volume_id { |
| | 296 | my ($volid, $noerr) = @_; |
| | 297 | |
| | 298 | return PVE::Storage::Plugin::parse_volume_id($volid, $noerr); |
| | 299 | } |
| | 300 | |
| | 301 | sub volume_is_base { |
| | 302 | my ($cfg, $volid) = @_; |
| | 303 | |
| | 304 | my ($sid, $volname) = parse_volume_id($volid, 1); |
| | 305 | return 0 if !$sid; |
| | 306 | |
| | 307 | if (my $scfg = $cfg->{ids}->{$sid}) { |
| | 308 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 309 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) = |
| | 310 | $plugin->parse_volname($volname); |
| | 311 | return $isBase ? 1 : 0; |
| | 312 | } else { |
| | 313 | # stale volid with undefined storage - so we can just guess |
| | 314 | if ($volid =~ m/base-/) { |
| | 315 | return 1; |
| | 316 | } |
| | 317 | } |
| | 318 | |
| | 319 | return 0; |
| | 320 | } |
| | 321 | |
| | 322 | # try to map a filesystem path to a volume identifier |
| | 323 | sub path_to_volume_id { |
| | 324 | my ($cfg, $path) = @_; |
| | 325 | |
| | 326 | my $ids = $cfg->{ids}; |
| | 327 | |
| | 328 | my ($sid, $volname) = parse_volume_id($path, 1); |
| | 329 | if ($sid) { |
| | 330 | if (my $scfg = $ids->{$sid}) { |
| | 331 | if ($scfg->{path}) { |
| | 332 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 333 | my ($vtype, $name, $vmid) = $plugin->parse_volname($volname); |
| | 334 | return ($vtype, $path); |
| | 335 | } |
| | 336 | } |
| | 337 | return (''); |
| | 338 | } |
| | 339 | |
| | 340 | # Note: abs_path() return undef if $path doesn not exist |
| | 341 | # for example when nfs storage is not mounted |
| | 342 | $path = abs_path($path) || $path; |
| | 343 | |
| | 344 | foreach my $sid (keys %$ids) { |
| | 345 | my $scfg = $ids->{$sid}; |
| | 346 | next if !$scfg->{path}; |
| | 347 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 348 | my $imagedir = $plugin->get_subdir($scfg, 'images'); |
| | 349 | my $isodir = $plugin->get_subdir($scfg, 'iso'); |
| | 350 | my $tmpldir = $plugin->get_subdir($scfg, 'vztmpl'); |
| | 351 | my $backupdir = $plugin->get_subdir($scfg, 'backup'); |
| | 352 | my $privatedir = $plugin->get_subdir($scfg, 'rootdir'); |
| | 353 | |
| | 354 | if ($path =~ m!^$imagedir/(\d+)/([^/\s]+)$!) { |
| | 355 | my $vmid = $1; |
| | 356 | my $name = $2; |
| | 357 | |
| | 358 | my $vollist = $plugin->list_images($sid, $scfg, $vmid); |
| | 359 | foreach my $info (@$vollist) { |
| | 360 | my ($storeid, $volname) = parse_volume_id($info->{volid}); |
| | 361 | my $volpath = $plugin->path($scfg, $volname, $storeid); |
| | 362 | if ($volpath eq $path) { |
| | 363 | return ('images', $info->{volid}); |
| | 364 | } |
| | 365 | } |
| | 366 | } elsif ($path =~ m!^$isodir/([^/]+\.[Ii][Ss][Oo])$!) { |
| | 367 | my $name = $1; |
| | 368 | return ('iso', "$sid:iso/$name"); |
| | 369 | } elsif ($path =~ m!^$tmpldir/([^/]+\.tar\.gz)$!) { |
| | 370 | my $name = $1; |
| | 371 | return ('vztmpl', "$sid:vztmpl/$name"); |
| | 372 | } elsif ($path =~ m!^$privatedir/(\d+)$!) { |
| | 373 | my $vmid = $1; |
| | 374 | return ('rootdir', "$sid:rootdir/$vmid"); |
| | 375 | } elsif ($path =~ m!^$backupdir/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz|vma|vma\.gz|vma\.lzo))$!) { |
| | 376 | my $name = $1; |
| | 377 | return ('iso', "$sid:backup/$name"); |
| | 378 | } |
| | 379 | } |
| | 380 | |
| | 381 | # can't map path to volume id |
| | 382 | return (''); |
| | 383 | } |
| | 384 | |
| | 385 | sub path { |
| | 386 | my ($cfg, $volid, $snapname) = @_; |
| | 387 | |
| | 388 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 389 | |
| | 390 | my $scfg = storage_config($cfg, $storeid); |
| | 391 | |
| | 392 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 393 | my ($path, $owner, $vtype) = $plugin->path($scfg, $volname, $storeid, $snapname); |
| | 394 | return wantarray ? ($path, $owner, $vtype) : $path; |
| | 395 | } |
| | 396 | |
| | 397 | sub abs_filesystem_path { |
| | 398 | my ($cfg, $volid) = @_; |
| | 399 | |
| | 400 | my $path; |
| | 401 | if (PVE::Storage::parse_volume_id ($volid, 1)) { |
| | 402 | PVE::Storage::activate_volumes($cfg, [ $volid ]); |
| | 403 | $path = PVE::Storage::path($cfg, $volid); |
| | 404 | } else { |
| | 405 | if (-f $volid) { |
| | 406 | my $abspath = abs_path($volid); |
| | 407 | if ($abspath && $abspath =~ m|^(/.+)$|) { |
| | 408 | $path = $1; # untaint any path |
| | 409 | } |
| | 410 | } |
| | 411 | } |
| | 412 | |
| | 413 | die "can't find file '$volid'\n" if !($path && -f $path); |
| | 414 | |
| | 415 | return $path; |
| | 416 | } |
| | 417 | |
| | 418 | sub storage_migrate { |
| | 419 | my ($cfg, $volid, $target_host, $target_storeid, $target_volname) = @_; |
| | 420 | |
| | 421 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 422 | $target_volname = $volname if !$target_volname; |
| | 423 | |
| | 424 | my $scfg = storage_config($cfg, $storeid); |
| | 425 | |
| | 426 | # no need to migrate shared content |
| | 427 | return if $storeid eq $target_storeid && $scfg->{shared}; |
| | 428 | |
| | 429 | my $tcfg = storage_config($cfg, $target_storeid); |
| | 430 | |
| | 431 | my $target_volid = "${target_storeid}:${target_volname}"; |
| | 432 | |
| | 433 | my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_host'"; |
| | 434 | |
| | 435 | my $sshoptions = "-o 'BatchMode=yes'"; |
| | 436 | my $ssh = "/usr/bin/ssh $sshoptions"; |
| | 437 | |
| | 438 | local $ENV{RSYNC_RSH} = $ssh; |
| | 439 | |
| | 440 | # only implemented for file system based storage |
| | 441 | if ($scfg->{path}) { |
| | 442 | if ($tcfg->{path}) { |
| | 443 | |
| | 444 | my $src_plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 445 | my $dst_plugin = PVE::Storage::Plugin->lookup($tcfg->{type}); |
| | 446 | my $src = $src_plugin->path($scfg, $volname, $storeid); |
| | 447 | my $dst = $dst_plugin->path($tcfg, $target_volname, $target_storeid); |
| | 448 | |
| | 449 | my $dirname = dirname($dst); |
| | 450 | |
| | 451 | if ($tcfg->{shared}) { # we can do a local copy |
| | 452 | |
| | 453 | run_command(['/bin/mkdir', '-p', $dirname]); |
| | 454 | |
| | 455 | run_command(['/bin/cp', $src, $dst]); |
| | 456 | |
| | 457 | } else { |
| | 458 | |
| | 459 | run_command(['/usr/bin/ssh', "root\@${target_host}", |
| | 460 | '/bin/mkdir', '-p', $dirname]); |
| | 461 | |
| | 462 | # we use rsync with --sparse, so we can't use --inplace, |
| | 463 | # so we remove file on the target if it already exists to |
| | 464 | # save space |
| | 465 | my ($size, $format) = PVE::Storage::Plugin::file_size_info($src); |
| | 466 | if ($format && ($format eq 'raw') && $size) { |
| | 467 | run_command(['/usr/bin/ssh', "root\@${target_host}", |
| | 468 | 'rm', '-f', $dst], |
| | 469 | outfunc => sub {}); |
| | 470 | } |
| | 471 | |
| | 472 | my $cmd = ['/usr/bin/rsync', '--progress', '--sparse', '--whole-file', |
| | 473 | $src, "root\@${target_host}:$dst"]; |
| | 474 | |
| | 475 | my $percent = -1; |
| | 476 | |
| | 477 | run_command($cmd, outfunc => sub { |
| | 478 | my $line = shift; |
| | 479 | |
| | 480 | if ($line =~ m/^\s*(\d+\s+(\d+)%\s.*)$/) { |
| | 481 | if ($2 > $percent) { |
| | 482 | $percent = $2; |
| | 483 | print "rsync status: $1\n"; |
| | 484 | *STDOUT->flush(); |
| | 485 | } |
| | 486 | } else { |
| | 487 | print "$line\n"; |
| | 488 | *STDOUT->flush(); |
| | 489 | } |
| | 490 | }); |
| | 491 | } |
| | 492 | } else { |
| | 493 | die "$errstr - target type '$tcfg->{type}' not implemented\n"; |
| | 494 | } |
| | 495 | |
| | 496 | } elsif ($scfg->{type} eq 'zfspool') { |
| | 497 | |
| | 498 | if ($tcfg->{type} eq 'zfspool') { |
| | 499 | |
| | 500 | die "$errstr - pool on target has not same name as source!" |
| | 501 | if $tcfg->{pool} ne $scfg->{pool}; |
| | 502 | |
| | 503 | my (undef, $volname) = parse_volname($cfg, $volid); |
| | 504 | |
| | 505 | my $zfspath = "$scfg->{pool}\/$volname"; |
| | 506 | |
| | 507 | my $snap = "zfs snapshot $zfspath\@__migration__"; |
| | 508 | |
| | 509 | my $send = "zfs send -v $zfspath\@__migration__ \| ssh root\@$target_host zfs recv $zfspath"; |
| | 510 | |
| | 511 | my $destroy_target = "ssh root\@$target_host zfs destroy $zfspath\@__migration__"; |
| | 512 | run_command($snap); |
| | 513 | eval{ |
| | 514 | run_command($send); |
| | 515 | }; |
| | 516 | my $err; |
| | 517 | if ($err = $@){ |
| | 518 | run_command("zfs destroy $zfspath\@__migration__"); |
| | 519 | die $err; |
| | 520 | } |
| | 521 | run_command($destroy_target); |
| | 522 | |
| | 523 | } else { |
| | 524 | die "$errstr - target type $tcfg->{type} is not valid\n"; |
| | 525 | } |
| | 526 | } else { |
| | 527 | die "$errstr - source type '$scfg->{type}' not implemented\n"; |
| | 528 | } |
| | 529 | } |
| | 530 | |
| | 531 | sub vdisk_clone { |
| | 532 | my ($cfg, $volid, $vmid, $snap) = @_; |
| | 533 | |
| | 534 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 535 | |
| | 536 | my $scfg = storage_config($cfg, $storeid); |
| | 537 | |
| | 538 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 539 | |
| | 540 | activate_storage($cfg, $storeid); |
| | 541 | |
| | 542 | # lock shared storage |
| | 543 | return $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { |
| | 544 | my $volname = $plugin->clone_image($scfg, $storeid, $volname, $vmid, $snap); |
| | 545 | return "$storeid:$volname"; |
| | 546 | }); |
| | 547 | } |
| | 548 | |
| | 549 | sub vdisk_create_base { |
| | 550 | my ($cfg, $volid) = @_; |
| | 551 | |
| | 552 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 553 | |
| | 554 | my $scfg = storage_config($cfg, $storeid); |
| | 555 | |
| | 556 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 557 | |
| | 558 | activate_storage($cfg, $storeid); |
| | 559 | |
| | 560 | # lock shared storage |
| | 561 | return $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { |
| | 562 | my $volname = $plugin->create_base($storeid, $scfg, $volname); |
| | 563 | return "$storeid:$volname"; |
| | 564 | }); |
| | 565 | } |
| | 566 | |
| | 567 | sub vdisk_alloc { |
| | 568 | my ($cfg, $storeid, $vmid, $fmt, $name, $size) = @_; |
| | 569 | |
| | 570 | die "no storage id specified\n" if !$storeid; |
| | 571 | |
| | 572 | PVE::JSONSchema::parse_storage_id($storeid); |
| | 573 | |
| | 574 | my $scfg = storage_config($cfg, $storeid); |
| | 575 | |
| | 576 | die "no VMID specified\n" if !$vmid; |
| | 577 | |
| | 578 | $vmid = parse_vmid($vmid); |
| | 579 | |
| | 580 | my $defformat = PVE::Storage::Plugin::default_format($scfg); |
| | 581 | |
| | 582 | $fmt = $defformat if !$fmt; |
| | 583 | |
| | 584 | activate_storage($cfg, $storeid); |
| | 585 | |
| | 586 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 587 | |
| | 588 | # lock shared storage |
| | 589 | return $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { |
| | 590 | my $volname = $plugin->alloc_image($storeid, $scfg, $vmid, $fmt, $name, $size); |
| | 591 | return "$storeid:$volname"; |
| | 592 | }); |
| | 593 | } |
| | 594 | |
| | 595 | sub vdisk_free { |
| | 596 | my ($cfg, $volid) = @_; |
| | 597 | |
| | 598 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 599 | |
| | 600 | my $scfg = storage_config($cfg, $storeid); |
| | 601 | |
| | 602 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 603 | |
| | 604 | activate_storage($cfg, $storeid); |
| | 605 | |
| | 606 | my $cleanup_worker; |
| | 607 | |
| | 608 | # lock shared storage |
| | 609 | $plugin->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub { |
| | 610 | |
| | 611 | my ($vtype, $name, $vmid, undef, undef, $isBase) = |
| | 612 | $plugin->parse_volname($volname); |
| | 613 | if ($isBase) { |
| | 614 | my $vollist = $plugin->list_images($storeid, $scfg); |
| | 615 | foreach my $info (@$vollist) { |
| | 616 | my (undef, $tmpvolname) = parse_volume_id($info->{volid}); |
| | 617 | my $basename = undef; |
| | 618 | my $basevmid = undef; |
| | 619 | |
| | 620 | eval{ |
| | 621 | (undef, undef, undef, $basename, $basevmid) = |
| | 622 | $plugin->parse_volname($tmpvolname); |
| | 623 | }; |
| | 624 | |
| | 625 | if ($basename && defined($basevmid) && $basevmid == $vmid && $basename eq $name) { |
| | 626 | die "base volume '$volname' is still in use " . |
| | 627 | "(use by '$tmpvolname')\n"; |
| | 628 | } |
| | 629 | } |
| | 630 | } |
| | 631 | $cleanup_worker = $plugin->free_image($storeid, $scfg, $volname, $isBase); |
| | 632 | }); |
| | 633 | |
| | 634 | return if !$cleanup_worker; |
| | 635 | |
| | 636 | my $rpcenv = PVE::RPCEnvironment::get(); |
| | 637 | my $authuser = $rpcenv->get_user(); |
| | 638 | |
| | 639 | $rpcenv->fork_worker('imgdel', undef, $authuser, $cleanup_worker); |
| | 640 | } |
| | 641 | |
| | 642 | #list iso or openvz template ($tt = <iso|vztmpl|backup>) |
| | 643 | sub template_list { |
| | 644 | my ($cfg, $storeid, $tt) = @_; |
| | 645 | |
| | 646 | die "unknown template type '$tt'\n" |
| | 647 | if !($tt eq 'iso' || $tt eq 'vztmpl' || $tt eq 'backup'); |
| | 648 | |
| | 649 | my $ids = $cfg->{ids}; |
| | 650 | |
| | 651 | storage_check_enabled($cfg, $storeid) if ($storeid); |
| | 652 | |
| | 653 | my $res = {}; |
| | 654 | |
| | 655 | # query the storage |
| | 656 | |
| | 657 | foreach my $sid (keys %$ids) { |
| | 658 | next if $storeid && $storeid ne $sid; |
| | 659 | |
| | 660 | my $scfg = $ids->{$sid}; |
| | 661 | my $type = $scfg->{type}; |
| | 662 | |
| | 663 | next if !storage_check_enabled($cfg, $sid, undef, 1); |
| | 664 | |
| | 665 | next if $tt eq 'iso' && !$scfg->{content}->{iso}; |
| | 666 | next if $tt eq 'vztmpl' && !$scfg->{content}->{vztmpl}; |
| | 667 | next if $tt eq 'backup' && !$scfg->{content}->{backup}; |
| | 668 | |
| | 669 | activate_storage($cfg, $sid); |
| | 670 | |
| | 671 | if ($scfg->{path}) { |
| | 672 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 673 | |
| | 674 | my $path = $plugin->get_subdir($scfg, $tt); |
| | 675 | |
| | 676 | foreach my $fn (<$path/*>) { |
| | 677 | |
| | 678 | my $info; |
| | 679 | |
| | 680 | if ($tt eq 'iso') { |
| | 681 | next if $fn !~ m!/([^/]+\.[Ii][Ss][Oo])$!; |
| | 682 | |
| | 683 | $info = { volid => "$sid:iso/$1", format => 'iso' }; |
| | 684 | |
| | 685 | } elsif ($tt eq 'vztmpl') { |
| | 686 | next if $fn !~ m!/([^/]+\.tar\.([gx]z))$!; |
| | 687 | |
| | 688 | $info = { volid => "$sid:vztmpl/$1", format => "t$2" }; |
| | 689 | |
| | 690 | } elsif ($tt eq 'backup') { |
| | 691 | next if $fn !~ m!/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz|vma|vma\.gz|vma\.lzo))$!; |
| | 692 | |
| | 693 | $info = { volid => "$sid:backup/$1", format => $2 }; |
| | 694 | } |
| | 695 | |
| | 696 | $info->{size} = -s $fn; |
| | 697 | |
| | 698 | push @{$res->{$sid}}, $info; |
| | 699 | } |
| | 700 | |
| | 701 | } |
| | 702 | |
| | 703 | @{$res->{$sid}} = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @{$res->{$sid}} if $res->{$sid}; |
| | 704 | } |
| | 705 | |
| | 706 | return $res; |
| | 707 | } |
| | 708 | |
| | 709 | |
| | 710 | sub vdisk_list { |
| | 711 | my ($cfg, $storeid, $vmid, $vollist) = @_; |
| | 712 | |
| | 713 | my $ids = $cfg->{ids}; |
| | 714 | |
| | 715 | storage_check_enabled($cfg, $storeid) if ($storeid); |
| | 716 | |
| | 717 | my $res = {}; |
| | 718 | |
| | 719 | # prepare/activate/refresh all storages |
| | 720 | |
| | 721 | my $storage_list = []; |
| | 722 | if ($vollist) { |
| | 723 | foreach my $volid (@$vollist) { |
| | 724 | my ($sid, undef) = parse_volume_id($volid); |
| | 725 | next if !defined($ids->{$sid}); |
| | 726 | next if !storage_check_enabled($cfg, $sid, undef, 1); |
| | 727 | push @$storage_list, $sid; |
| | 728 | } |
| | 729 | } else { |
| | 730 | foreach my $sid (keys %$ids) { |
| | 731 | next if $storeid && $storeid ne $sid; |
| | 732 | next if !storage_check_enabled($cfg, $sid, undef, 1); |
| | 733 | push @$storage_list, $sid; |
| | 734 | } |
| | 735 | } |
| | 736 | |
| | 737 | my $cache = {}; |
| | 738 | |
| | 739 | activate_storage_list($cfg, $storage_list, $cache); |
| | 740 | |
| | 741 | foreach my $sid (keys %$ids) { |
| | 742 | next if $storeid && $storeid ne $sid; |
| | 743 | next if !storage_check_enabled($cfg, $sid, undef, 1); |
| | 744 | |
| | 745 | my $scfg = $ids->{$sid}; |
| | 746 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 747 | $res->{$sid} = $plugin->list_images($sid, $scfg, $vmid, $vollist, $cache); |
| | 748 | @{$res->{$sid}} = sort {lc($a->{volid}) cmp lc ($b->{volid}) } @{$res->{$sid}} if $res->{$sid}; |
| | 749 | } |
| | 750 | |
| | 751 | return $res; |
| | 752 | } |
| | 753 | |
| | 754 | sub uevent_seqnum { |
| | 755 | |
| | 756 | my $filename = "/sys/kernel/uevent_seqnum"; |
| | 757 | |
| | 758 | my $seqnum = 0; |
| | 759 | if (my $fh = IO::File->new($filename, "r")) { |
| | 760 | my $line = <$fh>; |
| | 761 | if ($line =~ m/^(\d+)$/) { |
| | 762 | $seqnum = int($1); |
| | 763 | } |
| | 764 | close ($fh); |
| | 765 | } |
| | 766 | return $seqnum; |
| | 767 | } |
| | 768 | |
| | 769 | sub activate_storage { |
| | 770 | my ($cfg, $storeid, $cache) = @_; |
| | 771 | |
| | 772 | $cache = {} if !$cache; |
| | 773 | |
| | 774 | my $scfg = storage_check_enabled($cfg, $storeid); |
| | 775 | |
| | 776 | return if $cache->{activated}->{$storeid}; |
| | 777 | |
| | 778 | $cache->{uevent_seqnum} = uevent_seqnum() if !$cache->{uevent_seqnum}; |
| | 779 | |
| | 780 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 781 | |
| | 782 | if ($scfg->{base}) { |
| | 783 | my ($baseid, undef) = parse_volume_id ($scfg->{base}); |
| | 784 | activate_storage($cfg, $baseid, $cache); |
| | 785 | } |
| | 786 | |
| | 787 | if (!$plugin->check_connection($storeid, $scfg)) { |
| | 788 | die "storage '$storeid' is not online\n"; |
| | 789 | } |
| | 790 | |
| | 791 | $plugin->activate_storage($storeid, $scfg, $cache); |
| | 792 | |
| | 793 | my $newseq = uevent_seqnum (); |
| | 794 | |
| | 795 | # only call udevsettle if there are events |
| | 796 | if ($newseq > $cache->{uevent_seqnum}) { |
| | 797 | my $timeout = 30; |
| | 798 | system ("$UDEVADM settle --timeout=$timeout"); # ignore errors |
| | 799 | $cache->{uevent_seqnum} = $newseq; |
| | 800 | } |
| | 801 | |
| | 802 | $cache->{activated}->{$storeid} = 1; |
| | 803 | } |
| | 804 | |
| | 805 | sub activate_storage_list { |
| | 806 | my ($cfg, $storeid_list, $cache) = @_; |
| | 807 | |
| | 808 | $cache = {} if !$cache; |
| | 809 | |
| | 810 | foreach my $storeid (@$storeid_list) { |
| | 811 | activate_storage($cfg, $storeid, $cache); |
| | 812 | } |
| | 813 | } |
| | 814 | |
| | 815 | sub deactivate_storage { |
| | 816 | my ($cfg, $storeid) = @_; |
| | 817 | |
| | 818 | my $scfg = storage_config ($cfg, $storeid); |
| | 819 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 820 | |
| | 821 | my $cache = {}; |
| | 822 | $plugin->deactivate_storage($storeid, $scfg, $cache); |
| | 823 | } |
| | 824 | |
| | 825 | sub activate_volumes { |
| | 826 | my ($cfg, $vollist, $exclusive) = @_; |
| | 827 | |
| | 828 | return if !($vollist && scalar(@$vollist)); |
| | 829 | |
| | 830 | my $storagehash = {}; |
| | 831 | foreach my $volid (@$vollist) { |
| | 832 | my ($storeid, undef) = parse_volume_id($volid); |
| | 833 | $storagehash->{$storeid} = 1; |
| | 834 | } |
| | 835 | |
| | 836 | my $cache = {}; |
| | 837 | |
| | 838 | activate_storage_list($cfg, [keys %$storagehash], $cache); |
| | 839 | |
| | 840 | foreach my $volid (@$vollist) { |
| | 841 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 842 | my $scfg = storage_config($cfg, $storeid); |
| | 843 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 844 | $plugin->activate_volume($storeid, $scfg, $volname, $exclusive, $cache); |
| | 845 | } |
| | 846 | } |
| | 847 | |
| | 848 | sub deactivate_volumes { |
| | 849 | my ($cfg, $vollist) = @_; |
| | 850 | |
| | 851 | return if !($vollist && scalar(@$vollist)); |
| | 852 | |
| | 853 | my $cache = {}; |
| | 854 | |
| | 855 | my @errlist = (); |
| | 856 | foreach my $volid (@$vollist) { |
| | 857 | my ($storeid, $volname) = parse_volume_id($volid); |
| | 858 | |
| | 859 | my $scfg = storage_config($cfg, $storeid); |
| | 860 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 861 | |
| | 862 | eval { |
| | 863 | $plugin->deactivate_volume($storeid, $scfg, $volname, $cache); |
| | 864 | }; |
| | 865 | if (my $err = $@) { |
| | 866 | warn $err; |
| | 867 | push @errlist, $volid; |
| | 868 | } |
| | 869 | } |
| | 870 | |
| | 871 | die "volume deativation failed: " . join(' ', @errlist) |
| | 872 | if scalar(@errlist); |
| | 873 | } |
| | 874 | |
| | 875 | sub storage_info { |
| | 876 | my ($cfg, $content) = @_; |
| | 877 | |
| | 878 | my $ids = $cfg->{ids}; |
| | 879 | |
| | 880 | my $info = {}; |
| | 881 | |
| | 882 | my $slist = []; |
| | 883 | foreach my $storeid (keys %$ids) { |
| | 884 | |
| | 885 | next if $content && !$ids->{$storeid}->{content}->{$content}; |
| | 886 | |
| | 887 | next if !storage_check_enabled($cfg, $storeid, undef, 1); |
| | 888 | |
| | 889 | my $type = $ids->{$storeid}->{type}; |
| | 890 | |
| | 891 | $info->{$storeid} = { |
| | 892 | type => $type, |
| | 893 | total => 0, |
| | 894 | avail => 0, |
| | 895 | used => 0, |
| | 896 | shared => $ids->{$storeid}->{shared} ? 1 : 0, |
| | 897 | content => PVE::Storage::Plugin::content_hash_to_string($ids->{$storeid}->{content}), |
| | 898 | active => 0, |
| | 899 | }; |
| | 900 | |
| | 901 | push @$slist, $storeid; |
| | 902 | } |
| | 903 | |
| | 904 | my $cache = {}; |
| | 905 | |
| | 906 | foreach my $storeid (keys %$ids) { |
| | 907 | my $scfg = $ids->{$storeid}; |
| | 908 | next if !$info->{$storeid}; |
| | 909 | |
| | 910 | eval { activate_storage($cfg, $storeid, $cache); }; |
| | 911 | if (my $err = $@) { |
| | 912 | warn $err; |
| | 913 | next; |
| | 914 | } |
| | 915 | |
| | 916 | my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); |
| | 917 | my ($total, $avail, $used, $active); |
| | 918 | eval { ($total, $avail, $used, $active) = $plugin->status($storeid, $scfg, $cache); }; |
| | 919 | warn $@ if $@; |
| | 920 | next if !$active; |
| | 921 | $info->{$storeid}->{total} = $total; |
| | 922 | $info->{$storeid}->{avail} = $avail; |
| | 923 | $info->{$storeid}->{used} = $used; |
| | 924 | $info->{$storeid}->{active} = $active; |
| | 925 | } |
| | 926 | |
| | 927 | return $info; |
| | 928 | } |
| | 929 | |
| | 930 | sub resolv_server { |
| | 931 | my ($server) = @_; |
| | 932 | |
| | 933 | my ($packed_ip, $family); |
| | 934 | eval { |
| | 935 | my @res = PVE::Tools::getaddrinfo_all($server); |
| | 936 | $family = $res[0]->{family}; |
| | 937 | $packed_ip = (PVE::Tools::unpack_sockaddr_in46($res[0]->{addr}))[2]; |
| | 938 | }; |
| | 939 | if (defined $packed_ip) { |
| | 940 | return Socket::inet_ntop($family, $packed_ip); |
| | 941 | } |
| | 942 | return undef; |
| | 943 | } |
| | 944 | |
| | 945 | sub scan_nfs { |
| | 946 | my ($server_in) = @_; |
| | 947 | |
| | 948 | my $server; |
| | 949 | if (!($server = resolv_server ($server_in))) { |
| | 950 | die "unable to resolve address for server '${server_in}'\n"; |
| | 951 | } |
| | 952 | |
| | 953 | my $cmd = ['/sbin/showmount', '--no-headers', '--exports', $server]; |
| | 954 | |
| | 955 | my $res = {}; |
| | 956 | run_command($cmd, outfunc => sub { |
| | 957 | my $line = shift; |
| | 958 | |
| | 959 | # note: howto handle white spaces in export path?? |
| | 960 | if ($line =~ m!^(/\S+)\s+(.+)$!) { |
| | 961 | $res->{$1} = $2; |
| | 962 | } |
| | 963 | }); |
| | 964 | |
| | 965 | return $res; |
| | 966 | } |
| | 967 | |
| | 968 | sub scan_zfs { |
| | 969 | |
| | 970 | my $cmd = ['zpool', 'list', '-H', '-o', 'name,size,free']; |
| | 971 | |
| | 972 | my $res = []; |
| | 973 | run_command($cmd, outfunc => sub { |
| | 974 | my $line = shift; |
| | 975 | |
| | 976 | if ($line =~m/^(\S+)\s+(\S+)\s+(\S+)$/) { |
| | 977 | my ($pool, $size_str, $free_str) = ($1, $2, $3); |
| | 978 | my $size = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($size_str); |
| | 979 | my $free = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($free_str); |
| | 980 | push @$res, { pool => $pool, size => $size, free => $free }; |
| | 981 | } |
| | 982 | }); |
| | 983 | |
| | 984 | return $res; |
| | 985 | } |
| | 986 | |
| | 987 | sub resolv_portal { |
| | 988 | my ($portal, $noerr) = @_; |
| | 989 | |
| | 990 | if ($portal =~ m/^([^:]+)(:(\d+))?$/) { |
| | 991 | my $server = $1; |
| | 992 | my $port = $3; |
| | 993 | |
| | 994 | if (my $ip = resolv_server($server)) { |
| | 995 | $server = $ip; |
| | 996 | return $port ? "$server:$port" : $server; |
| | 997 | } |
| | 998 | } |
| | 999 | return undef if $noerr; |
| | 1000 | |
| | 1001 | raise_param_exc({ portal => "unable to resolve portal address '$portal'" }); |
| | 1002 | } |
| | 1003 | |
| | 1004 | # idea is from usbutils package (/usr/bin/usb-devices) script |
| | 1005 | sub __scan_usb_device { |
| | 1006 | my ($res, $devpath, $parent, $level) = @_; |
| | 1007 | |
| | 1008 | return if ! -d $devpath; |
| | 1009 | return if $level && $devpath !~ m/^.*[-.](\d+)$/; |
| | 1010 | my $port = $level ? int($1 - 1) : 0; |
| | 1011 | |
| | 1012 | my $busnum = int(file_read_firstline("$devpath/busnum")); |
| | 1013 | my $devnum = int(file_read_firstline("$devpath/devnum")); |
| | 1014 | |
| | 1015 | my $d = { |
| | 1016 | port => $port, |
| | 1017 | level => $level, |
| | 1018 | busnum => $busnum, |
| | 1019 | devnum => $devnum, |
| | 1020 | speed => file_read_firstline("$devpath/speed"), |
| | 1021 | class => hex(file_read_firstline("$devpath/bDeviceClass")), |
| | 1022 | vendid => file_read_firstline("$devpath/idVendor"), |
| | 1023 | prodid => file_read_firstline("$devpath/idProduct"), |
| | 1024 | }; |
| | 1025 | |
| | 1026 | if ($level) { |
| | 1027 | my $usbpath = $devpath; |
| | 1028 | $usbpath =~ s|^.*/\d+\-||; |
| | 1029 | $d->{usbpath} = $usbpath; |
| | 1030 | } |
| | 1031 | |
| | 1032 | my $product = file_read_firstline("$devpath/product"); |
| | 1033 | $d->{product} = $product if $product; |
| | 1034 | |
| | 1035 | my $manu = file_read_firstline("$devpath/manufacturer"); |
| | 1036 | $d->{manufacturer} = $manu if $manu; |
| | 1037 | |
| | 1038 | my $serial => file_read_firstline("$devpath/serial"); |
| | 1039 | $d->{serial} = $serial if $serial; |
| | 1040 | |
| | 1041 | push @$res, $d; |
| | 1042 | |
| | 1043 | foreach my $subdev (<$devpath/$busnum-*>) { |
| | 1044 | next if $subdev !~ m|/$busnum-[0-9]+(\.[0-9]+)*$|; |
| | 1045 | __scan_usb_device($res, $subdev, $devnum, $level + 1); |
| | 1046 | } |
| | 1047 | |
| | 1048 | }; |
| | 1049 | |
| | 1050 | sub scan_usb { |
| | 1051 | |
| | 1052 | my $devlist = []; |
| | 1053 | |
| | 1054 | foreach my $device (</sys/bus/usb/devices/usb*>) { |
| | 1055 | __scan_usb_device($devlist, $device, 0, 0); |
| | 1056 | } |
| | 1057 | |
| | 1058 | return $devlist; |
| | 1059 | } |
| | 1060 | |
| | 1061 | sub scan_iscsi { |
| | 1062 | my ($portal_in) = @_; |
| | 1063 | |
| | 1064 | my $portal; |
| | 1065 | if (!($portal = resolv_portal($portal_in))) { |
| | 1066 | die "unable to parse/resolve portal address '${portal_in}'\n"; |
| | 1067 | } |
| | 1068 | |
| | 1069 | return PVE::Storage::ISCSIPlugin::iscsi_discovery($portal); |
| | 1070 | } |
| | 1071 | |
| | 1072 | sub storage_default_format { |
| | 1073 | my ($cfg, $storeid) = @_; |
| | 1074 | |
| | 1075 | my $scfg = storage_config ($cfg, $storeid); |
| | 1076 | |
| | 1077 | return PVE::Storage::Plugin::default_format($scfg); |
| | 1078 | } |
| | 1079 | |
| | 1080 | sub vgroup_is_used { |
| | 1081 | my ($cfg, $vgname) = @_; |
| | 1082 | |
| | 1083 | foreach my $storeid (keys %{$cfg->{ids}}) { |
| | 1084 | my $scfg = storage_config($cfg, $storeid); |
| | 1085 | if ($scfg->{type} eq 'lvm' && $scfg->{vgname} eq $vgname) { |
| | 1086 | return 1; |
| | 1087 | } |
| | 1088 | } |
| | 1089 | |
| | 1090 | return undef; |
| | 1091 | } |
| | 1092 | |
| | 1093 | sub target_is_used { |
| | 1094 | my ($cfg, $target) = @_; |
| | 1095 | |
| | 1096 | foreach my $storeid (keys %{$cfg->{ids}}) { |
| | 1097 | my $scfg = storage_config($cfg, $storeid); |
| | 1098 | if ($scfg->{type} eq 'iscsi' && $scfg->{target} eq $target) { |
| | 1099 | return 1; |
| | 1100 | } |
| | 1101 | } |
| | 1102 | |
| | 1103 | return undef; |
| | 1104 | } |
| | 1105 | |
| | 1106 | sub volume_is_used { |
| | 1107 | my ($cfg, $volid) = @_; |
| | 1108 | |
| | 1109 | foreach my $storeid (keys %{$cfg->{ids}}) { |
| | 1110 | my $scfg = storage_config($cfg, $storeid); |
| | 1111 | if ($scfg->{base} && $scfg->{base} eq $volid) { |
| | 1112 | return 1; |
| | 1113 | } |
| | 1114 | } |
| | 1115 | |
| | 1116 | return undef; |
| | 1117 | } |
| | 1118 | |
| | 1119 | sub storage_is_used { |
| | 1120 | my ($cfg, $storeid) = @_; |
| | 1121 | |
| | 1122 | foreach my $sid (keys %{$cfg->{ids}}) { |
| | 1123 | my $scfg = storage_config($cfg, $sid); |
| | 1124 | next if !$scfg->{base}; |
| | 1125 | my ($st) = parse_volume_id($scfg->{base}); |
| | 1126 | return 1 if $st && $st eq $storeid; |
| | 1127 | } |
| | 1128 | |
| | 1129 | return undef; |
| | 1130 | } |
| | 1131 | |
| | 1132 | sub foreach_volid { |
| | 1133 | my ($list, $func) = @_; |
| | 1134 | |
| | 1135 | return if !$list; |
| | 1136 | |
| | 1137 | foreach my $sid (keys %$list) { |
| | 1138 | foreach my $info (@{$list->{$sid}}) { |
| | 1139 | my $volid = $info->{volid}; |
| | 1140 | my ($sid1, $volname) = parse_volume_id($volid, 1); |
| | 1141 | if ($sid1 && $sid1 eq $sid) { |
| | 1142 | &$func ($volid, $sid, $info); |
| | 1143 | } else { |
| | 1144 | warn "detected strange volid '$volid' in volume list for '$sid'\n"; |
| | 1145 | } |
| | 1146 | } |
| | 1147 | } |
| | 1148 | } |
| | 1149 | |
| | 1150 | 1; |
projects / pve-storage.git / blame_incremental