PVE/Storage/LvmThinPlugin.pm

   1 package PVE::Storage::LvmThinPlugin;
   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::Storage::LVMPlugin;
  11 use PVE::JSONSchema qw(get_standard_option);
  12
  13 # see: man lvmthin
  14 # lvcreate -n ThinDataLV -L LargeSize VG
  15 # lvconvert --type thin-pool VG/ThinDataLV
  16 # lvcreate -n pvepool -L 20G pve
  17 # lvconvert --type thin-pool pve/pvepool
  18
  19 # NOTE: volumes which were created as linked clones of another base volume
  20 # are currently not tracking this relationship in their volume IDs. this is
  21 # generally not a problem, as LVM thin allows deletion of such base volumes
  22 # without affecting the linked clones. this leads to increased disk usage
  23 # when migrating LVM-thin volumes, which is normally prevented for linked clones.
  24
  25 use base qw(PVE::Storage::LVMPlugin);
  26
  27 sub type {
  28     return 'lvmthin';
  29 }
  30
  31 sub plugindata {
  32     return {
  33         content => [ {images => 1, rootdir => 1}, { images => 1, rootdir => 1}],
  34     };
  35 }
  36
  37 sub properties {
  38     return {
  39         thinpool => {
  40             description => "LVM thin pool LV name.",
  41             type => 'string', format => 'pve-storage-vgname',
  42         },
  43     };
  44 }
  45
  46 sub options {
  47     return {
  48         thinpool => { fixed => 1 },
  49         vgname => { fixed => 1 },
  50         nodes => { optional => 1 },
  51         disable => { optional => 1 },
  52         content => { optional => 1 },
  53         bwlimit => { optional => 1 },
  54     };
  55 }
  56
  57 # NOTE: the fourth and fifth element of the returned array are always
  58 # undef, even if the volume is a linked clone of another volume. see note
  59 # at beginning of file.
  60 sub parse_volname {
  61     my ($class, $volname) = @_;
  62
  63     PVE::Storage::Plugin::parse_lvm_name($volname);
  64
  65     if ($volname =~ m/^((vm|base)-(\d+)-\S+)$/) {
  66         return ('images', $1, $3, undef, undef, $2 eq 'base', 'raw');
  67     }
  68
  69     die "unable to parse lvm volume name '$volname'\n";
  70 }
  71
  72 sub filesystem_path {
  73     my ($class, $scfg, $volname, $snapname) = @_;
  74
  75     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
  76
  77     my $vg = $scfg->{vgname};
  78
  79     my $path = defined($snapname) ? "/dev/$vg/snap_${name}_$snapname": "/dev/$vg/$name";
  80
  81     return wantarray ? ($path, $vmid, $vtype) : $path;
  82 }
  83
  84 sub alloc_image {
  85     my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
  86
  87     die "unsupported format '$fmt'" if $fmt ne 'raw';
  88
  89     die "illegal name '$name' - should be 'vm-$vmid-*'\n"
  90         if  $name && $name !~ m/^vm-$vmid-/;
  91
  92     my $vgs = PVE::Storage::LVMPlugin::lvm_vgs();
  93
  94     my $vg = $scfg->{vgname};
  95
  96     die "no such volume group '$vg'\n" if !defined ($vgs->{$vg});
  97
  98     $name = $class->find_free_diskname($storeid, $scfg, $vmid)
  99         if !$name;
 100
 101     my $cmd = ['/sbin/lvcreate', '-aly', '-V', "${size}k", '--name', $name,
 102                '--thinpool', "$vg/$scfg->{thinpool}" ];
 103
 104     run_command($cmd, errmsg => "lvcreate '$vg/$name' error");
 105
 106     return $name;
 107 }
 108
 109 sub free_image {
 110     my ($class, $storeid, $scfg, $volname, $isBase) = @_;
 111
 112     my $vg = $scfg->{vgname};
 113
 114     my $lvs = PVE::Storage::LVMPlugin::lvm_list_volumes($vg);
 115
 116     if (my $dat = $lvs->{$scfg->{vgname}}) {
 117
 118         # remove all volume snapshots first
 119         foreach my $lv (keys %$dat) {
 120             next if $lv !~ m/^snap_${volname}_${PVE::JSONSchema::CONFIGID_RE}$/;
 121             my $cmd = ['/sbin/lvremove', '-f', "$vg/$lv"];
 122             run_command($cmd, errmsg => "lvremove snapshot '$vg/$lv' error");
 123         }
 124
 125         # finally remove original (if exists)
 126         if ($dat->{$volname}) {
 127             my $cmd = ['/sbin/lvremove', '-f', "$vg/$volname"];
 128             run_command($cmd, errmsg => "lvremove '$vg/$volname' error");
 129         }
 130     }
 131
 132     return undef;
 133 }
 134
 135 sub list_images {
 136     my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
 137
 138     my $vgname = $scfg->{vgname};
 139
 140     $cache->{lvs} = PVE::Storage::LVMPlugin::lvm_list_volumes() if !$cache->{lvs};
 141
 142     my $res = [];
 143
 144     if (my $dat = $cache->{lvs}->{$vgname}) {
 145
 146         foreach my $volname (keys %$dat) {
 147
 148             next if $volname !~ m/^(vm|base)-(\d+)-/;
 149             my $owner = $2;
 150
 151             my $info = $dat->{$volname};
 152
 153             next if $info->{lv_type} ne 'V';
 154
 155             next if $info->{pool_lv} ne $scfg->{thinpool};
 156
 157             my $volid = "$storeid:$volname";
 158
 159             if ($vollist) {
 160                 my $found = grep { $_ eq $volid } @$vollist;
 161                 next if !$found;
 162             } else {
 163                 next if defined($vmid) && ($owner ne $vmid);
 164             }
 165
 166             push @$res, {
 167                 volid => $volid, format => 'raw', size => $info->{lv_size}, vmid => $owner,
 168                 ctime => $info->{ctime},
 169             };
 170         }
 171     }
 172
 173     return $res;
 174 }
 175
 176 sub list_thinpools {
 177     my ($vg) = @_;
 178
 179     my $lvs = PVE::Storage::LVMPlugin::lvm_list_volumes($vg);
 180     my $thinpools = [];
 181
 182     foreach my $vg (keys %$lvs) {
 183         foreach my $lvname (keys %{$lvs->{$vg}}) {
 184             next if $lvs->{$vg}->{$lvname}->{lv_type} ne 't';
 185             my $lv = $lvs->{$vg}->{$lvname};
 186             $lv->{lv} = $lvname;
 187             $lv->{vg} = $vg;
 188             push @$thinpools, $lv;
 189         }
 190     }
 191
 192     return $thinpools;
 193 }
 194
 195 sub status {
 196     my ($class, $storeid, $scfg, $cache) = @_;
 197
 198     my $lvs = $cache->{lvs} ||= PVE::Storage::LVMPlugin::lvm_list_volumes();
 199
 200     return if !$lvs->{$scfg->{vgname}};
 201
 202     my $info = $lvs->{$scfg->{vgname}}->{$scfg->{thinpool}};
 203
 204     return if !$info || $info->{lv_type} ne 't' || !$info->{lv_size};
 205
 206     return (
 207         $info->{lv_size},
 208         $info->{lv_size} - $info->{used},
 209         $info->{used},
 210         $info->{lv_state} eq 'a' ? 1 : 0,
 211     );
 212 }
 213
 214 my $activate_lv = sub {
 215     my ($vg, $lv, $cache) = @_;
 216
 217     my $lvs = $cache->{lvs} ||= PVE::Storage::LVMPlugin::lvm_list_volumes();
 218
 219     die "no such logical volume $vg/$lv\n" if !$lvs->{$vg} || !$lvs->{$vg}->{$lv};
 220
 221     return if $lvs->{$vg}->{$lv}->{lv_state} eq 'a';
 222
 223     run_command(['lvchange', '-ay', '-K', "$vg/$lv"], errmsg => "activating LV '$vg/$lv' failed");
 224
 225     $lvs->{$vg}->{$lv}->{lv_state} = 'a'; # update cache
 226
 227     return;
 228 };
 229
 230 sub activate_storage {
 231     my ($class, $storeid, $scfg, $cache) = @_;
 232
 233     $class->SUPER::activate_storage($storeid, $scfg, $cache);
 234
 235     $activate_lv->($scfg->{vgname}, $scfg->{thinpool}, $cache);
 236 }
 237
 238 sub activate_volume {
 239     my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
 240
 241     my $vg = $scfg->{vgname};
 242     my $lv = $snapname ? "snap_${volname}_$snapname" : $volname;
 243
 244     $activate_lv->($vg, $lv, $cache);
 245 }
 246
 247 sub deactivate_volume {
 248     my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
 249
 250     return if !$snapname && $volname !~ /^base-/; # other volumes are kept active
 251
 252     my $vg = $scfg->{vgname};
 253     my $lv = $snapname ? "snap_${volname}_$snapname" : $volname;
 254
 255     run_command(['lvchange', '-an', "$vg/$lv"], errmsg => "deactivate_volume '$vg/$lv' error");
 256
 257     $cache->{lvs}->{$vg}->{$lv}->{lv_state} = '-' # update cache
 258         if $cache->{lvs} && $cache->{lvs}->{$vg} && $cache->{lvs}->{$vg}->{$lv};
 259
 260     return;
 261 }
 262
 263 sub clone_image {
 264     my ($class, $scfg, $storeid, $volname, $vmid, $snap) = @_;
 265
 266     my $vg = $scfg->{vgname};
 267
 268     my $lv;
 269
 270     if ($snap) {
 271         $lv = "$vg/snap_${volname}_$snap";
 272     } else {
 273         my ($vtype, undef, undef, undef, undef, $isBase, $format) =
 274             $class->parse_volname($volname);
 275
 276         die "clone_image only works on base images\n" if !$isBase;
 277
 278         $lv = "$vg/$volname";
 279     }
 280
 281     my $name = $class->find_free_diskname($storeid, $scfg, $vmid);
 282
 283     my $cmd = ['/sbin/lvcreate', '-n', $name, '-prw', '-kn', '-s', $lv];
 284     run_command($cmd, errmsg => "clone image '$lv' error");
 285
 286     return $name;
 287 }
 288
 289 sub create_base {
 290     my ($class, $storeid, $scfg, $volname) = @_;
 291
 292     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 293         $class->parse_volname($volname);
 294
 295     die "create_base not possible with base image\n" if $isBase;
 296
 297     my $vg = $scfg->{vgname};
 298     my $lvs = PVE::Storage::LVMPlugin::lvm_list_volumes($vg);
 299
 300     if (my $dat = $lvs->{$vg}) {
 301         # to avoid confusion, reject if we find volume snapshots
 302         foreach my $lv (keys %$dat) {
 303             die "unable to create base volume - found snaphost '$lv'\n"
 304                 if $lv =~ m/^snap_${volname}_(\w+)$/;
 305         }
 306     }
 307
 308     my $newname = $name;
 309     $newname =~ s/^vm-/base-/;
 310
 311     my $cmd = ['/sbin/lvrename', $vg, $volname, $newname];
 312     run_command($cmd, errmsg => "lvrename '$vg/$volname' => '$vg/$newname' error");
 313
 314     # set inactive, read-only and activationskip flags
 315     $cmd = ['/sbin/lvchange', '-an', '-pr', '-ky', "$vg/$newname"];
 316     eval { run_command($cmd); };
 317     warn $@ if $@;
 318
 319     my $newvolname = $newname;
 320
 321     return $newvolname;
 322 }
 323
 324 # sub volume_resize {} reuse code from parent class
 325
 326 sub volume_snapshot {
 327     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 328
 329     my $vg = $scfg->{vgname};
 330     my $snapvol = "snap_${volname}_$snap";
 331
 332     my $cmd = ['/sbin/lvcreate', '-n', $snapvol, '-pr', '-s', "$vg/$volname"];
 333     run_command($cmd, errmsg => "lvcreate snapshot '$vg/$snapvol' error");
 334
 335 }
 336
 337 sub volume_snapshot_rollback {
 338     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 339
 340     my $vg = $scfg->{vgname};
 341     my $snapvol = "snap_${volname}_$snap";
 342
 343     my $cmd = ['/sbin/lvremove', '-f', "$vg/$volname"];
 344     run_command($cmd, errmsg => "lvremove '$vg/$volname' error");
 345
 346     $cmd = ['/sbin/lvcreate', '-kn', '-n', $volname, '-s', "$vg/$snapvol"];
 347     run_command($cmd, errmsg => "lvm rollback '$vg/$snapvol' error");
 348 }
 349
 350 sub volume_snapshot_delete {
 351     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 352
 353     my $vg = $scfg->{vgname};
 354     my $snapvol = "snap_${volname}_$snap";
 355
 356     my $cmd = ['/sbin/lvremove', '-f', "$vg/$snapvol"];
 357     run_command($cmd, errmsg => "lvremove snapshot '$vg/$snapvol' error");
 358 }
 359
 360 sub volume_has_feature {
 361     my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;
 362
 363     my $features = {
 364         snapshot => { current => 1 },
 365         clone => { base => 1, snap => 1},
 366         template => { current => 1},
 367         copy => { base => 1, current => 1, snap => 1},
 368         sparseinit => { base => 1, current => 1},
 369         rename => {current => 1},
 370     };
 371
 372     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 373         $class->parse_volname($volname);
 374
 375     my $key = undef;
 376     if($snapname){
 377         $key = 'snap';
 378     }else{
 379         $key =  $isBase ? 'base' : 'current';
 380     }
 381     return 1 if $features->{$feature}->{$key};
 382
 383     return undef;
 384 }
 385
 386 # used in LVMPlugin->volume_import
 387 sub volume_import_write {
 388     my ($class, $input_fh, $output_file) = @_;
 389     run_command(['dd', "of=$output_file", 'conv=sparse', 'bs=64k'],
 390         input => '<&'.fileno($input_fh));
 391 }
 392
 393 1;