[pve-container.git] / src / PVE / LXCCreate.pm

package PVE::LXCCreate;

use strict;
use warnings;
use File::Basename;
use File::Path;
use Data::Dumper;

use PVE::Storage;
use PVE::LXC;
use PVE::LXCSetup;
use PVE::VZDump::ConvertOVZ;

sub next_free_nbd_dev {
    
    for(my $i = 0;;$i++) {
	my $dev = "/dev/nbd$i";
	last if ! -b $dev;
	next if -f "/sys/block/nbd$i/pid"; # busy
	return $dev;
    }
    die "unable to find free nbd device\n";
}

sub restore_archive {
    my ($archive, $rootdir, $conf) = @_;

    my $userns_cmd = [];

#    we always use the same mapping: 'b:0:100000:65536'
#    if ($conf->{'lxc.id_map'}) {
#	$userns_cmd = ['lxc-usernsexec', '-m', 'b:0:100000:65536', '--'];
#	PVE::Tools::run_command(['chown', '-R', '100000:100000', $rootdir]);
#    }

    my $cmd = [@$userns_cmd, 'tar', 'xpf', $archive, '--numeric-owner', '--totals',
	    '--sparse', '-C', $rootdir];

    push @$cmd, '--anchored';
    push @$cmd, '--exclude' , './dev/*';

    if ($archive eq '-') {
	print "extracting archive from STDIN\n";
	PVE::Tools::run_command($cmd, input => "<&STDIN");
    } else {
	print "extracting archive '$archive'\n";
	PVE::Tools::run_command($cmd);
    }
    
    # determine file type of /usr/bin/file itself to get guests' architecture
    $cmd = [@$userns_cmd, '/usr/bin/file', '-b', '-L', "$rootdir/usr/bin/file"];
    PVE::Tools::run_command($cmd, outfunc => sub {
	shift =~ /^ELF (\d{2}-bit)/; # safely assumes x86 linux
	my $arch_str = $1;
	$conf->{'arch'} = 'amd64'; # defaults to 64bit
	if(defined($arch_str)) {
	    $conf->{'arch'} = 'i386' if $arch_str =~ /32/;
	    print "Detected container architecture: $conf->{'arch'}\n";
	} else {
	    print "CT architecture detection failed, falling back to amd64.\n" .
	          "Edit the config in /etc/pve/nodes/{node}/lxc/{vmid}/config " .
	          "to set another architecture.\n";
	}
    });
}

sub tar_archive_search_conf {
    my ($archive) = @_;

    die "ERROR: file '$archive' does not exist\n" if ! -f $archive;

    my $pid = open(my $fh, '-|', 'tar', 'tf', $archive) ||
       die "unable to open file '$archive'\n";

    my $file;
    while (defined($file = <$fh>)) {
	if ($file =~ m!^(\./etc/vzdump/(pct|vps)\.conf)$!) {
	    $file = $1; # untaint
	    last;
	}
    }

    kill 15, $pid;
    waitpid $pid, 0;
    close $fh;

    die "ERROR: archive contains no configuration file\n" if !$file;
    chomp $file;

    return $file;
}

sub recover_config {
    my ($archive) = @_;

    my $conf_file = tar_archive_search_conf($archive);
    
    my $raw = '';
    my $out = sub {
	my $output = shift;
	$raw .= "$output\n";
    };

    PVE::Tools::run_command(['tar', '-xpOf', $archive, $conf_file, '--occurrence'], outfunc => $out);

    my $conf;
    my $disksize;

    if ($conf_file =~ m/pct\.conf/) {

	$conf = PVE::LXC::parse_pct_config("/lxc/0.conf" , $raw);

	delete $conf->{snapshots};
	delete $conf->{template}; # restored CT is never a template
	
	if (defined($conf->{rootfs})) {
	    my $rootinfo = PVE::LXC::parse_ct_mountpoint($conf->{rootfs});
	    $disksize = $rootinfo->{size} if defined($rootinfo->{size});
	}
	
    } elsif ($conf_file =~ m/vps\.conf/) {
	
	($conf, $disksize) = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	
    } else {

       die "internal error";
    }

    return wantarray ? ($conf, $disksize) : $conf;
}

sub restore_and_configure {
    my ($vmid, $archive, $rootdir, $conf, $password, $restore) = @_;

    restore_archive($archive, $rootdir, $conf);

    if (!$restore) {
	my $lxc_setup = PVE::LXCSetup->new($conf, $rootdir); # detect OS

	PVE::LXC::write_config($vmid, $conf); # safe config (after OS detection)
	$lxc_setup->post_create_hook($password);
    } else {
	# restore: try to extract configuration from archive

	my $pct_cfg_fn = "$rootdir/etc/vzdump/pct.conf";
	my $ovz_cfg_fn = "$rootdir/etc/vzdump/vps.conf";
	if (-f $pct_cfg_fn) {
	    my $raw = PVE::Tools::file_get_contents($pct_cfg_fn);
	    my $oldconf = PVE::LXC::parse_pct_config("/lxc/$vmid.conf", $raw);

	    foreach my $key (keys %$oldconf) {
		next if $key eq 'digest' || $key eq 'rootfs' || $key eq 'snapshots';
		$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	    }
	    
	} elsif (-f $ovz_cfg_fn) {
	    print "###########################################################\n";
	    print "Converting OpenVZ configuration to LXC.\n";
	    print "Please check the configuration and reconfigure the network.\n";
	    print "###########################################################\n";

	    my $raw = PVE::Tools::file_get_contents($ovz_cfg_fn);
	    my $oldconf = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	    foreach my $key (keys %$oldconf) {
		$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	    }

	} else {
	    print "###########################################################\n";
	    print "Backup archive does not contain any configuration\n";
	    print "###########################################################\n";
	}
    }
}

# use new subvolume API
sub create_rootfs_subvol {
    my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;

    my $private = PVE::Storage::path($storage_conf, $volid);
    (-d $private) || die "unable to get container private dir '$private' - $!\n";

    restore_and_configure($vmid, $archive, $private, $conf, $password, $restore);
}

# direct mount
sub create_rootfs_dev {
    my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;

    my $image_path = PVE::Storage::path($storage_conf, $volid);
    
    my $cmd = ['mkfs.ext4', $image_path];
    PVE::Tools::run_command($cmd);

    my $mountpoint;

    eval {
	my $tmp = "/var/lib/lxc/$vmid/rootfs";
	File::Path::mkpath($tmp);
	PVE::Tools::run_command(['mount', '-t', 'ext4', $image_path, $tmp]);
	$mountpoint = $tmp;

	restore_and_configure($vmid, $archive, $mountpoint, $conf, $password, $restore);
    };
    if (my $err = $@) {
	if ($mountpoint) {
	    eval { PVE::Tools::run_command(['umount', $mountpoint]) };
	    warn $@ if $@;
	} 
	die $err;
    }

    PVE::Tools::run_command(['umount', '-l', $mountpoint]);
}

# create a raw file, then loop mount
sub create_rootfs_dir_loop {
    my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;

    my $image_path = PVE::Storage::path($storage_conf, $volid);

    my $cmd = ['mkfs.ext4', $image_path];
    PVE::Tools::run_command($cmd);

    my $mountpoint;

    my $loopdev;
    eval {
	my $parser = sub {
	    my $line = shift;
	    $loopdev = $line if $line =~m|^/dev/loop\d+$|;
	};
	PVE::Tools::run_command(['losetup', '--find', '--show', $image_path], outfunc => $parser);

	my $tmp = "/var/lib/lxc/$vmid/rootfs";
	File::Path::mkpath($tmp);
	PVE::Tools::run_command(['mount', '-t', 'ext4', $loopdev, $tmp]);
	$mountpoint = $tmp;

	restore_and_configure($vmid, $archive, $mountpoint, $conf, $password, $restore);
    };
    if (my $err = $@) {
	if ($mountpoint) {
	    eval { PVE::Tools::run_command(['umount', '-d', $mountpoint]) };
	    warn $@ if $@;
	} else {
	    eval { PVE::Tools::run_command(['losetup', '-d', $loopdev]) if $loopdev; };
	    warn $@ if $@;
	}
	die $err;
    }

    PVE::Tools::run_command(['umount', '-l', '-d', $mountpoint]);
}

sub create_rootfs {
    my ($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;

    my $config_fn = PVE::LXC::config_file($vmid);
    if (-f $config_fn) {
	die "container exists" if !$restore; # just to be sure

	my $old_conf = PVE::LXC::load_config($vmid);
	
	# destroy old container volume
	PVE::LXC::destory_lxc_container($storage_cfg, $vmid, $old_conf);

	# do not copy all settings to restored container
	foreach my $opt (qw(rootfs digest snapshots)) {
	    delete $old_conf->{$opt};
	}
	PVE::LXC::update_pct_config($vmid, $conf, 0, $old_conf);

	PVE::LXC::create_config($vmid, $conf);

    } else {
	
	PVE::LXC::create_config($vmid, $conf);
    }

    my ($vtype, undef, undef, undef, undef, $isBase, $format) =
	PVE::Storage::parse_volname($storage_cfg, $volid);
	
    die "got strange vtype '$vtype'\n" if $vtype ne 'images';
    
    die "unable to install into base volume" if $isBase;

    if ($format eq 'subvol') {
	create_rootfs_subvol($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
    } elsif ($format eq 'raw') {
	my $scfg = PVE::Storage::storage_config($storage_cfg, $storage);
	PVE::Storage::activate_storage($storage_cfg, $storage);
	PVE::Storage::activate_volumes($storage_cfg, [$volid]);
	if ($scfg->{path}) {
	    create_rootfs_dir_loop($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
	} elsif ($scfg->{type} eq 'drbd' || $scfg->{type} eq 'rbd') {
	    create_rootfs_dev($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
	} else {
	    die "unable to create containers on storage type '$scfg->{type}'\n";
	}
	PVE::Storage::deactivate_volumes($storage_cfg, [$volid]);
    } else {
	die "unsupported image format '$format'\n";
    }
}

1;
Commit	Line	Data
5b4657d0 DM	1	package PVE::LXCCreate;
	2
	3	use strict;
	4	use warnings;
	5	use File::Basename;
	6	use File::Path;
	7	use Data::Dumper;
	8
	9	use PVE::Storage;
	10	use PVE::LXC;
	11	use PVE::LXCSetup;
f507c3a7	12	use PVE::VZDump::ConvertOVZ;
5b4657d0	13
6ed8c6dd DM	14	sub next_free_nbd_dev {
	15
	16	for(my $i = 0;;$i++) {
	17	my $dev = "/dev/nbd$i";
	18	last if ! -b $dev;
	19	next if -f "/sys/block/nbd$i/pid"; # busy
	20	return $dev;
	21	}
	22	die "unable to find free nbd device\n";
	23	}
	24
5b4657d0 DM	25	sub restore_archive {
	26	my ($archive, $rootdir, $conf) = @_;
	27
27916659	28	my $userns_cmd = [];
5b4657d0	29
27916659 DM	30	# we always use the same mapping: 'b:0:100000:65536'
	31	# if ($conf->{'lxc.id_map'}) {
	32	# $userns_cmd = ['lxc-usernsexec', '-m', 'b:0:100000:65536', '--'];
	33	# PVE::Tools::run_command(['chown', '-R', '100000:100000', $rootdir]);
	34	# }
5b4657d0	35
27916659	36	my $cmd = [@$userns_cmd, 'tar', 'xpf', $archive, '--numeric-owner', '--totals',
5b4657d0 DM	37	'--sparse', '-C', $rootdir];
	38
	39	push @$cmd, '--anchored';
	40	push @$cmd, '--exclude' , './dev/*';
	41
6034ae50 DM	42	if ($archive eq '-') {
	43	print "extracting archive from STDIN\n";
	44	PVE::Tools::run_command($cmd, input => "<&STDIN");
27916659	45	} else {
6034ae50 DM	46	print "extracting archive '$archive'\n";
6034ae50 DM	47	PVE::Tools::run_command($cmd);
27916659	48	}
6034ae50	49
27916659	50	# determine file type of /usr/bin/file itself to get guests' architecture
a9d131df TL	51	$cmd = [@$userns_cmd, '/usr/bin/file', '-b', '-L', "$rootdir/usr/bin/file"];
	52	PVE::Tools::run_command($cmd, outfunc => sub {
	53	shift =~ /^ELF (\d{2}-bit)/; # safely assumes x86 linux
	54	my $arch_str = $1;
27916659	55	$conf->{'arch'} = 'amd64'; # defaults to 64bit
a9d131df	56	if(defined($arch_str)) {
27916659 DM	57	$conf->{'arch'} = 'i386' if $arch_str =~ /32/;
27916659 DM	58	print "Detected container architecture: $conf->{'arch'}\n";
a9d131df	59	} else {
27916659 DM	60	print "CT architecture detection failed, falling back to amd64.\n" .
	61	"Edit the config in /etc/pve/nodes/{node}/lxc/{vmid}/config " .
	62	"to set another architecture.\n";
a9d131df TL	63	}
a9d131df TL	64	});
5b4657d0 DM	65	}
5b4657d0 DM	66
f507c3a7 WL	67	sub tar_archive_search_conf {
	68	my ($archive) = @_;
	69
	70	die "ERROR: file '$archive' does not exist\n" if ! -f $archive;
	71
	72	my $pid = open(my $fh, '-\|', 'tar', 'tf', $archive) \|\|
27916659	73	die "unable to open file '$archive'\n";
f507c3a7 WL	74
f507c3a7 WL	75	my $file;
effa4f43	76	while (defined($file = <$fh>)) {
27916659	77	if ($file =~ m!^(\./etc/vzdump/(pct\|vps)\.conf)$!) {
effa4f43 DM	78	$file = $1; # untaint
	79	last;
	80	}
f507c3a7 WL	81	}
	82
	83	kill 15, $pid;
	84	waitpid $pid, 0;
	85	close $fh;
	86
effa4f43	87	die "ERROR: archive contains no configuration file\n" if !$file;
f507c3a7 WL	88	chomp $file;
	89
	90	return $file;
	91	}
	92
	93	sub recover_config {
effa4f43	94	my ($archive) = @_;
f507c3a7 WL	95
f507c3a7 WL	96	my $conf_file = tar_archive_search_conf($archive);
27916659	97
f507c3a7 WL	98	my $raw = '';
	99	my $out = sub {
	100	my $output = shift;
	101	$raw .= "$output\n";
	102	};
	103
	104	PVE::Tools::run_command(['tar', '-xpOf', $archive, $conf_file, '--occurrence'], outfunc => $out);
	105
effa4f43	106	my $conf;
27916659	107	my $disksize;
f507c3a7	108
27916659	109	if ($conf_file =~ m/pct\.conf/) {
f507c3a7	110
3381b5c2	111	$conf = PVE::LXC::parse_pct_config("/lxc/0.conf" , $raw);
f507c3a7	112
27916659	113	delete $conf->{snapshots};
bb1ac2de	114	delete $conf->{template}; # restored CT is never a template
27916659 DM	115
	116	if (defined($conf->{rootfs})) {
	117	my $rootinfo = PVE::LXC::parse_ct_mountpoint($conf->{rootfs});
	118	$disksize = $rootinfo->{size} if defined($rootinfo->{size});
	119	}
	120
effa4f43	121	} elsif ($conf_file =~ m/vps\.conf/) {
27916659 DM	122
	123	($conf, $disksize) = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	124
effa4f43 DM	125	} else {
effa4f43 DM	126
27916659	127	die "internal error";
f507c3a7 WL	128	}
f507c3a7 WL	129
27916659	130	return wantarray ? ($conf, $disksize) : $conf;
f507c3a7 WL	131	}
f507c3a7 WL	132
5b4657d0	133	sub restore_and_configure {
f507c3a7	134	my ($vmid, $archive, $rootdir, $conf, $password, $restore) = @_;
5b4657d0 DM	135
	136	restore_archive($archive, $rootdir, $conf);
	137
f507c3a7 WL	138	if (!$restore) {
f507c3a7 WL	139	my $lxc_setup = PVE::LXCSetup->new($conf, $rootdir); # detect OS
5b4657d0	140
f507c3a7 WL	141	PVE::LXC::write_config($vmid, $conf); # safe config (after OS detection)
f507c3a7 WL	142	$lxc_setup->post_create_hook($password);
27916659 DM	143	} else {
27916659 DM	144	# restore: try to extract configuration from archive
5b4657d0	145
27916659 DM	146	my $pct_cfg_fn = "$rootdir/etc/vzdump/pct.conf";
	147	my $ovz_cfg_fn = "$rootdir/etc/vzdump/vps.conf";
	148	if (-f $pct_cfg_fn) {
	149	my $raw = PVE::Tools::file_get_contents($pct_cfg_fn);
	150	my $oldconf = PVE::LXC::parse_pct_config("/lxc/$vmid.conf", $raw);
5b4657d0	151
27916659 DM	152	foreach my $key (keys %$oldconf) {
	153	next if $key eq 'digest' \|\| $key eq 'rootfs' \|\| $key eq 'snapshots';
	154	$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	155	}
	156
	157	} elsif (-f $ovz_cfg_fn) {
	158	print "###########################################################\n";
	159	print "Converting OpenVZ configuration to LXC.\n";
	160	print "Please check the configuration and reconfigure the network.\n";
	161	print "###########################################################\n";
	162
	163	my $raw = PVE::Tools::file_get_contents($ovz_cfg_fn);
	164	my $oldconf = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
	165	foreach my $key (keys %$oldconf) {
	166	$conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
	167	}
5b4657d0	168
27916659 DM	169	} else {
	170	print "###########################################################\n";
	171	print "Backup archive does not contain any configuration\n";
	172	print "###########################################################\n";
	173	}
	174	}
5b4657d0 DM	175	}
5b4657d0 DM	176
ad09aa15 DM	177	# use new subvolume API
ad09aa15 DM	178	sub create_rootfs_subvol {
27916659	179	my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;
ad09aa15 DM	180
	181	my $private = PVE::Storage::path($storage_conf, $volid);
	182	(-d $private) \|\| die "unable to get container private dir '$private' - $!\n";
	183
f507c3a7	184	restore_and_configure($vmid, $archive, $private, $conf, $password, $restore);
ad09aa15 DM	185	}
ad09aa15 DM	186
644f2f8f DM	187	# direct mount
	188	sub create_rootfs_dev {
	189	my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;
	190
	191	my $image_path = PVE::Storage::path($storage_conf, $volid);
	192
	193	my $cmd = ['mkfs.ext4', $image_path];
	194	PVE::Tools::run_command($cmd);
	195
	196	my $mountpoint;
	197
	198	eval {
	199	my $tmp = "/var/lib/lxc/$vmid/rootfs";
	200	File::Path::mkpath($tmp);
	201	PVE::Tools::run_command(['mount', '-t', 'ext4', $image_path, $tmp]);
	202	$mountpoint = $tmp;
	203
	204	restore_and_configure($vmid, $archive, $mountpoint, $conf, $password, $restore);
	205	};
	206	if (my $err = $@) {
	207	if ($mountpoint) {
	208	eval { PVE::Tools::run_command(['umount', $mountpoint]) };
	209	warn $@ if $@;
	210	}
	211	die $err;
	212	}
	213
	214	PVE::Tools::run_command(['umount', '-l', $mountpoint]);
	215	}
	216
5b4657d0 DM	217	# create a raw file, then loop mount
5b4657d0 DM	218	sub create_rootfs_dir_loop {
27916659	219	my ($storage_conf, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;
5b4657d0 DM	220
5b4657d0 DM	221	my $image_path = PVE::Storage::path($storage_conf, $volid);
5b4657d0 DM	222
	223	my $cmd = ['mkfs.ext4', $image_path];
	224	PVE::Tools::run_command($cmd);
	225
5b4657d0 DM	226	my $mountpoint;
	227
	228	my $loopdev;
	229	eval {
	230	my $parser = sub {
	231	my $line = shift;
	232	$loopdev = $line if $line =~m\|^/dev/loop\d+$\|;
	233	};
	234	PVE::Tools::run_command(['losetup', '--find', '--show', $image_path], outfunc => $parser);
	235
	236	my $tmp = "/var/lib/lxc/$vmid/rootfs";
	237	File::Path::mkpath($tmp);
	238	PVE::Tools::run_command(['mount', '-t', 'ext4', $loopdev, $tmp]);
	239	$mountpoint = $tmp;
	240
f507c3a7	241	restore_and_configure($vmid, $archive, $mountpoint, $conf, $password, $restore);
5b4657d0 DM	242	};
	243	if (my $err = $@) {
	244	if ($mountpoint) {
	245	eval { PVE::Tools::run_command(['umount', '-d', $mountpoint]) };
	246	warn $@ if $@;
	247	} else {
	248	eval { PVE::Tools::run_command(['losetup', '-d', $loopdev]) if $loopdev; };
	249	warn $@ if $@;
	250	}
	251	die $err;
	252	}
	253
	254	PVE::Tools::run_command(['umount', '-l', '-d', $mountpoint]);
	255	}
	256
	257	sub create_rootfs {
27916659	258	my ($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore) = @_;
148d1cb4 DM	259
	260	my $config_fn = PVE::LXC::config_file($vmid);
	261	if (-f $config_fn) {
	262	die "container exists" if !$restore; # just to be sure
	263
	264	my $old_conf = PVE::LXC::load_config($vmid);
27916659 DM	265
	266	# destroy old container volume
	267	PVE::LXC::destory_lxc_container($storage_cfg, $vmid, $old_conf);
148d1cb4	268
27916659 DM	269	# do not copy all settings to restored container
	270	foreach my $opt (qw(rootfs digest snapshots)) {
	271	delete $old_conf->{$opt};
f09ce711	272	}
27916659	273	PVE::LXC::update_pct_config($vmid, $conf, 0, $old_conf);
5b4657d0	274
148d1cb4	275	PVE::LXC::create_config($vmid, $conf);
5b4657d0	276
148d1cb4 DM	277	} else {
	278
	279	PVE::LXC::create_config($vmid, $conf);
	280	}
	281
3d8cbc23 DM	282	my ($vtype, undef, undef, undef, undef, $isBase, $format) =
	283	PVE::Storage::parse_volname($storage_cfg, $volid);
	284
	285	die "got strange vtype '$vtype'\n" if $vtype ne 'images';
	286
	287	die "unable to install into base volume" if $isBase;
	288
	289	if ($format eq 'subvol') {
27916659	290	create_rootfs_subvol($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
3d8cbc23 DM	291	} elsif ($format eq 'raw') {
3d8cbc23 DM	292	my $scfg = PVE::Storage::storage_config($storage_cfg, $storage);
63f2ddfb AD	293	PVE::Storage::activate_storage($storage_cfg, $storage);
63f2ddfb AD	294	PVE::Storage::activate_volumes($storage_cfg, [$volid]);
3d8cbc23 DM	295	if ($scfg->{path}) {
3d8cbc23 DM	296	create_rootfs_dir_loop($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
63f2ddfb	297	} elsif ($scfg->{type} eq 'drbd' \|\| $scfg->{type} eq 'rbd') {
3d8cbc23 DM	298	create_rootfs_dev($storage_cfg, $storage, $volid, $vmid, $conf, $archive, $password, $restore);
	299	} else {
	300	die "unable to create containers on storage type '$scfg->{type}'\n";
	301	}
63f2ddfb	302	PVE::Storage::deactivate_volumes($storage_cfg, [$volid]);
27916659	303	} else {
3d8cbc23	304	die "unsupported image format '$format'\n";
5b4657d0 DM	305	}
	306	}
	307
	308	1;