use PVE::INotify;
use PVE::JSONSchema qw(get_standard_option);
use PVE::Tools qw(
- dir_glob_foreach file_get_contents file_set_contents lock_file
- lock_file_full AT_FDCWD O_PATH $IPV4RE $IPV6RE
+ run_command
+ dir_glob_foreach
+ file_get_contents
+ file_set_contents
+ AT_FDCWD
+ O_PATH
+ $IPV4RE
+ $IPV6RE
);
use PVE::CpuSet;
use PVE::Network;
use PVE::AccessControl;
use PVE::ProcFSTools;
+use PVE::RESTEnvironment;
use PVE::Syscall qw(:fsmount);
use PVE::LXC::Config;
use PVE::GuestHelpers qw(safe_string_ne safe_num_ne safe_boolean_ne);
use PVE::LXC::Tools;
use PVE::LXC::CGroup;
+use PVE::LXC::Monitor;
+use PVE::CGroup;
use Time::HiRes qw (gettimeofday);
my $have_sdn;
my $cpuinfo= PVE::ProcFSTools::read_cpuinfo();
+our $NEW_DISK_RE = qr/^([^:\s]+):(\d+(\.\d+)?)$/;
+
sub config_list {
my $vmlist = PVE::Cluster::get_vmlist();
my $res = {};
sub vmstatus {
my ($opt_vmid) = @_;
- my $list = $opt_vmid ? { $opt_vmid => { type => 'lxc', vmid => $opt_vmid }} : config_list();
+ my $list = $opt_vmid ? { $opt_vmid => { type => 'lxc', vmid => int($opt_vmid) }} : config_list();
my $active_hash = list_active_containers();
foreach my $vmid (keys %$list) {
my $d = $list->{$vmid};
- eval { $d->{pid} = find_lxc_pid($vmid) if defined($active_hash->{$vmid}); };
+ eval { $d->{pid} = int(find_lxc_pid($vmid)) if defined($active_hash->{$vmid}); };
warn $@ if $@; # ignore errors (consider them stopped)
$d->{status} = $active_hash->{$vmid} ? 'running' : 'stopped';
$d->{cpus} = $conf->{cores} || $conf->{cpulimit};
$d->{cpus} = $cpucount if !$d->{cpus};
- $d->{lock} = $conf->{lock} || '';
$d->{tags} = $conf->{tags} if defined($conf->{tags});
if ($d->{pid}) {
my $res = get_container_disk_usage($vmid, $d->{pid});
- $d->{disk} = $res->{used};
- $d->{maxdisk} = $res->{total};
+ $d->{disk} = int($res->{used});
+ $d->{maxdisk} = int($res->{total});
} else {
$d->{disk} = 0;
# use 4GB by default ??
if (my $rootfs = $conf->{rootfs}) {
- my $rootinfo = PVE::LXC::Config->parse_ct_rootfs($rootfs);
+ my $rootinfo = PVE::LXC::Config->parse_volume('rootfs', $rootfs);
$d->{maxdisk} = $rootinfo->{size} || (4*1024*1024*1024);
} else {
$d->{maxdisk} = 4*1024*1024*1024;
$d->{diskread} = 0;
$d->{diskwrite} = 0;
- $d->{template} = PVE::LXC::Config->is_template($conf);
+ $d->{template} = 1 if PVE::LXC::Config->is_template($conf);
$d->{lock} = $conf->{lock} if $conf->{lock};
}
my $cgroups = PVE::LXC::CGroup->new($vmid);
if (defined(my $mem = $cgroups->get_memory_stat())) {
- $d->{mem} = $mem->{mem};
- $d->{swap} = $mem->{swap};
+ $d->{mem} = int($mem->{mem});
+ $d->{swap} = int($mem->{swap});
} else {
$d->{mem} = 0;
$d->{swap} = 0;
}
if (defined(my $blkio = $cgroups->get_io_stats())) {
- $d->{diskread} = $blkio->{diskread};
- $d->{diskwrite} = $blkio->{diskwrite};
+ $d->{diskread} = int($blkio->{diskread});
+ $d->{diskwrite} = int($blkio->{diskwrite});
} else {
$d->{diskread} = 0;
$d->{diskwrite} = 0;
die "unable to parse ipv4 address/mask\n";
}
-sub get_cgroup_subsystems {
- my $v1 = {};
- my $v2 = 0;
- my $data = PVE::Tools::file_get_contents('/proc/self/cgroup');
- while ($data =~ /^\d+:([^:\n]*):.*$/gm) {
- my $type = $1;
- if (length($type)) {
- $v1->{$_} = 1 foreach split(/,/, $type);
- } else {
- $v2 = 1;
- }
- }
- return wantarray ? ($v1, $v2) : $v1;
-}
-
# With seccomp trap to userspace we now have the ability to optionally forward
# certain syscalls to the "host" to handle (via our pve-lxc-syscalld daemon).
#
my $rules = {
keyctl => ['errno 38'],
+
+ # Disable btrfs ioctrls since they don't work particularly well in user namespaces.
+ # Particularly, without the mount option to enable rmdir removing snapshots, user
+ # namespaces can create snapshots but neither `show` or `delete` them, which is quite
+ # horrible, so for now, just disable this entirely:
+ #
+ # BTRFS_IOCTL_MAGIC 0x94, _IOC type shift is 8,
+ # so `(req & 0xFF00) == 0x9400` is a btrfs ioctl and gets an EPERM
+ ioctl => ['errno 1 [1,0x9400,SCMP_CMP_MASKED_EQ,0xff00]'],
};
my $raw_conf = '';
return;
}
+ my ($lxc_major, $lxc_minor) = get_lxc_version();
+
my $raw = '';
+ if ($lxc_major >= 4) {
+ # Explicitly don't use relative directories, which is the default, but
+ # note that we do this mostly because they are only applied for *some*
+ # cgroups. Our pve-container@.service now starts lxc-start with `-F`,
+ # so we also don't need to worry about the new monitor cgroup to
+ # confuse systemd.
+ $raw .= "lxc.cgroup.relative = 0\n";
+
+ # To make things easier, let's keep our previous cgroup layout and
+ # simply move the monitor outside:
+ $raw .= "lxc.cgroup.dir.monitor = lxc.monitor/$vmid\n";
+ # cgroup namespace separation for stronger limits:
+ $raw .= "lxc.cgroup.dir.container = lxc/$vmid\n";
+ $raw .= "lxc.cgroup.dir.container.inner = ns\n";
+ }
+
die "missing 'arch' - internal error" if !$conf->{arch};
$raw .= "lxc.arch = $conf->{arch}\n";
my $ostype = $conf->{ostype} || die "missing 'ostype' - internal error";
+ File::Path::mkpath($dir);
+
my $cfgpath = '/usr/share/lxc/config';
my $inc = "$cfgpath/$ostype.common.conf";
$inc ="$cfgpath/common.conf" if !-f $inc;
# files while the container is running!
$raw .= "lxc.monitor.unshare = 1\n";
- my $cgv1 = get_cgroup_subsystems();
+ my ($cgv1, $cgv2) = PVE::CGroup::get_cgroup_controllers();
# Should we read them from /etc/subuid?
if ($unprivileged && !$custom_idmap) {
if (!PVE::LXC::Config->has_dev_console($conf)) {
$raw .= "lxc.console.path = none\n";
- $raw .= "lxc.cgroup.devices.deny = c 5:1 rwm\n" if $cgv1->{devices};
+ if ($cgv1->{devices}) {
+ $raw .= "lxc.cgroup.devices.deny = c 5:1 rwm\n";
+ } elsif (defined($cgv2)) {
+ $raw .= "lxc.cgroup2.devices.deny = c 5:1 rwm\n";
+ }
}
my $ttycount = PVE::LXC::Config->get_tty_count($conf);
my $lxcswap = int(($memory + $swap)*1024*1024);
$raw .= "lxc.cgroup.memory.memsw.limit_in_bytes = $lxcswap\n";
+ } elsif ($cgv2->{memory}) {
+ my $memory = $conf->{memory} || 512;
+ my $swap = $conf->{swap} // 0;
+
+ my $lxcmem = int($memory*1024*1024);
+ $raw .= "lxc.cgroup2.memory.max = $lxcmem\n";
+
+ my $lxcswap = int($swap*1024*1024);
+ $raw .= "lxc.cgroup2.memory.swap.max = $lxcswap\n";
}
if ($cgv1->{cpu}) {
$raw .= "lxc.cgroup.cpu.cfs_quota_us = $value\n";
}
- my $shares = $conf->{cpuunits} || 1024;
+ my $shares = PVE::CGroup::clamp_cpu_shares($conf->{cpuunits});
$raw .= "lxc.cgroup.cpu.shares = $shares\n";
+ } elsif ($cgv2->{cpu}) {
+ # See PVE::CGroup
+ if (my $cpulimit = $conf->{cpulimit}) {
+ my $value = int(100000*$cpulimit);
+ $raw .= "lxc.cgroup2.cpu.max = $value 100000\n";
+ }
+
+ if (defined(my $shares = $conf->{cpuunits})) {
+ $shares = PVE::CGroup::clamp_cpu_shares($shares);
+ $raw .= "lxc.cgroup2.cpu.weight = $shares\n";
+ }
}
die "missing 'rootfs' configuration\n"
if !defined($conf->{rootfs});
- my $mountpoint = PVE::LXC::Config->parse_ct_rootfs($conf->{rootfs});
+ my $mountpoint = PVE::LXC::Config->parse_volume('rootfs', $conf->{rootfs});
$raw .= "lxc.rootfs.path = $dir/rootfs\n";
$raw .= "lxc.net.$ind.veth.pair = veth${vmid}i${ind}\n";
$raw .= "lxc.net.$ind.hwaddr = $d->{hwaddr}\n" if defined($d->{hwaddr});
$raw .= "lxc.net.$ind.name = $d->{name}\n" if defined($d->{name});
- $raw .= "lxc.net.$ind.mtu = $d->{mtu}\n" if defined($d->{mtu});
+
+ # Keep container from starting with invalid mtu configuration
+ if (my $mtu = $d->{mtu}) {
+ my $bridge_mtu = PVE::Network::read_bridge_mtu($d->{bridge});
+ die "$k: MTU size '$mtu' is bigger than bridge MTU '$bridge_mtu'\n"
+ if ($mtu > $bridge_mtu);
+
+ $raw .= "lxc.net.$ind.mtu = $mtu\n";
+ }
+
+ # Starting with lxc 4.0, we do not patch lxc to execute our up-scripts.
+ if ($lxc_major >= 4) {
+ $raw .= "lxc.net.$ind.script.up = /usr/share/lxc/lxcnetaddbr\n";
+ }
}
my $had_cpuset = 0;
if (my $lxcconf = $conf->{lxc}) {
foreach my $entry (@$lxcconf) {
my ($k, $v) = @$entry;
- $had_cpuset = 1 if $k eq 'lxc.cgroup.cpuset.cpus';
+ $had_cpuset = 1 if $k eq 'lxc.cgroup.cpuset.cpus' || $k eq 'lxc.cgroup2.cpuset.cpus';
$raw .= "$k = $v\n";
}
}
my $cpuset;
- my $cpuset_cgroup = eval { PVE::LXC::CGroup::cpuset_controller_path() };
+ my ($cpuset_cgroup, $cpuset_version) = eval { PVE::CGroup::cpuset_controller_path() };
if (defined($cpuset_cgroup)) {
$cpuset = eval { PVE::CpuSet->new_from_path("$cpuset_cgroup/lxc", 1) }
|| PVE::CpuSet->new_from_path($cpuset_cgroup, 1);
$cpuset->delete($members[$randidx]);
splice(@members, $randidx, 1); # keep track of the changes
}
- $raw .= "lxc.cgroup.cpuset.cpus = ".$cpuset->short_string()."\n";
+ my $ver = $cpuset_version == 1 ? '' : '2';
+ $raw .= "lxc.cgroup$ver.cpuset.cpus = ".$cpuset->short_string()."\n";
}
File::Path::mkpath("$dir/rootfs");
my @list = ();
foreach my $server (PVE::Tools::split_list($nameserver_list)) {
- PVE::JSONSchema::pve_verify_ip($server);
+ PVE::LXC::Config::verify_ip_with_ll_iface($server);
push @list, $server;
}
}
sub destroy_lxc_container {
- my ($storage_cfg, $vmid, $conf, $replacement_conf) = @_;
+ my ($storage_cfg, $vmid, $conf, $replacement_conf, $purge_unreferenced) = @_;
- PVE::LXC::Config->foreach_mountpoint($conf, sub {
+ my $volids = {};
+ my $remove_volume = sub {
my ($ms, $mountpoint) = @_;
- delete_mountpoint_volume($storage_cfg, $vmid, $mountpoint->{volume});
- });
+
+ my $volume = $mountpoint->{volume};
+
+ return if $volids->{$volume};
+ $volids->{$volume} = 1;
+
+ delete_mountpoint_volume($storage_cfg, $vmid, $volume);
+ };
+ PVE::LXC::Config->foreach_volume_full($conf, {include_unused => 1}, $remove_volume);
+
+ PVE::LXC::Config->foreach_volume_full($conf->{pending}, {include_unused => 1}, $remove_volume);
+
+ if ($purge_unreferenced) { # also remove unreferenced disk
+ my $vmdisks = PVE::Storage::vdisk_list($storage_cfg, undef, $vmid, undef, 'rootdir');
+ PVE::Storage::foreach_volid($vmdisks, sub {
+ my ($volid, $sid, $volname, $d) = @_;
+ eval { PVE::Storage::vdisk_free($storage_cfg, $volid) };
+ warn $@ if $@;
+ });
+ }
rmdir "/var/lib/lxc/$vmid/rootfs";
unlink "/var/lib/lxc/$vmid/config";
} else {
if (safe_string_ne($oldnet->{bridge}, $newnet->{bridge}) ||
safe_num_ne($oldnet->{tag}, $newnet->{tag}) ||
- safe_num_ne($oldnet->{firewall}, $newnet->{firewall})) {
+ safe_num_ne($oldnet->{firewall}, $newnet->{firewall})
+ ) {
if ($oldnet->{bridge}) {
PVE::Network::tap_unplug($veth);
PVE::LXC::Config->write_config($vmid, $conf);
}
+ my ($bridge, $mac, $firewall, $rate) = $newnet->@{'bridge', 'hwaddr', 'firewall', 'rate'};
if ($have_sdn) {
- PVE::Network::SDN::Zones::tap_plug($veth, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
+ PVE::Network::SDN::Zones::tap_plug(
+ $veth, $bridge, $newnet->{tag}, $firewall, $newnet->{trunks}, $rate);
+ PVE::Network::SDN::Zones::add_bridge_fdb($veth, $mac, $bridge, $firewall);
} else {
- PVE::Network::tap_plug($veth, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
+ PVE::Network::tap_plug(
+ $veth, $bridge, $newnet->{tag}, $firewall, $newnet->{trunks}, $rate, { mac => $mac });
}
# This includes the rate:
if ($have_sdn) {
PVE::Network::SDN::Zones::veth_create($veth, $vethpeer, $newnet->{bridge}, $newnet->{hwaddr});
PVE::Network::SDN::Zones::tap_plug($veth, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
+ PVE::Network::SDN::Zones::add_bridge_fdb($veth, $newnet->{hwaddr}, $newnet->{bridge}, $newnet->{firewall});
} else {
PVE::Network::veth_create($veth, $vethpeer, $newnet->{bridge}, $newnet->{hwaddr});
PVE::Network::tap_plug($veth, $newnet->{bridge}, $newnet->{tag}, $newnet->{firewall}, $newnet->{trunks}, $newnet->{rate});
+ PVE::Network::add_bridge_fdb($veth, $newnet->{hwaddr}, $newnet->{firewall}); # early returns if brport has learning on
}
# attach peer in container
my $mountdata = do { local $/ = undef; <$socket> };
close $socket;
+ my %nosyncfs = (
+ cgroup => 1,
+ cgroup2 => 1,
+ devtmpfs => 1,
+ devpts => 1,
+ 'fuse.lxcfs' => 1,
+ fusectl => 1,
+ mqueue => 1,
+ proc => 1,
+ sysfs => 1,
+ tmpfs => 1,
+ );
+
# Now sync all mountpoints...
my $mounts = PVE::ProcFSTools::parse_mounts($mountdata);
foreach my $mp (@$mounts) {
my ($what, $dir, $fs) = @$mp;
- next if $fs eq 'fuse.lxcfs';
+ next if $nosyncfs{$fs};
eval { PVE::Tools::sync_mountpoint($dir); };
warn $@ if $@;
}
my $storecfg = PVE::Storage::config();
- PVE::LXC::Config->foreach_mountpoint($conf, sub {
+ PVE::LXC::Config->foreach_volume($conf, sub {
my ($ms, $mountpoint) = @_;
my $volid = $mountpoint->{volume};
if !PVE::Storage::volume_has_feature($storecfg, 'template', $volid);
});
- PVE::LXC::Config->foreach_mountpoint($conf, sub {
+ PVE::LXC::Config->foreach_volume($conf, sub {
my ($ms, $mountpoint) = @_;
my $volid = $mountpoint->{volume};
}
sub check_ct_modify_config_perm {
- my ($rpcenv, $authuser, $vmid, $pool, $newconf, $delete) = @_;
+ my ($rpcenv, $authuser, $vmid, $pool, $oldconf, $newconf, $delete, $unprivileged) = @_;
return 1 if $authuser eq 'root@pam';
+ my $storage_cfg = PVE::Storage::config();
my $check = sub {
my ($opt, $delete) = @_;
} elsif ($opt eq 'rootfs' || $opt =~ /^mp\d+$/) {
$rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
return if $delete;
- my $data = $opt eq 'rootfs' ? PVE::LXC::Config->parse_ct_rootfs($newconf->{$opt})
- : PVE::LXC::Config->parse_ct_mountpoint($newconf->{$opt});
+ my $data = PVE::LXC::Config->parse_volume($opt, $newconf->{$opt});
raise_perm_exc("mount point type $data->{type} is only allowed for root\@pam")
if $data->{type} ne 'volume';
+ my $volid = $data->{volume};
+ if ($volid =~ $NEW_DISK_RE) {
+ my $sid = $1;
+ $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
+ } else {
+ PVE::Storage::check_volume_access(
+ $rpcenv,
+ $authuser,
+ $storage_cfg,
+ $vmid,
+ $volid,
+ 'rootdir',
+ );
+ }
} elsif ($opt eq 'memory' || $opt eq 'swap') {
$rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Memory']);
} elsif ($opt =~ m/^net\d+$/ || $opt eq 'nameserver' ||
$opt eq 'searchdomain' || $opt eq 'hostname') {
$rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']);
} elsif ($opt eq 'features') {
- # For now this is restricted to root@pam
- raise_perm_exc("changing feature flags is only allowed for root\@pam");
+ raise_perm_exc("changing feature flags for privileged container is only allowed for root\@pam")
+ if !$unprivileged;
+
+ my $nesting_changed = 0;
+ my $other_changed = 0;
+ if (!$delete) {
+ my $features = PVE::LXC::Config->parse_features($newconf->{$opt});
+ if (defined($oldconf) && $oldconf->{$opt}) {
+ # existing container with features
+ my $old_features = PVE::LXC::Config->parse_features($oldconf->{$opt});
+ for my $feature ((keys %$old_features, keys %$features)) {
+ my $old = $old_features->{$feature} // '';
+ my $new = $features->{$feature} // '';
+ if ($old ne $new) {
+ if ($feature eq 'nesting') {
+ $nesting_changed = 1;
+ next;
+ } else {
+ $other_changed = 1;
+ last;
+ }
+ }
+ }
+ } else {
+ # new container or no features defined
+ if (scalar(keys %$features) == 1 && $features->{nesting}) {
+ $nesting_changed = 1;
+ } elsif (scalar(keys %$features) > 0) {
+ $other_changed = 1;
+ }
+ }
+ } else {
+ my $features = PVE::LXC::Config->parse_features($oldconf->{$opt});
+ if (scalar(keys %$features) == 1 && $features->{nesting}) {
+ $nesting_changed = 1;
+ } elsif (scalar(keys %$features) > 0) {
+ $other_changed = 1;
+ }
+ }
+ raise_perm_exc("changing feature flags (except nesting) is only allowed for root\@pam")
+ if $other_changed;
+ $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Allocate'])
+ if $nesting_changed;
} elsif ($opt eq 'hookscript') {
# For now this is restricted to root@pam
raise_perm_exc("changing the hookscript is only allowed for root\@pam");
+ } elsif ($opt eq 'tags') {
+ my $old = $oldconf->{$opt};
+ my $new = $delete ? '' : $newconf->{$opt};
+ PVE::GuestHelpers::assert_tag_permissions($vmid, $old, $new, $rpcenv, $authuser);
} else {
$rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Options']);
}
my $res = 1;
- PVE::LXC::Config->foreach_mountpoint_reverse($conf, sub {
+ PVE::LXC::Config->foreach_volume_full($conf, {'reverse' => 1}, sub {
my ($ms, $mountpoint) = @_;
my $volid = $mountpoint->{volume};
my (undef, $rootuid, $rootgid) = parse_id_maps($conf);
eval {
- PVE::LXC::Config->foreach_mountpoint($conf, sub {
+ PVE::LXC::Config->foreach_volume($conf, sub {
my ($ms, $mountpoint) = @_;
$mountpoint->{ro} = 0 if $ignore_ro;
}
};
my $use_loopdev = 0;
- if ($scfg->{path}) {
- $mounted_dev = run_with_loopdev($domount, $path, $readonly);
- $use_loopdev = 1;
- } elsif ($scfg->{type} eq 'drbd' || $scfg->{type} eq 'lvm' ||
- $scfg->{type} eq 'rbd' || $scfg->{type} eq 'lvmthin') {
- $mounted_dev = $path;
- &$domount($path);
+ if ($scfg->{content}->{rootdir}) {
+ if ($scfg->{path}) {
+ $mounted_dev = run_with_loopdev($domount, $path, $readonly);
+ $use_loopdev = 1;
+ } else {
+ $mounted_dev = $path;
+ &$domount($path);
+ }
} else {
- die "unsupported storage type '$scfg->{type}'\n";
+ die "storage '$storage' does not support containers\n";
}
return wantarray ? ($path, $use_loopdev, $mounted_dev) : $path;
} else {
die "unsupported storage";
}
-sub mountpoint_hotplug($$$) {
+sub mountpoint_hotplug :prototype($$$$$) {
my ($vmid, $conf, $opt, $mp, $storage_cfg) = @_;
my (undef, $rootuid, $rootgid) = PVE::LXC::parse_id_maps($conf);
sub mkfs {
my ($dev, $rootuid, $rootgid) = @_;
- PVE::Tools::run_command(['mkfs.ext4', '-O', 'mmp',
- '-E', "root_owner=$rootuid:$rootgid",
- $dev]);
+ run_command(
+ [
+ 'mkfs.ext4',
+ '-O',
+ 'mmp',
+ '-E',
+ "root_owner=$rootuid:$rootgid",
+ $dev,
+ ],
+ outfunc => sub {
+ my $line = shift;
+ # a hack to print only the relevant stuff, i.e., the one which could help on repair
+ if ($line =~ /^(Creating filesystem|Filesystem UUID|Superblock backups|\s+\d+, \d)/) {
+ print "$line\n";
+ }
+ },
+ errfunc => sub {
+ my $line = shift;
+ print STDERR "$line\n" if $line && $line !~ /^mke2fs \d\.\d/;
+ }
+ );
}
sub format_disk {
eval {
my $do_format = 0;
- if ($scfg->{type} eq 'dir' || $scfg->{type} eq 'nfs' || $scfg->{type} eq 'cifs' ) {
- if ($size_kb > 0) {
- $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'raw',
- undef, $size_kb);
+ if ($scfg->{content}->{rootdir} && $scfg->{path}) {
+ if ($size_kb > 0 && !($scfg->{type} eq 'btrfs' && $scfg->{quotas})) {
+ $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'raw', undef, $size_kb);
$do_format = 1;
} else {
- $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'subvol',
- undef, 0);
+ $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'subvol', undef, $size_kb);
$needs_chown = 1;
}
} elsif ($scfg->{type} eq 'zfspool') {
-
- $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'subvol',
- undef, $size_kb);
+ $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'subvol', undef, $size_kb);
$needs_chown = 1;
- } elsif ($scfg->{type} eq 'drbd' || $scfg->{type} eq 'lvm' || $scfg->{type} eq 'lvmthin') {
-
- $volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'raw', undef, $size_kb);
- $do_format = 1;
-
- } elsif ($scfg->{type} eq 'rbd') {
-
+ } elsif ($scfg->{content}->{rootdir}) {
$volid = PVE::Storage::vdisk_alloc($storecfg, $storage, $vmid, 'raw', undef, $size_kb);
$do_format = 1;
} else {
- die "unable to create containers on storage type '$scfg->{type}'\n";
+ die "content type 'rootdir' is not available or configured on storage '$storage'\n";
}
format_disk($storecfg, $volid, $rootuid, $rootgid) if $do_format;
};
return ($volid, $needs_chown);
}
-our $NEW_DISK_RE = qr/^([^:\s]+):(\d+(\.\d+)?)$/;
sub create_disks {
my ($storecfg, $vmid, $settings, $conf, $pending) = @_;
my (undef, $rootuid, $rootgid) = PVE::LXC::parse_id_maps($conf);
my $chown_vollist = [];
- PVE::LXC::Config->foreach_mountpoint($settings, sub {
+ PVE::LXC::Config->foreach_volume($settings, sub {
my ($ms, $mountpoint) = @_;
my $volid = $mountpoint->{volume};
}
};
- PVE::LXC::Config->foreach_mountpoint($conf, $update_mp);
+ PVE::LXC::Config->foreach_volume($conf, $update_mp);
return $changes;
}
sub scan_volids {
my ($cfg, $vmid) = @_;
- my $info = PVE::Storage::vdisk_list($cfg, undef, $vmid);
+ my $info = PVE::Storage::vdisk_list($cfg, undef, $vmid, undef, 'rootdir');
my $all_volumes = {};
foreach my $storeid (keys %$info) {
my $cfg = PVE::Storage::config();
- # FIXME: Remove once our RBD plugin can handle CT and VM on a single storage
- # see: https://pve.proxmox.com/pipermail/pve-devel/2018-July/032900.html
- foreach my $stor (keys %{$cfg->{ids}}) {
- delete($cfg->{ids}->{$stor}) if !$cfg->{ids}->{$stor}->{content}->{rootdir};
- }
-
print "rescan volumes...\n";
my $all_volumes = scan_volids($cfg, $vmid);
return [];
}
+my sub print_ct_stderr_log {
+ my ($vmid) = @_;
+ my $log = eval { file_get_contents("/run/pve/ct-$vmid.stderr") };
+ return if !$log;
+
+ while ($log =~ /^\h*(lxc-start:?\s+$vmid:?\s*\S+\s*)?(.*?)\h*$/gm) {
+ my $line = $2;
+ print STDERR "$line\n";
+ }
+}
+my sub print_ct_warn_log {
+ my ($vmid) = @_;
+ my $log_fn = "/run/pve/ct-$vmid.warnings";
+ my $log = eval { file_get_contents($log_fn) };
+ return if !$log;
+
+ while ($log =~ /^\h*\s*(.*?)\h*$/gm) {
+ PVE::RESTEnvironment::log_warn($1);
+ }
+ unlink $log_fn or warn "could not unlink '$log_fn' - $!\n";
+}
+
+my sub monitor_state_change($$) {
+ my ($monitor_socket, $vmid) = @_;
+ die "no monitor socket\n" if !defined($monitor_socket);
+
+ while (1) {
+ my ($type, $name, $value) = PVE::LXC::Monitor::read_lxc_message($monitor_socket);
+
+ die "monitor socket: got EOF\n" if !defined($type);
+
+ next if $name ne "$vmid" || $type ne 'STATE';
+
+ if ($value eq PVE::LXC::Monitor::STATE_STARTING) {
+ alarm(0); # don't timeout after seeing the starting state
+ } elsif ($value eq PVE::LXC::Monitor::STATE_ABORTING ||
+ $value eq PVE::LXC::Monitor::STATE_STOPPING ||
+ $value eq PVE::LXC::Monitor::STATE_STOPPED) {
+ return 0;
+ } elsif ($value eq PVE::LXC::Monitor::STATE_RUNNING) {
+ return 1;
+ } else {
+ warn "unexpected message from monitor socket - " .
+ "type: '$type' - value: '$value'\n";
+ }
+ }
+}
+my sub monitor_start($$) {
+ my ($monitor_socket, $vmid) = @_;
+
+ my $success = eval {
+ PVE::Tools::run_with_timeout(10, \&monitor_state_change, $monitor_socket, $vmid)
+ };
+ if (my $err = $@) {
+ warn "problem with monitor socket, but continuing anyway: $err\n";
+ } elsif (!$success) {
+ print_ct_stderr_log($vmid);
+ die "startup for container '$vmid' failed\n";
+ }
+}
+
sub vm_start {
- my ($vmid, $conf, $skiplock) = @_;
+ my ($vmid, $conf, $skiplock, $debug) = @_;
# apply pending changes while starting
if (scalar(keys %{$conf->{pending}})) {
my $storecfg = PVE::Storage::config();
PVE::LXC::Config->vmconfig_apply_pending($vmid, $conf, $storecfg);
+ PVE::LXC::Config->write_config($vmid, $conf);
$conf = PVE::LXC::Config->load_config($vmid); # update/reload
}
close($fh);
}
- my $cmd = ['systemctl', 'start', "pve-container\@$vmid"];
+ my $storage_cfg = PVE::Storage::config();
+ my $vollist = PVE::LXC::Config->get_vm_volumes($conf);
+
+ PVE::Storage::activate_volumes($storage_cfg, $vollist);
+
+ my $monitor_socket = eval { PVE::LXC::Monitor::get_monitor_socket() };
+ warn $@ if $@;
+
+ unlink "/run/pve/ct-$vmid.stderr"; # systemd does not truncate log files
+
+ my $is_debug = $debug || (!defined($debug) && $conf->{debug});
+ my $base_unit = $is_debug ? 'pve-container-debug' : 'pve-container';
+
+ my $cmd = ['systemctl', 'start', "$base_unit\@$vmid"];
PVE::GuestHelpers::exec_hookscript($conf, $vmid, 'pre-start', 1);
- eval { PVE::Tools::run_command($cmd); };
+ eval {
+ run_command($cmd);
+
+ monitor_start($monitor_socket, $vmid) if defined($monitor_socket);
+
+ # if debug is requested, print the log it also when the start succeeded
+ print_ct_stderr_log($vmid) if $is_debug;
+
+ print_ct_warn_log($vmid); # always print warn log, if any
+ };
if (my $err = $@) {
unlink $skiplock_flag_fn;
die $err;
}
}
- eval { PVE::Tools::run_command($cmd, timeout => $shutdown_timeout) };
+ eval { run_command($cmd, timeout => $shutdown_timeout) };
if (my $err = $@) {
warn $@ if $@;
}
# Unshare the mount namespace
die "failed to unshare mount namespace: $!\n"
if !PVE::Tools::unshare(PVE::Tools::CLONE_NEWNS);
- PVE::Tools::run_command(['mount', '--make-rslave', '/']);
+ run_command(['mount', '--make-rslave', '/']);
return $code->();
});
}
$bwlimit //= 0;
- PVE::Tools::run_command(['/usr/bin/rsync', '--stats', '-X', '-A', '--numeric-ids',
- '-aH', '--whole-file', '--sparse', '--one-file-system',
- "--bwlimit=$bwlimit", "$src/", $dest]);
+ run_command([
+ 'rsync',
+ '--stats',
+ '-X',
+ '-A',
+ '--numeric-ids',
+ '-aH',
+ '--whole-file',
+ '--sparse',
+ '--one-file-system',
+ "--bwlimit=$bwlimit",
+ "$src/",
+ $dest
+ ]);
};
my $err = $@;
while ((system {"fuser"} "fuser", "-s", $dest) == 0) {sleep 1};
foreach my $mount (reverse @mounted) {
- eval { PVE::Tools::run_command(['/bin/umount', $mount], errfunc => sub{})};
+ eval { run_command(['/bin/umount', $mount], errfunc => sub{})};
warn "Can't umount $mount\n" if $@;
}
sub get_lxc_version() {
my $version;
- PVE::Tools::run_command([qw(lxc-start --version)], outfunc => sub {
+ run_command([qw(lxc-start --version)], outfunc => sub {
my ($line) = @_;
# We only parse out major & minor version numbers.
if ($line =~ /^(\d+)\.(\d+)(?:\D.*)?$/) {
return $version->@*;
}
+sub freeze($) {
+ my ($vmid) = @_;
+ if (PVE::CGroup::cgroup_mode() == 2) {
+ PVE::LXC::Command::freeze($vmid, 30);
+ } else {
+ PVE::LXC::CGroup->new($vmid)->freeze_thaw(1);
+ }
+}
+
+sub thaw($) {
+ my ($vmid) = @_;
+ if (PVE::CGroup::cgroup_mode() == 2) {
+ PVE::LXC::Command::unfreeze($vmid, 30);
+ } else {
+ PVE::LXC::CGroup->new($vmid)->freeze_thaw(0);
+ }
+}
+
1;
projects / pve-container.git / blobdiff