[pve-storage.git] / PVE / Storage / RBDPlugin.pm

package PVE::Storage::RBDPlugin;

use strict;
use warnings;
use IO::File;
use PVE::Tools qw(run_command trim);
use PVE::Storage::Plugin;
use PVE::JSONSchema qw(get_standard_option);

use base qw(PVE::Storage::Plugin);

sub rbd_unittobytes {
  {
       "M"  => 1024*1024,
       "G"  => 1024*1024*1024,
       "T"  => 1024*1024*1024*1024,
  }
}

my $add_pool_to_disk = sub {
    my ($scfg, $disk) = @_;

    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';

    return "$pool/$disk";
};

my $rbd_cmd = sub {
    my ($scfg, $storeid, $op, @options) = @_;

    my $monhost = $scfg->{monhost};
    $monhost =~ s/;/,/g;

    my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';
    my $username =  $scfg->{username} ? $scfg->{username} : 'admin';

    my $cmd = ['/usr/bin/rbd', '-p', $pool, '-m', $monhost]; 

    if(-e $keyring){
	push @$cmd, '-n', "client.$username";
	push @$cmd, '--keyring', $keyring;
	push @$cmd, '--auth_supported', 'cephx';
    }else{
	push @$cmd, '--auth_supported', 'none';
    }

    push @$cmd, $op;

    push @$cmd, @options if scalar(@options);

    return $cmd;
};

my $rados_cmd = sub {
    my ($scfg, $storeid, $op, @options) = @_;

    my $monhost = $scfg->{monhost};
    $monhost =~ s/;/,/g;

    my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';
    my $username =  $scfg->{username} ? $scfg->{username} : 'admin';

    my $cmd = ['/usr/bin/rados', '-p', $pool, '-m', $monhost];

    if(-e $keyring){
	push @$cmd, '-n', "client.$username";
	push @$cmd, '--keyring', $keyring;
	push @$cmd, '--auth_supported', 'cephx';
    }else{
	push @$cmd, '--auth_supported', 'none';
    }

    push @$cmd, $op;

    push @$cmd, @options if scalar(@options);

    return $cmd;
};

sub run_rbd_command {
    my ($cmd, %args) = @_;

    my $lasterr;
    my $errmsg = $args{errmsg} . ": " || "";
    if (!exists($args{errfunc})) {
	# ' error: 2014-02-06 11:51:59.839135 7f09f94d0760 -1 librbd: snap_unprotect: can't unprotect;
	# at least 1 child(ren) in pool cephstor1
	$args{errfunc} = sub {
	    my $line = shift;
	    if ($line =~ m/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ [0-9a-f]+ [\-\d]+ librbd: (.*)$/) {
		$lasterr = "$1\n";
	    } else {
		$lasterr = $line;
	    }
	    print STDERR $lasterr;
	    *STDERR->flush();
	};
    }
    
    eval { run_command($cmd, %args); };
    if (my $err = $@) {
	die $errmsg . $lasterr if length($lasterr);
	die $err;
    }

    return undef;
}

sub rbd_ls {
    my ($scfg, $storeid) = @_;

    my $cmd = &$rbd_cmd($scfg, $storeid, 'ls', '-l');
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';

    my $list = {};

    my $parser = sub {
	my $line = shift;

	if ($line =~  m/^((vm|base)-(\d+)-disk-\d+)\s+(\d+)(M|G|T)\s((\S+)\/((vm|base)-\d+-\S+@\S+))?/) {
	    my ($image, $owner, $size, $unit, $parent) = ($1, $3, $4, $5, $8);

	    $list->{$pool}->{$image} = {
		name => $image,
		size => $size*rbd_unittobytes()->{$unit},
		parent => $parent,
		vmid => $owner
	    };
	}
    };

    eval {
	run_rbd_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
    };
    my $err = $@;

    die $err if $err && $err !~ m/doesn't contain rbd images/ ;
  
    return $list;
}

sub rbd_volume_info {
    my ($scfg, $storeid, $volname, $snap) = @_;

    my $cmd = undef;

    if($snap){
       $cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname, '--snap', $snap);
    }else{
       $cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname);
    }

    my $size = undef;
    my $parent = undef;
    my $format = undef;
    my $protected = undef;

    my $parser = sub {
	my $line = shift;

	if ($line =~ m/size (\d+) (M|G|T)B in (\d+) objects/) {
	    $size = $1 * rbd_unittobytes()->{$2} if ($1);
	} elsif ($line =~ m/parent:\s(\S+)\/(\S+)/) {
	    $parent = $2;
	} elsif ($line =~ m/format:\s(\d+)/) {
	    $format = $1;
	} elsif ($line =~ m/protected:\s(\S+)/) {
	    $protected = 1 if $1 eq "True";
	}

    };

    run_rbd_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);

    return ($size, $parent, $format, $protected);
}

sub addslashes {
    my $text = shift;
    $text =~ s/;/\\;/g;
    $text =~ s/:/\\:/g;
    return $text;
}

# Configuration

PVE::JSONSchema::register_format('pve-storage-monhost', \&parse_monhost);
sub parse_monhost {
    my ($name, $noerr) = @_;

    if ($name !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
	return undef if $noerr;
	die "lvm name '$name' contains illegal characters\n";
    }

    return $name;
}

sub type {
    return 'rbd';
}

sub plugindata {
    return {
	content => [ {images => 1}, { images => 1 }],
    };
}

sub properties {
    return {
	monhost => {
	    description => "Monitors daemon ips.",
	    type => 'string',
	},
	pool => {
	    description => "Pool.",
	    type => 'string',
	},
	username => {
	    description => "RBD Id.",
	    type => 'string',
	},
	authsupported => {
	    description => "Authsupported.",
	    type => 'string',
	},
    };
}

sub options {
    return {
	nodes => { optional => 1 },
	disable => { optional => 1 },
	monhost => { fixed => 1 },
	pool => { optional => 1 },
	username => { optional => 1 },
	content => { optional => 1 },
    };
}

# Storage implementation

sub parse_volname {
    my ($class, $volname) = @_;

    if ($volname =~ m/^((base-(\d+)-\S+)\/)?((base)?(vm)?-(\d+)-\S+)$/) {
	return ('images', $4, $7, $2, $3, $5);
    }

    die "unable to parse rbd volume name '$volname'\n";
}

sub path {
    my ($class, $scfg, $volname, $storeid, $snapname) = @_;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);
    $name .= '@'.$snapname if $snapname;

    my $monhost = addslashes($scfg->{monhost});
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';
    my $username =  $scfg->{username} ? $scfg->{username} : 'admin';

    my $path = "rbd:$pool/$name:mon_host=$monhost";
    my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";

    if(-e $keyring ){
        $path .= ":id=$username:auth_supported=cephx:keyring=$keyring";
    }else{
	$path .= ":auth_supported=none";
    }

    return ($path, $vmid, $vtype);
}

my $find_free_diskname = sub {
    my ($storeid, $scfg, $vmid) = @_;

    my $rbd = rbd_ls($scfg, $storeid);
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';
    my $disk_ids = {};
    my $dat = $rbd->{$pool};

    foreach my $image (keys %$dat) {
	my $volname = $dat->{$image}->{name};
	if ($volname =~ m/(vm|base)-$vmid-disk-(\d+)/){
	    $disk_ids->{$2} = 1;
	}
    }
    #fix: can we search in $rbd hash key with a regex to find (vm|base) ?
    for (my $i = 1; $i < 100; $i++) {
        if (!$disk_ids->{$i}) {
            return "vm-$vmid-disk-$i";
        }
    }

    die "unable to allocate an image name for VM $vmid in storage '$storeid'\n";
};

sub create_base {
    my ($class, $storeid, $scfg, $volname) = @_;

    my $snap = '__base__';

    my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
        $class->parse_volname($volname);

    die "create_base not possible with base image\n" if $isBase;

    my ($size, $parent, $format, undef) = rbd_volume_info($scfg, $storeid, $name);
    die "rbd volume info on '$name' failed\n" if !($size);

    die "rbd image must be at format V2" if $format ne "2";

    die "volname '$volname' contains wrong information about parent $parent $basename\n"
        if $basename && (!$parent || $parent ne $basename."@".$snap);

    my $newname = $name;
    $newname =~ s/^vm-/base-/;

    my $newvolname = $basename ? "$basename/$newname" : "$newname";

    my $cmd = &$rbd_cmd($scfg, $storeid, 'rename', &$add_pool_to_disk($scfg, $name), &$add_pool_to_disk($scfg, $newname));
    run_rbd_command($cmd, errmsg => "rbd rename '$name' error");

    my $running  = undef; #fixme : is create_base always offline ?

    $class->volume_snapshot($scfg, $storeid, $newname, $snap, $running);

    my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $newname, $snap);

    if (!$protected){
	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'protect', $newname, '--snap', $snap);
	run_rbd_command($cmd, errmsg => "rbd protect $newname snap '$snap' error");
    }

    return $newvolname;

}

sub clone_image {
    my ($class, $scfg, $storeid, $volname, $vmid, $snapname) = @_;

    my $snap = '__base__';
    $snap = $snapname if length $snapname;

    my ($vtype, $basename, $basevmid, undef, undef, $isBase) =
        $class->parse_volname($volname);

    die "$volname is not a base image and snapname is not provided\n" 
	if !$isBase && !length($snapname);

    my $name = &$find_free_diskname($storeid, $scfg, $vmid);

    warn "clone $volname: $basename snapname $snap to $name\n";

    if (length($snapname)) {
	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $volname, $snapname);

	if (!$protected) {
	    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'protect', $volname, '--snap', $snapname);
	    run_rbd_command($cmd, errmsg => "rbd protect $volname snap $snapname error");
	}
    }

    my $newvol = "$basename/$name";
    $newvol = $name if length($snapname);

    my $cmd = &$rbd_cmd($scfg, $storeid, 'clone', &$add_pool_to_disk($scfg, $basename), 
			'--snap', $snap, &$add_pool_to_disk($scfg, $name));

    run_rbd_command($cmd, errmsg => "rbd clone '$basename' error");

    return $newvol;
}

sub alloc_image {
    my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;


    die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
	if  $name && $name !~ m/^vm-$vmid-/;

    $name = &$find_free_diskname($storeid, $scfg, $vmid);

    my $cmd = &$rbd_cmd($scfg, $storeid, 'create', '--image-format' , 2, '--size', int(($size+1023)/1024), $name);
    run_rbd_command($cmd, errmsg => "rbd create $name' error");

    return $name;
}

sub free_image {
    my ($class, $storeid, $scfg, $volname, $isBase) = @_;

    my ($vtype, $name, $vmid, undef, undef, undef) =
	$class->parse_volname($volname);

    if ($isBase) {
	my $snap = '__base__';
	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $name, $snap);
	if ($protected){
	    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'unprotect', $name, '--snap', $snap);
	    run_rbd_command($cmd, errmsg => "rbd unprotect $name snap '$snap' error");
	}
    }

    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'purge',  $name);
    run_rbd_command($cmd, errmsg => "rbd snap purge '$volname' error");

    $cmd = &$rbd_cmd($scfg, $storeid, 'rm', $name);
    run_rbd_command($cmd, errmsg => "rbd rm '$volname' error");

    return undef;
}

sub list_images {
    my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;

    $cache->{rbd} = rbd_ls($scfg, $storeid) if !$cache->{rbd};
    my $pool =  $scfg->{pool} ? $scfg->{pool} : 'rbd';

    my $res = [];

    if (my $dat = $cache->{rbd}->{$pool}) {
        foreach my $image (keys %$dat) {

            my $volname = $dat->{$image}->{name};

            my $volid = "$storeid:$volname";

            my $owner = $dat->{$volname}->{vmid};
            if ($vollist) {
                my $found = grep { $_ eq $volid } @$vollist;
                next if !$found;
            } else {
                next if defined ($vmid) && ($owner ne $vmid);
            }

            my $info = $dat->{$volname};
            $info->{volid} = $volid;
	    $info->{format} = 'raw';

            push @$res, $info;
        }
    }
    
    return $res;
}

sub status {
    my ($class, $storeid, $scfg, $cache) = @_;

    my $cmd = &$rados_cmd($scfg, $storeid, 'df');

    my $stats = {};

    my $parser = sub {
	my $line = shift;
	if ($line =~ m/^\s+total\s(\S+)\s+(\d+)/) {
	    $stats->{$1} = $2;
	}
    };

    eval {
	run_rbd_command($cmd, errmsg => "rados error", errfunc => sub {}, outfunc => $parser);
    };

    my $total = $stats->{space} ? $stats->{space}*1024 : 0;
    my $free = $stats->{avail} ? $stats->{avail}*1024 : 0;
    my $used = $stats->{used} ? $stats->{used}*1024: 0;
    my $active = 1;

    return ($total, $free, $used, $active);
}

sub activate_storage {
    my ($class, $storeid, $scfg, $cache) = @_;
    return 1;
}

sub deactivate_storage {
    my ($class, $storeid, $scfg, $cache) = @_;
    return 1;
}

sub activate_volume {
    my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
    return 1;
}

sub deactivate_volume {
    my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
    return 1;
}

sub volume_size_info {
    my ($class, $scfg, $storeid, $volname, $timeout) = @_;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);
    my ($size, undef) = rbd_volume_info($scfg, $storeid, $name);
    return $size;
}

sub volume_resize {
    my ($class, $scfg, $storeid, $volname, $size, $running) = @_;

    return 1 if $running;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);

    my $cmd = &$rbd_cmd($scfg, $storeid, 'resize', '--size', ($size/1024/1024), $name);
    run_rbd_command($cmd, errmsg => "rbd resize '$volname' error");
    return undef;
}

sub volume_snapshot {
    my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;

    return 1 if $running;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);

    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'create', '--snap', $snap, $name);
    run_rbd_command($cmd, errmsg => "rbd snapshot '$volname' error");
    return undef;
}

sub volume_snapshot_rollback {
    my ($class, $scfg, $storeid, $volname, $snap) = @_;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);

    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rollback', '--snap', $snap, $name);
    run_rbd_command($cmd, errmsg => "rbd snapshot $volname to '$snap' error");
}

sub volume_snapshot_delete {
    my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;

    return 1 if $running;

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);

    my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $name, $snap);
    if ($protected){
	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'unprotect', $name, '--snap', $snap);
	run_rbd_command($cmd, errmsg => "rbd unprotect $name snap '$snap' error");
    }

    my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rm', '--snap', $snap, $name);

    run_rbd_command($cmd, errmsg => "rbd snapshot '$volname' error");

    return undef;
}

sub volume_has_feature {
    my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;

   my $features = {
	snapshot => { current => 1, snap => 1},
	clone => { base => 1, snap => 1},
	template => { current => 1},
	copy => { base => 1, current => 1, snap => 1},
    };

    my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
        $class->parse_volname($volname);

    my $key = undef;
    if($snapname){
	$key = 'snap';
    }else{
	$key =  $isBase ? 'base' : 'current';
    }
    return 1 if $features->{$feature}->{$key};

    return undef;
}

1;
Commit	Line	Data
	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" => 102410241024,
	16	"T" => 102410241024*1024,
	17	}
	18	}
	19
	20	my $add_pool_to_disk = sub {
	21	my ($scfg, $disk) = @_;
	22
	23	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	24
	25	return "$pool/$disk";
	26	};
	27
	28	my $rbd_cmd = sub {
	29	my ($scfg, $storeid, $op, @options) = @_;
	30
	31	my $monhost = $scfg->{monhost};
	32	$monhost =~ s/;/,/g;
	33
	34	my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";
	35	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	36	my $username = $scfg->{username} ? $scfg->{username} : 'admin';
	37
	38	my $cmd = ['/usr/bin/rbd', '-p', $pool, '-m', $monhost];
	39
	40	if(-e $keyring){
	41	push @$cmd, '-n', "client.$username";
	42	push @$cmd, '--keyring', $keyring;
	43	push @$cmd, '--auth_supported', 'cephx';
	44	}else{
	45	push @$cmd, '--auth_supported', 'none';
	46	}
	47
	48	push @$cmd, $op;
	49
	50	push @$cmd, @options if scalar(@options);
	51
	52	return $cmd;
	53	};
	54
	55	my $rados_cmd = sub {
	56	my ($scfg, $storeid, $op, @options) = @_;
	57
	58	my $monhost = $scfg->{monhost};
	59	$monhost =~ s/;/,/g;
	60
	61	my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";
	62	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	63	my $username = $scfg->{username} ? $scfg->{username} : 'admin';
	64
	65	my $cmd = ['/usr/bin/rados', '-p', $pool, '-m', $monhost];
	66
	67	if(-e $keyring){
	68	push @$cmd, '-n', "client.$username";
	69	push @$cmd, '--keyring', $keyring;
	70	push @$cmd, '--auth_supported', 'cephx';
	71	}else{
	72	push @$cmd, '--auth_supported', 'none';
	73	}
	74
	75	push @$cmd, $op;
	76
	77	push @$cmd, @options if scalar(@options);
	78
	79	return $cmd;
	80	};
	81
	82	sub run_rbd_command {
	83	my ($cmd, %args) = @_;
	84
	85	my $lasterr;
	86	my $errmsg = $args{errmsg} . ": " \|\| "";
	87	if (!exists($args{errfunc})) {
	88	# ' error: 2014-02-06 11:51:59.839135 7f09f94d0760 -1 librbd: snap_unprotect: can't unprotect;
	89	# at least 1 child(ren) in pool cephstor1
	90	$args{errfunc} = sub {
	91	my $line = shift;
	92	if ($line =~ m/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ [0-9a-f]+ [\-\d]+ librbd: (.*)$/) {
	93	$lasterr = "$1\n";
	94	} else {
	95	$lasterr = $line;
	96	}
	97	print STDERR $lasterr;
	98	*STDERR->flush();
	99	};
	100	}
	101
	102	eval { run_command($cmd, %args); };
	103	if (my $err = $@) {
	104	die $errmsg . $lasterr if length($lasterr);
	105	die $err;
	106	}
	107
	108	return undef;
	109	}
	110
	111	sub rbd_ls {
	112	my ($scfg, $storeid) = @_;
	113
	114	my $cmd = &$rbd_cmd($scfg, $storeid, 'ls', '-l');
	115	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	116
	117	my $list = {};
	118
	119	my $parser = sub {
	120	my $line = shift;
	121
	122	if ($line =~ m/^((vm\|base)-(\d+)-disk-\d+)\s+(\d+)(M\|G\|T)\s((\S+)\/((vm\|base)-\d+-\S+@\S+))?/) {
	123	my ($image, $owner, $size, $unit, $parent) = ($1, $3, $4, $5, $8);
	124
	125	$list->{$pool}->{$image} = {
	126	name => $image,
	127	size => $size*rbd_unittobytes()->{$unit},
	128	parent => $parent,
	129	vmid => $owner
	130	};
	131	}
	132	};
	133
	134	eval {
	135	run_rbd_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
	136	};
	137	my $err = $@;
	138
	139	die $err if $err && $err !~ m/doesn't contain rbd images/ ;
	140
	141	return $list;
	142	}
	143
	144	sub rbd_volume_info {
	145	my ($scfg, $storeid, $volname, $snap) = @_;
	146
	147	my $cmd = undef;
	148
	149	if($snap){
	150	$cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname, '--snap', $snap);
	151	}else{
	152	$cmd = &$rbd_cmd($scfg, $storeid, 'info', $volname);
	153	}
	154
	155	my $size = undef;
	156	my $parent = undef;
	157	my $format = undef;
	158	my $protected = undef;
	159
	160	my $parser = sub {
	161	my $line = shift;
	162
	163	if ($line =~ m/size (\d+) (M\|G\|T)B in (\d+) objects/) {
	164	$size = $1 * rbd_unittobytes()->{$2} if ($1);
	165	} elsif ($line =~ m/parent:\s(\S+)\/(\S+)/) {
	166	$parent = $2;
	167	} elsif ($line =~ m/format:\s(\d+)/) {
	168	$format = $1;
	169	} elsif ($line =~ m/protected:\s(\S+)/) {
	170	$protected = 1 if $1 eq "True";
	171	}
	172
	173	};
	174
	175	run_rbd_command($cmd, errmsg => "rbd error", errfunc => sub {}, outfunc => $parser);
	176
	177	return ($size, $parent, $format, $protected);
	178	}
	179
	180	sub addslashes {
	181	my $text = shift;
	182	$text =~ s/;/\\;/g;
	183	$text =~ s/:/\\:/g;
	184	return $text;
	185	}
	186
	187	# Configuration
	188
	189	PVE::JSONSchema::register_format('pve-storage-monhost', \&parse_monhost);
	190	sub parse_monhost {
	191	my ($name, $noerr) = @_;
	192
	193	if ($name !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
	194	return undef if $noerr;
	195	die "lvm name '$name' contains illegal characters\n";
	196	}
	197
	198	return $name;
	199	}
	200
	201	sub type {
	202	return 'rbd';
	203	}
	204
	205	sub plugindata {
	206	return {
	207	content => [ {images => 1}, { images => 1 }],
	208	};
	209	}
	210
	211	sub properties {
	212	return {
	213	monhost => {
	214	description => "Monitors daemon ips.",
	215	type => 'string',
	216	},
	217	pool => {
	218	description => "Pool.",
	219	type => 'string',
	220	},
	221	username => {
	222	description => "RBD Id.",
	223	type => 'string',
	224	},
	225	authsupported => {
	226	description => "Authsupported.",
	227	type => 'string',
	228	},
	229	};
	230	}
	231
	232	sub options {
	233	return {
	234	nodes => { optional => 1 },
	235	disable => { optional => 1 },
	236	monhost => { fixed => 1 },
	237	pool => { optional => 1 },
	238	username => { optional => 1 },
	239	content => { optional => 1 },
	240	};
	241	}
	242
	243	# Storage implementation
	244
	245	sub parse_volname {
	246	my ($class, $volname) = @_;
	247
	248	if ($volname =~ m/^((base-(\d+)-\S+)\/)?((base)?(vm)?-(\d+)-\S+)$/) {
	249	return ('images', $4, $7, $2, $3, $5);
	250	}
	251
	252	die "unable to parse rbd volume name '$volname'\n";
	253	}
	254
	255	sub path {
	256	my ($class, $scfg, $volname, $storeid, $snapname) = @_;
	257
	258	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	259	$name .= '@'.$snapname if $snapname;
	260
	261	my $monhost = addslashes($scfg->{monhost});
	262	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	263	my $username = $scfg->{username} ? $scfg->{username} : 'admin';
	264
	265	my $path = "rbd:$pool/$name:mon_host=$monhost";
	266	my $keyring = "/etc/pve/priv/ceph/${storeid}.keyring";
	267
	268	if(-e $keyring ){
	269	$path .= ":id=$username:auth_supported=cephx:keyring=$keyring";
	270	}else{
	271	$path .= ":auth_supported=none";
	272	}
	273
	274	return ($path, $vmid, $vtype);
	275	}
	276
	277	my $find_free_diskname = sub {
	278	my ($storeid, $scfg, $vmid) = @_;
	279
	280	my $rbd = rbd_ls($scfg, $storeid);
	281	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	282	my $disk_ids = {};
	283	my $dat = $rbd->{$pool};
	284
	285	foreach my $image (keys %$dat) {
	286	my $volname = $dat->{$image}->{name};
	287	if ($volname =~ m/(vm\|base)-$vmid-disk-(\d+)/){
	288	$disk_ids->{$2} = 1;
	289	}
	290	}
	291	#fix: can we search in $rbd hash key with a regex to find (vm\|base) ?
	292	for (my $i = 1; $i < 100; $i++) {
	293	if (!$disk_ids->{$i}) {
	294	return "vm-$vmid-disk-$i";
	295	}
	296	}
	297
	298	die "unable to allocate an image name for VM $vmid in storage '$storeid'\n";
	299	};
	300
	301	sub create_base {
	302	my ($class, $storeid, $scfg, $volname) = @_;
	303
	304	my $snap = '__base__';
	305
	306	my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
	307	$class->parse_volname($volname);
	308
	309	die "create_base not possible with base image\n" if $isBase;
	310
	311	my ($size, $parent, $format, undef) = rbd_volume_info($scfg, $storeid, $name);
	312	die "rbd volume info on '$name' failed\n" if !($size);
	313
	314	die "rbd image must be at format V2" if $format ne "2";
	315
	316	die "volname '$volname' contains wrong information about parent $parent $basename\n"
	317	if $basename && (!$parent \|\| $parent ne $basename."@".$snap);
	318
	319	my $newname = $name;
	320	$newname =~ s/^vm-/base-/;
	321
	322	my $newvolname = $basename ? "$basename/$newname" : "$newname";
	323
	324	my $cmd = &$rbd_cmd($scfg, $storeid, 'rename', &$add_pool_to_disk($scfg, $name), &$add_pool_to_disk($scfg, $newname));
	325	run_rbd_command($cmd, errmsg => "rbd rename '$name' error");
	326
	327	my $running = undef; #fixme : is create_base always offline ?
	328
	329	$class->volume_snapshot($scfg, $storeid, $newname, $snap, $running);
	330
	331	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $newname, $snap);
	332
	333	if (!$protected){
	334	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'protect', $newname, '--snap', $snap);
	335	run_rbd_command($cmd, errmsg => "rbd protect $newname snap '$snap' error");
	336	}
	337
	338	return $newvolname;
	339
	340	}
	341
	342	sub clone_image {
	343	my ($class, $scfg, $storeid, $volname, $vmid, $snapname) = @_;
	344
	345	my $snap = '__base__';
	346	$snap = $snapname if length $snapname;
	347
	348	my ($vtype, $basename, $basevmid, undef, undef, $isBase) =
	349	$class->parse_volname($volname);
	350
	351	die "$volname is not a base image and snapname is not provided\n"
	352	if !$isBase && !length($snapname);
	353
	354	my $name = &$find_free_diskname($storeid, $scfg, $vmid);
	355
	356	warn "clone $volname: $basename snapname $snap to $name\n";
	357
	358	if (length($snapname)) {
	359	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $volname, $snapname);
	360
	361	if (!$protected) {
	362	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'protect', $volname, '--snap', $snapname);
	363	run_rbd_command($cmd, errmsg => "rbd protect $volname snap $snapname error");
	364	}
	365	}
	366
	367	my $newvol = "$basename/$name";
	368	$newvol = $name if length($snapname);
	369
	370	my $cmd = &$rbd_cmd($scfg, $storeid, 'clone', &$add_pool_to_disk($scfg, $basename),
	371	'--snap', $snap, &$add_pool_to_disk($scfg, $name));
	372
	373	run_rbd_command($cmd, errmsg => "rbd clone '$basename' error");
	374
	375	return $newvol;
	376	}
	377
	378	sub alloc_image {
	379	my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_;
	380
	381
	382	die "illegal name '$name' - sould be 'vm-$vmid-*'\n"
	383	if $name && $name !~ m/^vm-$vmid-/;
	384
	385	$name = &$find_free_diskname($storeid, $scfg, $vmid);
	386
	387	my $cmd = &$rbd_cmd($scfg, $storeid, 'create', '--image-format' , 2, '--size', int(($size+1023)/1024), $name);
	388	run_rbd_command($cmd, errmsg => "rbd create $name' error");
	389
	390	return $name;
	391	}
	392
	393	sub free_image {
	394	my ($class, $storeid, $scfg, $volname, $isBase) = @_;
	395
	396	my ($vtype, $name, $vmid, undef, undef, undef) =
	397	$class->parse_volname($volname);
	398
	399	if ($isBase) {
	400	my $snap = '__base__';
	401	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $name, $snap);
	402	if ($protected){
	403	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'unprotect', $name, '--snap', $snap);
	404	run_rbd_command($cmd, errmsg => "rbd unprotect $name snap '$snap' error");
	405	}
	406	}
	407
	408	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'purge', $name);
	409	run_rbd_command($cmd, errmsg => "rbd snap purge '$volname' error");
	410
	411	$cmd = &$rbd_cmd($scfg, $storeid, 'rm', $name);
	412	run_rbd_command($cmd, errmsg => "rbd rm '$volname' error");
	413
	414	return undef;
	415	}
	416
	417	sub list_images {
	418	my ($class, $storeid, $scfg, $vmid, $vollist, $cache) = @_;
	419
	420	$cache->{rbd} = rbd_ls($scfg, $storeid) if !$cache->{rbd};
	421	my $pool = $scfg->{pool} ? $scfg->{pool} : 'rbd';
	422
	423	my $res = [];
	424
	425	if (my $dat = $cache->{rbd}->{$pool}) {
	426	foreach my $image (keys %$dat) {
	427
	428	my $volname = $dat->{$image}->{name};
	429
	430	my $volid = "$storeid:$volname";
	431
	432	my $owner = $dat->{$volname}->{vmid};
	433	if ($vollist) {
	434	my $found = grep { $_ eq $volid } @$vollist;
	435	next if !$found;
	436	} else {
	437	next if defined ($vmid) && ($owner ne $vmid);
	438	}
	439
	440	my $info = $dat->{$volname};
	441	$info->{volid} = $volid;
	442	$info->{format} = 'raw';
	443
	444	push @$res, $info;
	445	}
	446	}
	447
	448	return $res;
	449	}
	450
	451	sub status {
	452	my ($class, $storeid, $scfg, $cache) = @_;
	453
	454	my $cmd = &$rados_cmd($scfg, $storeid, 'df');
	455
	456	my $stats = {};
	457
	458	my $parser = sub {
	459	my $line = shift;
	460	if ($line =~ m/^\s+total\s(\S+)\s+(\d+)/) {
	461	$stats->{$1} = $2;
	462	}
	463	};
	464
	465	eval {
	466	run_rbd_command($cmd, errmsg => "rados error", errfunc => sub {}, outfunc => $parser);
	467	};
	468
	469	my $total = $stats->{space} ? $stats->{space}*1024 : 0;
	470	my $free = $stats->{avail} ? $stats->{avail}*1024 : 0;
	471	my $used = $stats->{used} ? $stats->{used}*1024: 0;
	472	my $active = 1;
	473
	474	return ($total, $free, $used, $active);
	475	}
	476
	477	sub activate_storage {
	478	my ($class, $storeid, $scfg, $cache) = @_;
	479	return 1;
	480	}
	481
	482	sub deactivate_storage {
	483	my ($class, $storeid, $scfg, $cache) = @_;
	484	return 1;
	485	}
	486
	487	sub activate_volume {
	488	my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
	489	return 1;
	490	}
	491
	492	sub deactivate_volume {
	493	my ($class, $storeid, $scfg, $volname, $exclusive, $cache) = @_;
	494	return 1;
	495	}
	496
	497	sub volume_size_info {
	498	my ($class, $scfg, $storeid, $volname, $timeout) = @_;
	499
	500	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	501	my ($size, undef) = rbd_volume_info($scfg, $storeid, $name);
	502	return $size;
	503	}
	504
	505	sub volume_resize {
	506	my ($class, $scfg, $storeid, $volname, $size, $running) = @_;
	507
	508	return 1 if $running;
	509
	510	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	511
	512	my $cmd = &$rbd_cmd($scfg, $storeid, 'resize', '--size', ($size/1024/1024), $name);
	513	run_rbd_command($cmd, errmsg => "rbd resize '$volname' error");
	514	return undef;
	515	}
	516
	517	sub volume_snapshot {
	518	my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
	519
	520	return 1 if $running;
	521
	522	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	523
	524	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'create', '--snap', $snap, $name);
	525	run_rbd_command($cmd, errmsg => "rbd snapshot '$volname' error");
	526	return undef;
	527	}
	528
	529	sub volume_snapshot_rollback {
	530	my ($class, $scfg, $storeid, $volname, $snap) = @_;
	531
	532	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	533
	534	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rollback', '--snap', $snap, $name);
	535	run_rbd_command($cmd, errmsg => "rbd snapshot $volname to '$snap' error");
	536	}
	537
	538	sub volume_snapshot_delete {
	539	my ($class, $scfg, $storeid, $volname, $snap, $running) = @_;
	540
	541	return 1 if $running;
	542
	543	my ($vtype, $name, $vmid) = $class->parse_volname($volname);
	544
	545	my (undef, undef, undef, $protected) = rbd_volume_info($scfg, $storeid, $name, $snap);
	546	if ($protected){
	547	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'unprotect', $name, '--snap', $snap);
	548	run_rbd_command($cmd, errmsg => "rbd unprotect $name snap '$snap' error");
	549	}
	550
	551	my $cmd = &$rbd_cmd($scfg, $storeid, 'snap', 'rm', '--snap', $snap, $name);
	552
	553	run_rbd_command($cmd, errmsg => "rbd snapshot '$volname' error");
	554
	555	return undef;
	556	}
	557
	558	sub volume_has_feature {
	559	my ($class, $scfg, $feature, $storeid, $volname, $snapname, $running) = @_;
	560
	561	my $features = {
	562	snapshot => { current => 1, snap => 1},
	563	clone => { base => 1, snap => 1},
	564	template => { current => 1},
	565	copy => { base => 1, current => 1, snap => 1},
	566	};
	567
	568	my ($vtype, $name, $vmid, $basename, $basevmid, $isBase) =
	569	$class->parse_volname($volname);
	570
	571	my $key = undef;
	572	if($snapname){
	573	$key = 'snap';
	574	}else{
	575	$key = $isBase ? 'base' : 'current';
	576	}
	577	return 1 if $features->{$feature}->{$key};
	578
	579	return undef;
	580	}
	581
	582	1;