PVE/Storage/LvmThinPlugin.pm

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