PVE/Storage/LVMPlugin.pm

   1 package PVE::Storage::LVMPlugin;
   2
   3 use strict;
   4 use warnings;
   5
   6 use IO::File;
   7
   8 use PVE::Tools qw(run_command trim);
   9 use PVE::Storage::Plugin;
  10 use PVE::JSONSchema qw(get_standard_option);
  11
  12 use base qw(PVE::Storage::Plugin);
  13
  14 # lvm helper functions
  15
  16 my $ignore_no_medium_warnings = sub {
  17     my $line = shift;
  18     # ignore those, most of the time they're from (virtual) IPMI/iKVM devices
  19     # and just spam the log..
  20     if ($line !~ /open failed: No medium found/) {
  21         print STDERR "$line\n";
  22     }
  23 };
  24
  25 sub lvm_pv_info {
  26     my ($device) = @_;
  27
  28     die "no device specified" if !$device;
  29
  30     my $has_label = 0;
  31
  32     my $cmd = ['/usr/bin/file', '-L', '-s', $device];
  33     run_command($cmd, outfunc => sub {
  34         my $line = shift;
  35         $has_label = 1 if $line =~ m/LVM2/;
  36     });
  37
  38     return undef if !$has_label;
  39
  40     $cmd = ['/sbin/pvs', '--separator', ':', '--noheadings', '--units', 'k',
  41             '--unbuffered', '--nosuffix', '--options',
  42             'pv_name,pv_size,vg_name,pv_uuid', $device];
  43
  44     my $pvinfo;
  45     run_command($cmd, outfunc => sub {
  46         my $line = shift;
  47
  48         $line = trim($line);
  49
  50         my ($pvname, $size, $vgname, $uuid) = split(':', $line);
  51
  52         die "found multiple pvs entries for device '$device'\n"
  53             if $pvinfo;
  54
  55         $pvinfo = {
  56             pvname => $pvname,
  57             size => int($size),
  58             vgname => $vgname,
  59             uuid => $uuid,
  60         };
  61     });
  62
  63     return $pvinfo;
  64 }
  65
  66 sub clear_first_sector {
  67     my ($dev) = shift;
  68
  69     if (my $fh = IO::File->new($dev, "w")) {
  70         my $buf = 0 x 512;
  71         syswrite $fh, $buf;
  72         $fh->close();
  73     }
  74 }
  75
  76 sub lvm_create_volume_group {
  77     my ($device, $vgname, $shared) = @_;
  78
  79     my $res = lvm_pv_info($device);
  80
  81     if ($res->{vgname}) {
  82         return if $res->{vgname} eq $vgname; # already created
  83         die "device '$device' is already used by volume group '$res->{vgname}'\n";
  84     }
  85
  86     clear_first_sector($device); # else pvcreate fails
  87
  88     # we use --metadatasize 250k, which reseults in "pe_start = 512"
  89     # so pe_start is aligned on a 128k boundary (advantage for SSDs)
  90     my $cmd = ['/sbin/pvcreate', '--metadatasize', '250k', $device];
  91
  92     run_command($cmd, errmsg => "pvcreate '$device' error");
  93
  94     $cmd = ['/sbin/vgcreate', $vgname, $device];
  95     # push @$cmd, '-c', 'y' if $shared; # we do not use this yet
  96
  97     run_command($cmd, errmsg => "vgcreate $vgname $device error", errfunc => $ignore_no_medium_warnings, outfunc => $ignore_no_medium_warnings);
  98 }
  99
 100 sub lvm_vgs {
 101     my ($includepvs) = @_;
 102
 103     my $cmd = ['/sbin/vgs', '--separator', ':', '--noheadings', '--units', 'b',
 104                '--unbuffered', '--nosuffix', '--options'];
 105
 106     my $cols = [qw(vg_name vg_size vg_free lv_count)];
 107
 108     if ($includepvs) {
 109         push @$cols, qw(pv_name pv_size pv_free);
 110     }
 111
 112     push @$cmd, join(',', @$cols);
 113
 114     my $vgs = {};
 115     eval {
 116         run_command($cmd, outfunc => sub {
 117             my $line = shift;
 118             $line = trim($line);
 119
 120             my ($name, $size, $free, $lvcount, $pvname, $pvsize, $pvfree) = split (':', $line);
 121
 122             $vgs->{$name} //= {
 123                 size => int ($size),
 124                 free => int ($free),
 125                 lvcount => int($lvcount)
 126             };
 127
 128             if (defined($pvname) && defined($pvsize) && defined($pvfree)) {
 129                 push @{$vgs->{$name}->{pvs}}, {
 130                     name => $pvname,
 131                     size => int($pvsize),
 132                     free => int($pvfree),
 133                 };
 134             }
 135         },
 136         errfunc => $ignore_no_medium_warnings,
 137         );
 138     };
 139     my $err = $@;
 140
 141     # just warn (vgs return error code 5 if clvmd does not run)
 142     # but output is still OK (list without clustered VGs)
 143     warn $err if $err;
 144
 145     return $vgs;
 146 }
 147
 148 sub lvm_list_volumes {
 149     my ($vgname) = @_;
 150
 151     my $option_list = 'vg_name,lv_name,lv_size,lv_attr,pool_lv,data_percent,metadata_percent,snap_percent,uuid,tags,metadata_size,time';
 152
 153     my $cmd = [
 154         '/sbin/lvs', '--separator', ':', '--noheadings', '--units', 'b',
 155         '--unbuffered', '--nosuffix',
 156         '--config', 'report/time_format="%s"',
 157         '--options', $option_list,
 158     ];
 159
 160     push @$cmd, $vgname if $vgname;
 161
 162     my $lvs = {};
 163     run_command($cmd, outfunc => sub {
 164         my $line = shift;
 165
 166         $line = trim($line);
 167
 168         my ($vg_name, $lv_name, $lv_size, $lv_attr, $pool_lv, $data_percent, $meta_percent, $snap_percent, $uuid, $tags, $meta_size, $ctime) = split(':', $line);
 169         return if !$vg_name;
 170         return if !$lv_name;
 171
 172         my $lv_type = substr($lv_attr, 0, 1);
 173
 174         my $d = {
 175             lv_size => int($lv_size),
 176             lv_type => $lv_type,
 177         };
 178         $d->{pool_lv} = $pool_lv if $pool_lv;
 179         $d->{tags} = $tags if $tags;
 180         $d->{ctime} = $ctime;
 181
 182         if ($lv_type eq 't') {
 183             $data_percent ||= 0;
 184             $meta_percent ||= 0;
 185             $snap_percent ||= 0;
 186             $d->{metadata_size} = int($meta_size);
 187             $d->{metadata_used} = int(($meta_percent * $meta_size)/100);
 188             $d->{used} = int(($data_percent * $lv_size)/100);
 189         }
 190         $lvs->{$vg_name}->{$lv_name} = $d;
 191     },
 192     errfunc => $ignore_no_medium_warnings,
 193     );
 194
 195     return $lvs;
 196 }
 197
 198 # Configuration
 199
 200 sub type {
 201     return 'lvm';
 202 }
 203
 204 sub plugindata {
 205     return {
 206         content => [ {images => 1, rootdir => 1}, { images => 1 }],
 207     };
 208 }
 209
 210 sub properties {
 211     return {
 212         vgname => {
 213             description => "Volume group name.",
 214             type => 'string', format => 'pve-storage-vgname',
 215         },
 216         base => {
 217             description => "Base volume. This volume is automatically activated.",
 218             type => 'string', format => 'pve-volume-id',
 219         },
 220         saferemove => {
 221             description => "Zero-out data when removing LVs.",
 222             type => 'boolean',
 223         },
 224         saferemove_throughput => {
 225             description => "Wipe throughput (cstream -t parameter value).",
 226             type => 'string',
 227         },
 228         tagged_only => {
 229             description => "Only use logical volumes tagged with 'pve-vm-ID'.",
 230             type => 'boolean',
 231         }
 232     };
 233 }
 234
 235 sub options {
 236     return {
 237         vgname => { fixed => 1 },
 238         nodes => { optional => 1 },
 239         shared => { optional => 1 },
 240         disable => { optional => 1 },
 241         saferemove => { optional => 1 },
 242         saferemove_throughput => { optional => 1 },
 243         content => { optional => 1 },
 244         base => { fixed => 1, optional => 1 },
 245         tagged_only => { optional => 1 },
 246         bwlimit => { optional => 1 },
 247     };
 248 }
 249
 250 # Storage implementation
 251
 252 sub on_add_hook {
 253     my ($class, $storeid, $scfg, %param) = @_;
 254
 255     if (my $base = $scfg->{base}) {
 256         my ($baseid, $volname) = PVE::Storage::parse_volume_id($base);
 257
 258         my $cfg = PVE::Storage::config();
 259         my $basecfg = PVE::Storage::storage_config ($cfg, $baseid, 1);
 260         die "base storage ID '$baseid' does not exist\n" if !$basecfg;
 261
 262         # we only support iscsi for now
 263         die "unsupported base type '$basecfg->{type}'"
 264             if $basecfg->{type} ne 'iscsi';
 265
 266         my $path = PVE::Storage::path($cfg, $base);
 267
 268         PVE::Storage::activate_storage($cfg, $baseid);
 269
 270         lvm_create_volume_group($path, $scfg->{vgname}, $scfg->{shared});
 271     }
 272
 273     return;
 274 }
 275
 276 sub parse_volname {
 277     my ($class, $volname) = @_;
 278
 279     PVE::Storage::Plugin::parse_lvm_name($volname);
 280
 281     if ($volname =~ m/^(vm-(\d+)-\S+)$/) {
 282         return ('images', $1, $2, undef, undef, undef, 'raw');
 283     }
 284
 285     die "unable to parse lvm volume name '$volname'\n";
 286 }
 287
 288 sub filesystem_path {
 289     my ($class, $scfg, $volname, $snapname) = @_;
 290
 291     die "lvm snapshot is not implemented"if defined($snapname);
 292
 293     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
 294
 295     my $vg = $scfg->{vgname};
 296
 297     my $path = "/dev/$vg/$name";
 298
 299     return wantarray ? ($path, $vmid, $vtype) : $path;
 300 }
 301
 302 sub create_base {
 303     my ($class, $storeid, $scfg, $volname) = @_;
 304
 305     die "can't create base images in lvm storage\n";
 306 }
 307
 308 sub clone_image {
 309     my ($class, $scfg, $storeid, $volname, $vmid, $snap) = @_;
 310
 311     die "can't clone images in lvm storage\n";
 312 }
 313
 314 sub find_free_diskname {
 315     my ($class, $storeid, $scfg, $vmid, $fmt, $add_fmt_suffix) = @_;
 316
 317     my $vg = $scfg->{vgname};
 318
 319     my $lvs = lvm_list_volumes($vg);
 320
 321     my $disk_list = [ keys %{$lvs->{$vg}} ];
 322
 323     return PVE::Storage::Plugin::get_next_vm_diskname($disk_list, $storeid, $vmid, undef, $scfg);
 324 }
 325
 326 sub lvcreate {
 327     my ($vg, $name, $size, $tags) = @_;
 328
 329     if ($size =~ m/\d$/) { # no unit is given
 330         $size .= "k"; # default to kilobytes
 331     }
 332
 333     my $cmd = ['/sbin/lvcreate', '-aly', '--size', $size, '--name', $name];
 334     for my $tag (@$tags) {
 335         push @$cmd, '--addtag', $tag;
 336     }
 337     push @$cmd, $vg;
 338
 339     run_command($cmd, errmsg => "lvcreate '$vg/$name' error");
 340 }
 341
 342 sub alloc_image {
 343     my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
 344
 345     die "unsupported format '$fmt'" if $fmt ne 'raw';
 346
 347     die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
 348         if  $name && $name !~ m/^vm-$vmid-/;
 349
 350     my $vgs = lvm_vgs();
 351
 352     my $vg = $scfg->{vgname};
 353
 354     die "no such volume group '$vg'\n" if !defined ($vgs->{$vg});
 355
 356     my $free = int($vgs->{$vg}->{free});
 357
 358     die "not enough free space ($free < $size)\n" if $free < $size;
 359
 360     $name = $class->find_free_diskname($storeid, $scfg, $vmid)
 361         if !$name;
 362
 363     lvcreate($vg, $name, $size, ["pve-vm-$vmid"]);
 364
 365     return $name;
 366 }
 367
 368 sub free_image {
 369     my ($class, $storeid, $scfg, $volname, $isBase) = @_;
 370
 371     my $vg = $scfg->{vgname};
 372
 373     # we need to zero out LVM data for security reasons
 374     # and to allow thin provisioning
 375
 376     my $zero_out_worker = sub {
 377         print "zero-out data on image $volname (/dev/$vg/del-$volname)\n";
 378
 379         # wipe throughput up to 10MB/s by default; may be overwritten with saferemove_throughput
 380         my $throughput = '-10485760';
 381         if ($scfg->{saferemove_throughput}) {
 382                 $throughput = $scfg->{saferemove_throughput};
 383         }
 384
 385         my $cmd = [
 386                 '/usr/bin/cstream',
 387                 '-i', '/dev/zero',
 388                 '-o', "/dev/$vg/del-$volname",
 389                 '-T', '10',
 390                 '-v', '1',
 391                 '-b', '1048576',
 392                 '-t', "$throughput"
 393         ];
 394         eval { run_command($cmd, errmsg => "zero out finished (note: 'No space left on device' is ok here)"); };
 395         warn $@ if $@;
 396
 397         $class->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
 398             my $cmd = ['/sbin/lvremove', '-f', "$vg/del-$volname"];
 399             run_command($cmd, errmsg => "lvremove '$vg/del-$volname' error");
 400         });
 401         print "successfully removed volume $volname ($vg/del-$volname)\n";
 402     };
 403
 404     my $cmd = ['/sbin/lvchange', '-aly', "$vg/$volname"];
 405     run_command($cmd, errmsg => "can't activate LV '$vg/$volname' to zero-out its data");
 406     $cmd = ['/sbin/lvchange', '--refresh', "$vg/$volname"];
 407     run_command($cmd, errmsg => "can't refresh LV '$vg/$volname' to zero-out its data");
 408
 409     if ($scfg->{saferemove}) {
 410         # avoid long running task, so we only rename here
 411         $cmd = ['/sbin/lvrename', $vg, $volname, "del-$volname"];
 412         run_command($cmd, errmsg => "lvrename '$vg/$volname' error");
 413         return $zero_out_worker;
 414     } else {
 415         my $tmpvg = $scfg->{vgname};
 416         $cmd = ['/sbin/lvremove', '-f', "$tmpvg/$volname"];
 417         run_command($cmd, errmsg => "lvremove '$tmpvg/$volname' error");
 418     }
 419
 420     return undef;
 421 }
 422
 423 my $check_tags = sub {
 424     my ($tags) = @_;
 425
 426     return defined($tags) && $tags =~ /(^|,)pve-vm-\d+(,|$)/;
 427 };
 428
 429 sub list_images {
 430     my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
 431
 432     my $vgname = $scfg->{vgname};
 433
 434     $cache->{lvs} = lvm_list_volumes() if !$cache->{lvs};
 435
 436     my $res = [];
 437
 438     if (my $dat = $cache->{lvs}->{$vgname}) {
 439
 440         foreach my $volname (keys %$dat) {
 441
 442             next if $volname !~ m/^vm-(\d+)-/;
 443             my $owner = $1;
 444
 445             my $info = $dat->{$volname};
 446
 447             next if $scfg->{tagged_only} && !&$check_tags($info->{tags});
 448
 449             next if $info->{lv_type} ne '-';
 450
 451             my $volid = "$storeid:$volname";
 452
 453             if ($vollist) {
 454                 my $found = grep { $_ eq $volid } @$vollist;
 455                 next if !$found;
 456             } else {
 457                 next if defined($vmid) && ($owner ne $vmid);
 458             }
 459
 460             push @$res, {
 461                 volid => $volid, format => 'raw', size => $info->{lv_size}, vmid => $owner,
 462                 ctime => $info->{ctime},
 463             };
 464         }
 465     }
 466
 467     return $res;
 468 }
 469
 470 sub status {
 471     my ($class, $storeid, $scfg, $cache) = @_;
 472
 473     $cache->{vgs} = lvm_vgs() if !$cache->{vgs};
 474
 475     my $vgname = $scfg->{vgname};
 476
 477      if (my $info = $cache->{vgs}->{$vgname}) {
 478         return ($info->{size}, $info->{free}, $info->{size} - $info->{free}, 1);
 479     }
 480
 481     return undef;
 482 }
 483
 484 sub activate_storage {
 485     my ($class, $storeid, $scfg, $cache) = @_;
 486
 487     $cache->{vgs} = lvm_vgs() if !$cache->{vgs};
 488
 489     # In LVM2, vgscans take place automatically;
 490     # this is just to be sure
 491     if ($cache->{vgs} && !$cache->{vgscaned} &&
 492         !$cache->{vgs}->{$scfg->{vgname}}) {
 493         $cache->{vgscaned} = 1;
 494         my $cmd = ['/sbin/vgscan', '--ignorelockingfailure', '--mknodes'];
 495         eval { run_command($cmd, outfunc => sub {}); };
 496         warn $@ if $@;
 497     }
 498
 499     # we do not acticate any volumes here ('vgchange -aly')
 500     # instead, volumes are activate individually later
 501 }
 502
 503 sub deactivate_storage {
 504     my ($class, $storeid, $scfg, $cache) = @_;
 505
 506     my $cmd = ['/sbin/vgchange', '-aln', $scfg->{vgname}];
 507     run_command($cmd, errmsg => "can't deactivate VG '$scfg->{vgname}'");
 508 }
 509
 510 sub activate_volume {
 511     my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
 512     #fix me lvmchange is not provided on
 513     my $path = $class->path($scfg, $volname, $snapname);
 514
 515     my $lvm_activate_mode = 'ey';
 516
 517     my $cmd = ['/sbin/lvchange', "-a$lvm_activate_mode", $path];
 518     run_command($cmd, errmsg => "can't activate LV '$path'");
 519     $cmd = ['/sbin/lvchange', '--refresh', $path];
 520     run_command($cmd, errmsg => "can't refresh LV '$path' for activation");
 521 }
 522
 523 sub deactivate_volume {
 524     my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
 525
 526     my $path = $class->path($scfg, $volname, $snapname);
 527     return if ! -b $path;
 528
 529     my $cmd = ['/sbin/lvchange', '-aln', $path];
 530     run_command($cmd, errmsg => "can't deactivate LV '$path'");
 531 }
 532
 533 sub volume_resize {
 534     my ($class, $scfg, $storeid, $volname, $size, $running) = @_;
 535
 536     $size = ($size/1024/1024) . "M";
 537
 538     my $path = $class->path($scfg, $volname);
 539     my $cmd = ['/sbin/lvextend', '-L', $size, $path];
 540
 541     $class->cluster_lock_storage($storeid, $scfg->{shared}, undef, sub {
 542         run_command($cmd, errmsg => "error resizing volume '$path'");
 543     });
 544
 545     return 1;
 546 }
 547
 548 sub volume_size_info {
 549     my ($class, $scfg, $storeid, $volname, $timeout) = @_;
 550     my $path = $class->filesystem_path($scfg, $volname);
 551
 552     my $cmd = ['/sbin/lvs', '--separator', ':', '--noheadings', '--units', 'b',
 553                '--unbuffered', '--nosuffix', '--options', 'lv_size', $path];
 554
 555     my $size;
 556     run_command($cmd, timeout => $timeout, errmsg => "can't get size of '$path'",
 557         outfunc => sub {
 558             $size = int(shift);
 559     });
 560     return wantarray ? ($size, 'raw', 0, undef) : $size;
 561 }
 562
 563 sub volume_snapshot {
 564     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 565
 566     die "lvm snapshot is not implemented";
 567 }
 568
 569 sub volume_snapshot_rollback {
 570     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 571
 572     die "lvm snapshot rollback is not implemented";
 573 }
 574
 575 sub volume_snapshot_delete {
 576     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 577
 578     die "lvm snapshot delete is not implemented";
 579 }
 580
 581 sub volume_has_feature {
 582     my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;
 583
 584     my $features = {
 585         copy => { base => 1, current => 1},
 586     };
 587
 588     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 589         $class->parse_volname($volname);
 590
 591     my $key = undef;
 592     if($snapname){
 593         $key = 'snap';
 594     }else{
 595         $key =  $isBase ? 'base' : 'current';
 596     }
 597     return 1 if $features->{$feature}->{$key};
 598
 599     return undef;
 600 }
 601
 602 sub volume_export_formats {
 603     my ($class, $scfg, $storeid, $volname, $snapshot, $base_snapshot, $with_snapshots) = @_;
 604     return () if defined($snapshot); # lvm-thin only
 605     return volume_import_formats($class, $scfg, $storeid, $volname, $base_snapshot, $with_snapshots);
 606 }
 607
 608 sub volume_export {
 609     my ($class, $scfg, $storeid, $fh, $volname, $format, $snapshot, $base_snapshot, $with_snapshots) = @_;
 610     die "volume export format $format not available for $class\n"
 611         if $format ne 'raw+size';
 612     die "cannot export volumes together with their snapshots in $class\n"
 613         if $with_snapshots;
 614     die "cannot export a snapshot in $class\n" if defined($snapshot);
 615     die "cannot export an incremental stream in $class\n" if defined($base_snapshot);
 616     my $file = $class->path($scfg, $volname, $storeid);
 617     my $size;
 618     # should be faster than querying LVM, also checks for the device file's availability
 619     run_command(['/sbin/blockdev', '--getsize64', $file], outfunc => sub {
 620         my ($line) = @_;
 621         die "unexpected output from /sbin/blockdev: $line\n" if $line !~ /^(\d+)$/;
 622         $size = int($1);
 623     });
 624     PVE::Storage::Plugin::write_common_header($fh, $size);
 625     run_command(['dd', "if=$file", "bs=64k"], output => '>&'.fileno($fh));
 626 }
 627
 628 sub volume_import_formats {
 629     my ($class, $scfg, $storeid, $volname, $base_snapshot, $with_snapshots) = @_;
 630     return () if $with_snapshots; # not supported
 631     return () if defined($base_snapshot); # not supported
 632     return ('raw+size');
 633 }
 634
 635 sub volume_import {
 636     my ($class, $scfg, $storeid, $fh, $volname, $format, $base_snapshot, $with_snapshots, $allow_rename) = @_;
 637     die "volume import format $format not available for $class\n"
 638         if $format ne 'raw+size';
 639     die "cannot import volumes together with their snapshots in $class\n"
 640         if $with_snapshots;
 641     die "cannot import an incremental stream in $class\n" if defined($base_snapshot);
 642
 643     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $file_format) =
 644         $class->parse_volname($volname);
 645     die "cannot import format $format into a file of format $file_format\n"
 646         if $file_format ne 'raw';
 647
 648     my $vg = $scfg->{vgname};
 649     my $lvs = lvm_list_volumes($vg);
 650     if ($lvs->{$vg}->{$volname}) {
 651         die "volume $vg/$volname already exists\n" if !$allow_rename;
 652         warn "volume $vg/$volname already exists - importing with a different name\n";
 653         $name = undef;
 654     }
 655
 656     my ($size) = PVE::Storage::Plugin::read_common_header($fh);
 657     $size = int($size/1024);
 658
 659     eval {
 660         my $allocname = $class->alloc_image($storeid, $scfg, $vmid, 'raw', $name, $size);
 661         my $oldname = $volname;
 662         $volname = $allocname;
 663         if (defined($name) && $allocname ne $oldname) {
 664             die "internal error: unexpected allocated name: '$allocname' != '$oldname'\n";
 665         }
 666         my $file = $class->path($scfg, $volname, $storeid)
 667             or die "internal error: failed to get path to newly allocated volume $volname\n";
 668
 669         $class->volume_import_write($fh, $file);
 670     };
 671     if (my $err = $@) {
 672         eval { $class->free_image($storeid, $scfg, $volname, 0) };
 673         warn $@ if $@;
 674         die $err;
 675     }
 676
 677     return "$storeid:$volname";
 678 }
 679
 680 sub volume_import_write {
 681     my ($class, $input_fh, $output_file) = @_;
 682     run_command(['dd', "of=$output_file", 'bs=64k'],
 683         input => '<&'.fileno($input_fh));
 684 }
 685
 686 1;