PVE/Storage/RBDPlugin.pm

   1 package PVE::Storage::RBDPlugin;
   2
   3 use strict;
   4 use warnings;
   5 use IO::File;
   6 use PVE::Tools qw(run_command trim);
   7 use PVE::Storage::Plugin;
   8 use PVE::JSONSchema qw(get_standard_option);
   9
  10 use base qw(PVE::Storage::Plugin);
  11
  12 sub rbd_unittobytes {
  13   {
  14        "M"  => 1024*1024,
  15        "G"  => 1024*1024*1024,
  16        "T"  => 1024*1024*1024*1024,
  17   }
  18 }
  19
  20 my $rbd_cmd = sub {
  21     my ($scfg, $storeid, $op, @options) = @_;
  22
  23     my $monhost = $scfg->{monhost};
  24     $monhost =~ s/;/,/g;
  25
  26     my $cmd = ['/usr/bin/rbd', '-p', $scfg->{pool}, '-m', $monhost, '-n',
  27                "client.$scfg->{username}",
  28                '--keyring', "/etc/pve/priv/ceph/${storeid}.keyring",
  29                '--auth_supported', $scfg->{authsupported}, $op];
  30
  31     push @$cmd, @options if scalar(@options);
  32
  33     return $cmd;
  34 };
  35
  36 my $rados_cmd = sub {
  37     my ($scfg, $storeid, $op, @options) = @_;
  38
  39     my $monhost = $scfg->{monhost};
  40     $monhost =~ s/;/,/g;
  41
  42     my $cmd = ['/usr/bin/rados', '-p', $scfg->{pool}, '-m', $monhost, '-n',
  43                "client.$scfg->{username}",
  44                '--keyring', "/etc/pve/priv/ceph/${storeid}.keyring",
  45                '--auth_supported', $scfg->{authsupported}, $op];
  46
  47     push @$cmd, @options if scalar(@options);
  48
  49     return $cmd;
  50 };
  51
  52 sub rbd_ls {
  53     my ($scfg, $storeid) = @_;
  54
  55     my $cmd = &$rbd_cmd($scfg, $storeid, 'ls', '-l');
  56
  57     my $list = {};
  58
  59     my $parser = sub {
  60         my $line = shift;
  61
  62         if ($line =~  m/^((vm|base)-(\d+)-disk-\d+)\s+(\d+)(M|G|T)\s((\S+)\/((vm|base)-\d+-\S+@\S+))?/) {
  63             my ($image, $owner, $size, $unit, $parent) = ($1, $3, $4, $5, $8);
  64
  65             $list->{$scfg->{pool}}->{$image} = {
  66                 name => $image,
  67                 size => $size*rbd_unittobytes()->{$unit},
  68                 parent => $parent,
  69                 vmid => $owner
  70             };
  71         }
  72     };
  73
  74     eval {
  75         run_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
  76     };
  77     my $err = $@;
  78
  79     die $err if $err && $err !~ m/doesn't contain rbd images/ ;
  80
  81     return $list;
  82 }
  83
  84 sub rbd_volume_info {
  85     my ($scfg, $storeid, $volname, $snap) = @_;
  86
  87     my $cmd = undef;
  88
  89     if($snap){
  90        $cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname, '--snap', $snap);
  91     }else{
  92        $cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname);
  93     }
  94
  95     my $size = undef;
  96     my $parent = undef;
  97     my $format = undef;
  98     my $protected = undef;
  99
 100     my $parser = sub {
 101         my $line = shift;
 102
 103         if ($line =~ m/size (\d+) (M|G|T)B in (\d+) objects/) {
 104             $size = $1 * rbd_unittobytes()->{$2} if ($1);
 105         } elsif ($line =~ m/parent:\s(\S+)\/(\S+)/) {
 106             $parent = $2;
 107         } elsif ($line =~ m/format:\s(\d+)/) {
 108             $format = $1;
 109         } elsif ($line =~ m/protected:\s(\S+)/) {
 110             $protected = 1 if $1 eq "True";
 111         }
 112
 113     };
 114
 115     run_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
 116
 117     return ($size, $parent, $format, $protected);
 118 }
 119
 120 sub addslashes {
 121     my $text = shift;
 122     $text =~ s/;/\\;/g;
 123     $text =~ s/:/\\:/g;
 124     return $text;
 125 }
 126
 127 # Configuration
 128
 129 PVE::JSONSchema::register_format('pve-storage-monhost', \&parse_monhost);
 130 sub parse_monhost {
 131     my ($name, $noerr) = @_;
 132
 133     if ($name !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
 134         return undef if $noerr;
 135         die "lvm name '$name' contains illegal characters\n";
 136     }
 137
 138     return $name;
 139 }
 140
 141 sub type {
 142     return 'rbd';
 143 }
 144
 145 sub plugindata {
 146     return {
 147         content => [ {images => 1}, { images => 1 }],
 148     };
 149 }
 150
 151 sub properties {
 152     return {
 153         monhost => {
 154             description => "Monitors daemon ips.",
 155             type => 'string',
 156         },
 157         pool => {
 158             description => "Pool.",
 159             type => 'string',
 160         },
 161         username => {
 162             description => "RBD Id.",
 163             type => 'string',
 164         },
 165         authsupported => {
 166             description => "Authsupported.",
 167             type => 'string',
 168         },
 169     };
 170 }
 171
 172 sub options {
 173     return {
 174         nodes => { optional => 1 },
 175         disable => { optional => 1 },
 176         monhost => { fixed => 1 },
 177         pool => { fixed => 1 },
 178         username => { fixed => 1 },
 179         authsupported => { fixed => 1 },
 180         content => { optional => 1 },
 181     };
 182 }
 183
 184 # Storage implementation
 185
 186 sub parse_volname {
 187     my ($class, $volname) = @_;
 188
 189     if ($volname =~ m/^((base-(\d+)-\S+)\/)?((base)?(vm)?-(\d+)-\S+)$/) {
 190         return ('images', $4, $7, $2, $3, $5);
 191     }
 192
 193     die "unable to parse rbd volume name '$volname'\n";
 194 }
 195
 196 sub path {
 197     my ($class, $scfg, $volname, $storeid) = @_;
 198
 199     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
 200
 201     my $monhost = addslashes($scfg->{monhost});
 202     my $pool = $scfg->{pool};
 203     my $username = $scfg->{username};
 204     my $authsupported = addslashes($scfg->{authsupported});
 205
 206     my $path = "rbd:$pool/$name:id=$username:auth_supported=$authsupported:keyring=/etc/pve/priv/ceph/$storeid.keyring:mon_host=$monhost";
 207
 208     return ($path, $vmid, $vtype);
 209 }
 210
 211 sub create_base {
 212     my ($class, $storeid, $scfg, $volname) = @_;
 213
 214     my $snap = '__base__';
 215
 216     my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
 217         $class->parse_volname($volname);
 218
 219     die "create_base not possible with base image\n" if $isBase;
 220
 221     my ($size, $parent, $format, undef) = rbd_volume_info($scfg, $storeid, $name);
 222     die "rbd volume info on '$name' failed\n" if !($size);
 223
 224     die "rbd image must be at format V2" if $format ne "2";
 225
 226     die "volname '$volname' contains wrong information about parent $parent $basename\n"
 227         if $basename && (!$parent || $parent ne $basename."@".$snap);
 228
 229     my $newname = $name;
 230     $newname =~ s/^vm-/base-/;
 231
 232     my $newvolname = $basename ? "$basename/$newname" : "$newname";
 233
 234     my $cmd = &$rbd_cmd($scfg, $storeid, 'rename', $name, $newname);
 235     run_command($cmd, errmsg => "rbd rename $name' error", errfunc => sub {});
 236
 237     my $running  = undef; #fixme : is create_base always offline ?
 238
 239     $class->volume_snapshot($scfg, $storeid, $newname, $snap, $running);
 240
 241     my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $newname, $snap);
 242
 243     if (!$protected){
 244         my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'protect', $newname, '--snap', $snap);
 245         run_command($cmd, errmsg => "rbd protect $newname snap $snap' error", errfunc => sub {});
 246     }
 247
 248     return $newvolname;
 249
 250 }
 251
 252 sub clone_image {
 253     my ($class, $scfg, $storeid, $volname, $vmid) = @_;
 254
 255     die "not implemented";
 256 }
 257
 258 my $find_free_diskname = sub {
 259     my ($storeid, $scfg, $vmid) = @_;
 260
 261     my $rbd = rbd_ls($scfg, $storeid);
 262     my $disk_ids = {};
 263     my $dat = $rbd->{$scfg->{pool}};
 264
 265     foreach my $image (keys %$dat) {
 266         my $volname = $dat->{$image}->{name};
 267         if ($volname =~ m/(vm|base)-$vmid-disk-(\d+)/){
 268             $disk_ids->{$2} = 1;
 269         }
 270     }
 271     #fix: can we search in $rbd hash key with a regex to find (vm|base) ?
 272     for (my $i = 1; $i < 100; $i++) {
 273         if (!$disk_ids->{$i}) {
 274             return "vm-$vmid-disk-$i";
 275         }
 276     }
 277
 278     die "unable to allocate an image name for VM $vmid in storage '$storeid'\n";
 279 };
 280
 281 sub alloc_image {
 282     my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
 283
 284
 285     die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
 286         if  $name && $name !~ m/^vm-$vmid-/;
 287
 288     $name = &$find_free_diskname($storeid, $scfg, $vmid);
 289
 290     my $cmd = &$rbd_cmd($scfg, $storeid, 'create', '--format' , 2, '--size', ($size/1024), $name);
 291     run_command($cmd, errmsg => "rbd create $name' error", errfunc => sub {});
 292
 293     return $name;
 294 }
 295
 296 sub free_image {
 297     my ($class, $storeid, $scfg, $volname, $isBase) = @_;
 298
 299     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'purge',  $volname);
 300     run_command($cmd, errmsg => "rbd snap purge $volname' error", outfunc => sub {}, errfunc => sub {});
 301
 302     $cmd = &$rbd_cmd($scfg, $storeid, 'rm', $volname);
 303     run_command($cmd, errmsg => "rbd rm $volname' error", outfunc => sub {}, errfunc => sub {});
 304
 305     return undef;
 306 }
 307
 308 sub list_images {
 309     my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
 310
 311     $cache->{rbd} = rbd_ls($scfg, $storeid) if !$cache->{rbd};
 312
 313     my $res = [];
 314
 315     if (my $dat = $cache->{rbd}->{$scfg->{pool}}) {
 316         foreach my $image (keys %$dat) {
 317
 318             my $volname = $dat->{$image}->{name};
 319
 320             my $volid = "$storeid:$volname";
 321
 322             my $owner = $dat->{$volname}->{vmid};
 323             if ($vollist) {
 324                 my $found = grep { $_ eq $volid } @$vollist;
 325                 next if !$found;
 326             } else {
 327                 next if defined ($vmid) && ($owner ne $vmid);
 328             }
 329
 330             my $info = $dat->{$volname};
 331             $info->{volid} = $volid;
 332             $info->{format} = 'raw';
 333
 334             push @$res, $info;
 335         }
 336     }
 337
 338     return $res;
 339 }
 340
 341 sub status {
 342     my ($class, $storeid, $scfg, $cache) = @_;
 343
 344     my $cmd = &$rados_cmd($scfg, $storeid, 'df');
 345
 346     my $stats = {};
 347
 348     my $parser = sub {
 349         my $line = shift;
 350         if ($line =~ m/^\s+total\s(\S+)\s+(\d+)/) {
 351             $stats->{$1} = $2;
 352         }
 353     };
 354
 355     eval {
 356         run_command($cmd, errmsg => "rados error", errfunc => sub {}, outfunc => $parser);
 357     };
 358
 359     my $total = $stats->{space} ? $stats->{space}*1024 : 0;
 360     my $free = $stats->{avail} ? $stats->{avail}*1024 : 0;
 361     my $used = $stats->{used} ? $stats->{used}*1024: 0;
 362     my $active = 1;
 363
 364     return ($total, $free, $used, $active);
 365 }
 366
 367 sub activate_storage {
 368     my ($class, $storeid, $scfg, $cache) = @_;
 369     return 1;
 370 }
 371
 372 sub deactivate_storage {
 373     my ($class, $storeid, $scfg, $cache) = @_;
 374     return 1;
 375 }
 376
 377 sub activate_volume {
 378     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 379     return 1;
 380 }
 381
 382 sub deactivate_volume {
 383     my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
 384     return 1;
 385 }
 386
 387 sub volume_size_info {
 388     my ($class, $scfg, $storeid, $volname, $timeout) = @_;
 389
 390     my ($size, undef) = rbd_volume_info($scfg, $storeid, $volname);
 391     return $size;
 392 }
 393
 394 sub volume_resize {
 395     my ($class, $scfg, $storeid, $volname, $size, $running) = @_;
 396
 397     return 1 if $running;
 398
 399     my $cmd = &$rbd_cmd($scfg, $storeid, 'resize', '--size', ($size/1024/1024), $volname);
 400     run_command($cmd, errmsg => "rbd resize $volname' error", errfunc => sub {});
 401     return undef;
 402 }
 403
 404 sub volume_snapshot {
 405     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 406
 407     return 1 if $running;
 408
 409     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'create', '--snap', $snap, $volname);
 410     run_command($cmd, errmsg => "rbd snapshot $volname' error", errfunc => sub {});
 411     return undef;
 412 }
 413
 414 sub volume_snapshot_rollback {
 415     my ($class, $scfg, $storeid, $volname, $snap) = @_;
 416
 417     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rollback', '--snap', $snap, $volname);
 418     run_command($cmd, errmsg => "rbd snapshot $volname to $snap' error", errfunc => sub {});
 419 }
 420
 421 sub volume_snapshot_delete {
 422     my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
 423
 424     return 1 if $running;
 425
 426     my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rm', '--snap', $snap, $volname);
 427     run_command($cmd, errmsg => "rbd snapshot $volname' error", errfunc => sub {});
 428     return undef;
 429 }
 430
 431 sub volume_has_feature {
 432     my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;
 433
 434    my $features = {
 435         snapshot => { current => 1, snap => 1},
 436         clone => { snap => 1},
 437     };
 438
 439     my $snap = $snapname ? 'snap' : 'current';
 440     return 1 if $features->{$feature}->{$snap};
 441
 442     return undef;
 443 }
 444
 445 1;