1 package PVE
::LXC
::Config
;
6 use PVE
::AbstractConfig
;
7 use PVE
::Cluster
qw(cfs_register_file);
9 use PVE
::JSONSchema
qw(get_standard_option);
12 use base
qw(PVE::AbstractConfig);
14 my $nodename = PVE
::INotify
::nodename
();
15 my $lock_handles = {};
16 my $lockdir = "/run/lock/lxc";
18 mkdir "/etc/pve/nodes/$nodename/lxc";
19 my $MAX_MOUNT_POINTS = 256;
20 my $MAX_UNUSED_DISKS = $MAX_MOUNT_POINTS;
22 # BEGIN implemented abstract methods from PVE::AbstractConfig
28 sub __config_max_unused_disks
{
31 return $MAX_UNUSED_DISKS;
34 sub config_file_lock
{
35 my ($class, $vmid) = @_;
37 return "$lockdir/pve-config-${vmid}.lock";
41 my ($class, $vmid, $node) = @_;
43 $node = $nodename if !$node;
44 return "nodes/$node/lxc/$vmid.conf";
47 sub mountpoint_backup_enabled
{
48 my ($class, $mp_key, $mountpoint) = @_;
50 return 1 if $mp_key eq 'rootfs';
52 return 0 if $mountpoint->{type
} ne 'volume';
54 return 1 if $mountpoint->{backup
};
60 my ($class, $feature, $conf, $storecfg, $snapname, $running, $backup_only) = @_;
63 $class->foreach_mountpoint($conf, sub {
64 my ($ms, $mountpoint) = @_;
66 return if $err; # skip further test
67 return if $backup_only && !$class->mountpoint_backup_enabled($ms, $mountpoint);
70 if !PVE
::Storage
::volume_has_feature
($storecfg, $feature,
71 $mountpoint->{volume
},
78 sub __snapshot_save_vmstate
{
79 my ($class, $vmid, $conf, $snapname, $storecfg) = @_;
80 die "implement me - snapshot_save_vmstate\n";
83 sub __snapshot_check_running
{
84 my ($class, $vmid) = @_;
85 return PVE
::LXC
::check_running
($vmid);
88 sub __snapshot_check_freeze_needed
{
89 my ($class, $vmid, $config, $save_vmstate) = @_;
91 my $ret = $class->__snapshot_check_running($vmid);
95 sub __snapshot_freeze
{
96 my ($class, $vmid, $unfreeze) = @_;
99 eval { PVE
::Tools
::run_command
(['/usr/bin/lxc-unfreeze', '-n', $vmid]); };
102 PVE
::Tools
::run_command
(['/usr/bin/lxc-freeze', '-n', $vmid]);
103 PVE
::LXC
::sync_container_namespace
($vmid);
107 sub __snapshot_create_vol_snapshot
{
108 my ($class, $vmid, $ms, $mountpoint, $snapname) = @_;
110 my $storecfg = PVE
::Storage
::config
();
112 return if $snapname eq 'vzdump' &&
113 !$class->mountpoint_backup_enabled($ms, $mountpoint);
115 PVE
::Storage
::volume_snapshot
($storecfg, $mountpoint->{volume
}, $snapname);
118 sub __snapshot_delete_remove_drive
{
119 my ($class, $snap, $remove_drive) = @_;
121 if ($remove_drive eq 'vmstate') {
122 die "implement me - saving vmstate\n";
124 my $value = $snap->{$remove_drive};
125 my $mountpoint = $remove_drive eq 'rootfs' ?
$class->parse_ct_rootfs($value, 1) : $class->parse_ct_mountpoint($value, 1);
126 delete $snap->{$remove_drive};
128 $class->add_unused_volume($snap, $mountpoint->{volume
})
129 if ($mountpoint->{type
} eq 'volume');
133 sub __snapshot_delete_vmstate_file
{
134 my ($class, $snap, $force) = @_;
136 die "implement me - saving vmstate\n";
139 sub __snapshot_delete_vol_snapshot
{
140 my ($class, $vmid, $ms, $mountpoint, $snapname, $unused) = @_;
142 return if $snapname eq 'vzdump' &&
143 !$class->mountpoint_backup_enabled($ms, $mountpoint);
145 my $storecfg = PVE
::Storage
::config
();
146 PVE
::Storage
::volume_snapshot_delete
($storecfg, $mountpoint->{volume
}, $snapname);
147 push @$unused, $mountpoint->{volume
};
150 sub __snapshot_rollback_vol_possible
{
151 my ($class, $mountpoint, $snapname) = @_;
153 my $storecfg = PVE
::Storage
::config
();
154 PVE
::Storage
::volume_rollback_is_possible
($storecfg, $mountpoint->{volume
}, $snapname);
157 sub __snapshot_rollback_vol_rollback
{
158 my ($class, $mountpoint, $snapname) = @_;
160 my $storecfg = PVE
::Storage
::config
();
161 PVE
::Storage
::volume_snapshot_rollback
($storecfg, $mountpoint->{volume
}, $snapname);
164 sub __snapshot_rollback_vm_stop
{
165 my ($class, $vmid) = @_;
167 PVE
::LXC
::vm_stop
($vmid, 1)
168 if $class->__snapshot_check_running($vmid);
171 sub __snapshot_rollback_vm_start
{
172 my ($class, $vmid, $vmstate, $data);
174 die "implement me - save vmstate\n";
177 sub __snapshot_rollback_get_unused
{
178 my ($class, $conf, $snap) = @_;
182 $class->__snapshot_foreach_volume($conf, sub {
183 my ($vs, $volume) = @_;
185 return if $volume->{type
} ne 'volume';
188 my $volid = $volume->{volume
};
190 $class->__snapshot_foreach_volume($snap, sub {
191 my ($ms, $mountpoint) = @_;
194 return if ($mountpoint->{type
} ne 'volume');
197 if ($mountpoint->{volume
} && $mountpoint->{volume
} eq $volid);
200 push @$unused, $volid if !$found;
206 sub __snapshot_foreach_volume
{
207 my ($class, $conf, $func) = @_;
209 $class->foreach_mountpoint($conf, $func);
212 # END implemented abstract methods from PVE::AbstractConfig
214 # BEGIN JSON config code
216 cfs_register_file
('/lxc/', \
&parse_pct_config
, \
&write_pct_config
);
222 format
=> 'pve-lxc-mp-string',
223 format_description
=> 'volume',
224 description
=> 'Volume, device or directory to mount into the container.',
228 format
=> 'disk-size',
229 format_description
=> 'DiskSize',
230 description
=> 'Volume size (read only value).',
235 description
=> 'Explicitly enable or disable ACL support.',
240 description
=> 'Read-only mount point',
245 description
=> 'Enable user quotas inside the container (not supported with zfs subvolumes)',
250 description
=> 'Will include this volume to a storage replica job.',
256 description
=> 'Mark this non-volume mount point as available on multiple nodes (see \'nodes\')',
257 verbose_description
=> "Mark this non-volume mount point as available on all nodes.\n\nWARNING: This option does not share the mount point automatically, it assumes it is shared already!",
263 PVE
::JSONSchema
::register_standard_option
('pve-ct-rootfs', {
264 type
=> 'string', format
=> $rootfs_desc,
265 description
=> "Use volume as container root.",
269 PVE
::JSONSchema
::register_standard_option
('pve-lxc-snapshot-name', {
270 description
=> "The name of the snapshot.",
271 type
=> 'string', format
=> 'pve-configid',
279 description
=> "Lock/unlock the VM.",
280 enum
=> [qw(backup disk migrate mounted rollback snapshot snapshot-delete)],
285 description
=> "Specifies whether a VM will be started during system bootup.",
288 startup
=> get_standard_option
('pve-startup-order'),
292 description
=> "Enable/disable Template.",
298 enum
=> ['amd64', 'i386'],
299 description
=> "OS architecture type.",
305 enum
=> [qw(debian ubuntu centos fedora opensuse archlinux alpine gentoo unmanaged)],
306 description
=> "OS type. This is used to setup configuration inside the container, and corresponds to lxc setup scripts in /usr/share/lxc/config/<ostype>.common.conf. Value 'unmanaged' can be used to skip and OS specific setup.",
311 description
=> "Attach a console device (/dev/console) to the container.",
317 description
=> "Specify the number of tty available to the container",
325 description
=> "The number of cores assigned to the container. A container can use all available cores by default.",
332 description
=> "Limit of CPU usage.\n\nNOTE: If the computer has 2 CPUs, it has a total of '2' CPU time. Value '0' indicates no CPU limit.",
340 description
=> "CPU weight for a VM. Argument is used in the kernel fair scheduler. The larger the number is, the more CPU time this VM gets. Number is relative to the weights of all the other running VMs.\n\nNOTE: You can disable fair-scheduler configuration by setting this to 0.",
348 description
=> "Amount of RAM for the VM in MB.",
355 description
=> "Amount of SWAP for the VM in MB.",
361 description
=> "Set a host name for the container.",
362 type
=> 'string', format
=> 'dns-name',
368 description
=> "Container description. Only used on the configuration web interface.",
372 type
=> 'string', format
=> 'dns-name-list',
373 description
=> "Sets DNS search domains for a container. Create will automatically use the setting from the host if you neither set searchdomain nor nameserver.",
377 type
=> 'string', format
=> 'address-list',
378 description
=> "Sets DNS server IP address for a container. Create will automatically use the setting from the host if you neither set searchdomain nor nameserver.",
380 rootfs
=> get_standard_option
('pve-ct-rootfs'),
383 type
=> 'string', format
=> 'pve-configid',
385 description
=> "Parent snapshot name. This is used internally, and should not be modified.",
389 description
=> "Timestamp for snapshots.",
395 description
=> "Console mode. By default, the console command tries to open a connection to one of the available tty devices. By setting cmode to 'console' it tries to attach to /dev/console instead. If you set cmode to 'shell', it simply invokes a shell inside the container (no login).",
397 enum
=> ['shell', 'console', 'tty'],
403 description
=> "Sets the protection flag of the container. This will prevent the CT or CT's disk remove/update operation.",
409 description
=> "Makes the container run as unprivileged user. (Should not be modified manually.)",
414 my $valid_lxc_conf_keys = {
415 'lxc.apparmor.profile' => 1,
416 'lxc.apparmor.allow_incomplete' => 1,
417 'lxc.selinux.context' => 1,
421 'lxc.signal.halt' => 1,
422 'lxc.signal.reboot' => 1,
423 'lxc.signal.stop' => 1,
426 'lxc.console.logfile' => 1,
427 'lxc.console.path' => 1,
429 'lxc.devtty.dir' => 1,
430 'lxc.hook.autodev' => 1,
433 'lxc.mount.fstab' => 1,
434 'lxc.mount.entry' => 1,
435 'lxc.mount.auto' => 1,
436 'lxc.rootfs.path' => 'lxc.rootfs.path is auto generated from rootfs',
437 'lxc.rootfs.mount' => 1,
438 'lxc.rootfs.options' => 'lxc.rootfs.options is not supported' .
439 ', please use mount point options in the "rootfs" key',
444 'lxc.seccomp.profile' => 1,
446 'lxc.hook.pre-start' => 1,
447 'lxc.hook.pre-mount' => 1,
448 'lxc.hook.mount' => 1,
449 'lxc.hook.start' => 1,
450 'lxc.hook.stop' => 1,
451 'lxc.hook.post-stop' => 1,
452 'lxc.hook.clone' => 1,
453 'lxc.hook.destroy' => 1,
454 'lxc.log.level' => 1,
456 'lxc.start.auto' => 1,
457 'lxc.start.delay' => 1,
458 'lxc.start.order' => 1,
460 'lxc.environment' => 1,
463 my $deprecated_lxc_conf_keys = {
464 # Deprecated (removed with lxc 3.0):
465 'lxc.aa_profile' => 'lxc.apparmor.profile',
466 'lxc.aa_allow_incomplete' => 'lxc.apparmor.allow_incomplete',
467 'lxc.console' => 'lxc.console.path',
468 'lxc.devttydir' => 'lxc.tty.dir',
469 'lxc.haltsignal' => 'lxc.signal.halt',
470 'lxc.rebootsignal' => 'lxc.signal.reboot',
471 'lxc.stopsignal' => 'lxc.signal.stop',
472 'lxc.id_map' => 'lxc.idmap',
473 'lxc.init_cmd' => 'lxc.init.cmd',
474 'lxc.loglevel' => 'lxc.log.level',
475 'lxc.logfile' => 'lxc.log.file',
476 'lxc.mount' => 'lxc.mount.fstab',
477 'lxc.network.type' => 'lxc.net.INDEX.type',
478 'lxc.network.flags' => 'lxc.net.INDEX.flags',
479 'lxc.network.link' => 'lxc.net.INDEX.link',
480 'lxc.network.mtu' => 'lxc.net.INDEX.mtu',
481 'lxc.network.name' => 'lxc.net.INDEX.name',
482 'lxc.network.hwaddr' => 'lxc.net.INDEX.hwaddr',
483 'lxc.network.ipv4' => 'lxc.net.INDEX.ipv4.address',
484 'lxc.network.ipv4.gateway' => 'lxc.net.INDEX.ipv4.gateway',
485 'lxc.network.ipv6' => 'lxc.net.INDEX.ipv6.address',
486 'lxc.network.ipv6.gateway' => 'lxc.net.INDEX.ipv6.gateway',
487 'lxc.network.script.up' => 'lxc.net.INDEX.script.up',
488 'lxc.network.script.down' => 'lxc.net.INDEX.script.down',
489 'lxc.pts' => 'lxc.pty.max',
490 'lxc.se_context' => 'lxc.selinux.context',
491 'lxc.seccomp' => 'lxc.seccomp.profile',
492 'lxc.tty' => 'lxc.tty.max',
493 'lxc.utsname' => 'lxc.uts.name',
496 sub is_valid_lxc_conf_key
{
497 my ($vmid, $key) = @_;
498 if ($key =~ /^lxc\.limit\./) {
499 warn "vm $vmid - $key: lxc.limit.* was renamed to lxc.prlimit.*\n";
502 if (defined(my $new_name = $deprecated_lxc_conf_keys->{$key})) {
503 warn "vm $vmid - $key is deprecated and was renamed to $new_name\n";
506 my $validity = $valid_lxc_conf_keys->{$key};
507 return $validity if defined($validity);
508 return 1 if $key =~ /^lxc\.cgroup\./ # allow all cgroup values
509 || $key =~ /^lxc\.prlimit\./ # allow all prlimits
510 || $key =~ /^lxc\.net\./; # allow custom network definitions
514 our $netconf_desc = {
518 description
=> "Network interface type.",
523 format_description
=> 'string',
524 description
=> 'Name of the network device as seen from inside the container. (lxc.network.name)',
525 pattern
=> '[-_.\w\d]+',
529 format_description
=> 'bridge',
530 description
=> 'Bridge to attach the network device to.',
531 pattern
=> '[-_.\w\d]+',
536 format_description
=> "XX:XX:XX:XX:XX:XX",
537 description
=> 'The interface MAC address. This is dynamically allocated by default, but you can set that statically if needed, for example to always have the same link-local IPv6 address. (lxc.network.hwaddr)',
538 pattern
=> qr/(?:[a-f0-9]{2}:){5}[a-f0-9]{2}/i,
543 description
=> 'Maximum transfer unit of the interface. (lxc.network.mtu)',
544 minimum
=> 64, # minimum ethernet frame is 64 bytes
549 format
=> 'pve-ipv4-config',
550 format_description
=> '(IPv4/CIDR|dhcp|manual)',
551 description
=> 'IPv4 address in CIDR format.',
557 format_description
=> 'GatewayIPv4',
558 description
=> 'Default gateway for IPv4 traffic.',
563 format
=> 'pve-ipv6-config',
564 format_description
=> '(IPv6/CIDR|auto|dhcp|manual)',
565 description
=> 'IPv6 address in CIDR format.',
571 format_description
=> 'GatewayIPv6',
572 description
=> 'Default gateway for IPv6 traffic.',
577 description
=> "Controls whether this interface's firewall rules should be used.",
584 description
=> "VLAN tag for this interface.",
589 pattern
=> qr/\d+(?:;\d+)*/,
590 format_description
=> 'vlanid[;vlanid...]',
591 description
=> "VLAN ids to pass through the interface",
596 format_description
=> 'mbps',
597 description
=> "Apply rate limiting to the interface",
601 PVE
::JSONSchema
::register_format
('pve-lxc-network', $netconf_desc);
603 my $MAX_LXC_NETWORKS = 10;
604 for (my $i = 0; $i < $MAX_LXC_NETWORKS; $i++) {
605 $confdesc->{"net$i"} = {
607 type
=> 'string', format
=> $netconf_desc,
608 description
=> "Specifies network interfaces for the container.",
612 PVE
::JSONSchema
::register_format
('pve-lxc-mp-string', \
&verify_lxc_mp_string
);
613 sub verify_lxc_mp_string
{
614 my ($mp, $noerr) = @_;
618 # /. or /.. at the end
619 # ../ at the beginning
621 if($mp =~ m
@/\.\
.?
/@ ||
624 return undef if $noerr;
625 die "$mp contains illegal character sequences\n";
634 description
=> 'Whether to include the mount point in backups.',
635 verbose_description
=> 'Whether to include the mount point in backups '.
636 '(only used for volume mount points).',
641 format
=> 'pve-lxc-mp-string',
642 format_description
=> 'Path',
643 description
=> 'Path to the mount point as seen from inside the container '.
644 '(must not contain symlinks).',
645 verbose_description
=> "Path to the mount point as seen from inside the container.\n\n".
646 "NOTE: Must not contain any symlinks for security reasons."
649 PVE
::JSONSchema
::register_format
('pve-ct-mountpoint', $mp_desc);
653 type
=> 'string', format
=> 'pve-volume-id',
654 description
=> "Reference to unused volumes. This is used internally, and should not be modified manually.",
657 for (my $i = 0; $i < $MAX_MOUNT_POINTS; $i++) {
658 $confdesc->{"mp$i"} = {
660 type
=> 'string', format
=> $mp_desc,
661 description
=> "Use volume as container mount point.",
666 for (my $i = 0; $i < $MAX_MOUNT_POINTS; $i++) {
667 $confdesc->{"unused$i"} = $unuseddesc;
670 sub parse_pct_config
{
671 my ($filename, $raw) = @_;
673 return undef if !defined($raw);
676 digest
=> Digest
::SHA
::sha1_hex
($raw),
680 $filename =~ m
|/lxc/(\d
+).conf
$|
681 || die "got strange filename '$filename'";
689 my @lines = split(/\n/, $raw);
690 foreach my $line (@lines) {
691 next if $line =~ m/^\s*$/;
693 if ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
695 $conf->{description
} = $descr if $descr;
697 $conf = $res->{snapshots
}->{$section} = {};
701 if ($line =~ m/^\#(.*)\s*$/) {
702 $descr .= PVE
::Tools
::decode_text
($1) . "\n";
706 if ($line =~ m/^(lxc\.[a-z0-9_\-\.]+)(:|\s*=)\s*(.*?)\s*$/) {
709 my $validity = is_valid_lxc_conf_key
($vmid, $key);
710 if ($validity eq 1) {
711 push @{$conf->{lxc
}}, [$key, $value];
712 } elsif (my $errmsg = $validity) {
713 warn "vm $vmid - $key: $errmsg\n";
715 warn "vm $vmid - unable to parse config: $line\n";
717 } elsif ($line =~ m/^(description):\s*(.*\S)\s*$/) {
718 $descr .= PVE
::Tools
::decode_text
($2);
719 } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
720 $conf->{snapstate
} = $1;
721 } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(\S.*)\s*$/) {
724 eval { $value = PVE
::LXC
::Config-
>check_type($key, $value); };
725 warn "vm $vmid - unable to parse value of '$key' - $@" if $@;
726 $conf->{$key} = $value;
728 warn "vm $vmid - unable to parse config: $line\n";
732 $conf->{description
} = $descr if $descr;
734 delete $res->{snapstate
}; # just to be sure
739 sub write_pct_config
{
740 my ($filename, $conf) = @_;
742 delete $conf->{snapstate
}; # just to be sure
744 my $volidlist = PVE
::LXC
::Config-
>get_vm_volumes($conf);
745 my $used_volids = {};
746 foreach my $vid (@$volidlist) {
747 $used_volids->{$vid} = 1;
750 # remove 'unusedX' settings if the volume is still used
751 foreach my $key (keys %$conf) {
752 my $value = $conf->{$key};
753 if ($key =~ m/^unused/ && $used_volids->{$value}) {
754 delete $conf->{$key};
758 my $generate_raw_config = sub {
763 # add description as comment to top of file
764 my $descr = $conf->{description
} || '';
765 foreach my $cl (split(/\n/, $descr)) {
766 $raw .= '#' . PVE
::Tools
::encode_text
($cl) . "\n";
769 foreach my $key (sort keys %$conf) {
770 next if $key eq 'digest' || $key eq 'description' ||
771 $key eq 'pending' || $key eq 'snapshots' ||
772 $key eq 'snapname' || $key eq 'lxc';
773 my $value = $conf->{$key};
774 die "detected invalid newline inside property '$key'\n"
776 $raw .= "$key: $value\n";
779 if (my $lxcconf = $conf->{lxc
}) {
780 foreach my $entry (@$lxcconf) {
781 my ($k, $v) = @$entry;
789 my $raw = &$generate_raw_config($conf);
791 foreach my $snapname (sort keys %{$conf->{snapshots
}}) {
792 $raw .= "\n[$snapname]\n";
793 $raw .= &$generate_raw_config($conf->{snapshots
}->{$snapname});
799 sub update_pct_config
{
800 my ($class, $vmid, $conf, $running, $param, $delete) = @_;
809 my $pid = PVE
::LXC
::find_lxc_pid
($vmid);
810 $rootdir = "/proc/$pid/root";
813 my $hotplug_error = sub {
822 if (defined($delete)) {
823 foreach my $opt (@$delete) {
824 if (!exists($conf->{$opt})) {
829 if ($opt eq 'memory' || $opt eq 'rootfs') {
830 die "unable to delete required option '$opt'\n";
831 } elsif ($opt eq 'hostname') {
832 delete $conf->{$opt};
833 } elsif ($opt eq 'swap') {
834 delete $conf->{$opt};
835 PVE
::LXC
::write_cgroup_value
("memory", $vmid,
836 "memory.memsw.limit_in_bytes", -1);
837 } elsif ($opt eq 'description' || $opt eq 'onboot' || $opt eq 'startup') {
838 delete $conf->{$opt};
839 } elsif ($opt eq 'nameserver' || $opt eq 'searchdomain' ||
840 $opt eq 'tty' || $opt eq 'console' || $opt eq 'cmode') {
841 next if $hotplug_error->($opt);
842 delete $conf->{$opt};
843 } elsif ($opt eq 'cores') {
844 delete $conf->{$opt}; # rest is handled by pvestatd
845 } elsif ($opt eq 'cpulimit') {
846 PVE
::LXC
::write_cgroup_value
("cpu", $vmid, "cpu.cfs_quota_us", -1);
847 delete $conf->{$opt};
848 } elsif ($opt eq 'cpuunits') {
849 PVE
::LXC
::write_cgroup_value
("cpu", $vmid, "cpu.shares", $confdesc->{cpuunits
}->{default});
850 delete $conf->{$opt};
851 } elsif ($opt =~ m/^net(\d)$/) {
852 delete $conf->{$opt};
855 PVE
::Network
::veth_delete
("veth${vmid}i$netid");
856 } elsif ($opt eq 'protection') {
857 delete $conf->{$opt};
858 } elsif ($opt =~ m/^unused(\d+)$/) {
859 next if $hotplug_error->($opt);
860 PVE
::LXC
::Config-
>check_protection($conf, "can't remove CT $vmid drive '$opt'");
861 push @deleted_volumes, $conf->{$opt};
862 delete $conf->{$opt};
863 } elsif ($opt =~ m/^mp(\d+)$/) {
864 next if $hotplug_error->($opt);
865 PVE
::LXC
::Config-
>check_protection($conf, "can't remove CT $vmid drive '$opt'");
866 my $mp = PVE
::LXC
::Config-
>parse_ct_mountpoint($conf->{$opt});
867 delete $conf->{$opt};
868 if ($mp->{type
} eq 'volume') {
869 PVE
::LXC
::Config-
>add_unused_volume($conf, $mp->{volume
});
871 } elsif ($opt eq 'unprivileged') {
872 die "unable to delete read-only option: '$opt'\n";
874 die "implement me (delete: $opt)"
876 PVE
::LXC
::Config-
>write_config($vmid, $conf) if $running;
880 # There's no separate swap size to configure, there's memory and "total"
881 # memory (iow. memory+swap). This means we have to change them together.
882 my $wanted_memory = PVE
::Tools
::extract_param
($param, 'memory');
883 my $wanted_swap = PVE
::Tools
::extract_param
($param, 'swap');
884 if (defined($wanted_memory) || defined($wanted_swap)) {
886 my $old_memory = ($conf->{memory
} || 512);
887 my $old_swap = ($conf->{swap
} || 0);
889 $wanted_memory //= $old_memory;
890 $wanted_swap //= $old_swap;
892 my $total = $wanted_memory + $wanted_swap;
894 my $old_total = $old_memory + $old_swap;
895 if ($total > $old_total) {
896 PVE
::LXC
::write_cgroup_value
("memory", $vmid,
897 "memory.memsw.limit_in_bytes",
898 int($total*1024*1024));
899 PVE
::LXC
::write_cgroup_value
("memory", $vmid,
900 "memory.limit_in_bytes",
901 int($wanted_memory*1024*1024));
903 PVE
::LXC
::write_cgroup_value
("memory", $vmid,
904 "memory.limit_in_bytes",
905 int($wanted_memory*1024*1024));
906 PVE
::LXC
::write_cgroup_value
("memory", $vmid,
907 "memory.memsw.limit_in_bytes",
908 int($total*1024*1024));
911 $conf->{memory
} = $wanted_memory;
912 $conf->{swap
} = $wanted_swap;
914 PVE
::LXC
::Config-
>write_config($vmid, $conf) if $running;
917 my $storecfg = PVE
::Storage
::config
();
919 my $used_volids = {};
920 my $check_content_type = sub {
922 my $sid = PVE
::Storage
::parse_volume_id
($mp->{volume
});
923 my $storage_config = PVE
::Storage
::storage_config
($storecfg, $sid);
924 die "storage '$sid' does not allow content type 'rootdir' (Container)\n"
925 if !$storage_config->{content
}->{rootdir
};
928 my $rescan_volume = sub {
931 $mp->{size
} = PVE
::Storage
::volume_size_info
($storecfg, $mp->{volume
}, 5)
932 if !defined($mp->{size
});
934 warn "Could not rescan volume size - $@\n" if $@;
937 foreach my $opt (keys %$param) {
938 my $value = $param->{$opt};
939 my $check_protection_msg = "can't update CT $vmid drive '$opt'";
940 if ($opt eq 'hostname' || $opt eq 'arch') {
941 $conf->{$opt} = $value;
942 } elsif ($opt eq 'onboot') {
943 $conf->{$opt} = $value ?
1 : 0;
944 } elsif ($opt eq 'startup') {
945 $conf->{$opt} = $value;
946 } elsif ($opt eq 'tty' || $opt eq 'console' || $opt eq 'cmode') {
947 next if $hotplug_error->($opt);
948 $conf->{$opt} = $value;
949 } elsif ($opt eq 'nameserver') {
950 next if $hotplug_error->($opt);
951 my $list = PVE
::LXC
::verify_nameserver_list
($value);
952 $conf->{$opt} = $list;
953 } elsif ($opt eq 'searchdomain') {
954 next if $hotplug_error->($opt);
955 my $list = PVE
::LXC
::verify_searchdomain_list
($value);
956 $conf->{$opt} = $list;
957 } elsif ($opt eq 'cores') {
958 $conf->{$opt} = $value;# rest is handled by pvestatd
959 } elsif ($opt eq 'cpulimit') {
961 PVE
::LXC
::write_cgroup_value
("cpu", $vmid, "cpu.cfs_quota_us", -1);
963 PVE
::LXC
::write_cgroup_value
("cpu", $vmid, "cpu.cfs_quota_us", int(100000*$value));
965 $conf->{$opt} = $value;
966 } elsif ($opt eq 'cpuunits') {
967 $conf->{$opt} = $value;
968 PVE
::LXC
::write_cgroup_value
("cpu", $vmid, "cpu.shares", $value);
969 } elsif ($opt eq 'description') {
970 $conf->{$opt} = $value;
971 } elsif ($opt =~ m/^net(\d+)$/) {
973 my $net = PVE
::LXC
::Config-
>parse_lxc_network($value);
975 $conf->{$opt} = PVE
::LXC
::Config-
>print_lxc_network($net);
977 PVE
::LXC
::update_net
($vmid, $conf, $opt, $net, $netid, $rootdir);
979 } elsif ($opt eq 'protection') {
980 $conf->{$opt} = $value ?
1 : 0;
981 } elsif ($opt =~ m/^mp(\d+)$/) {
982 next if $hotplug_error->($opt);
983 PVE
::LXC
::Config-
>check_protection($conf, $check_protection_msg);
984 my $old = $conf->{$opt};
985 my $mp = PVE
::LXC
::Config-
>parse_ct_mountpoint($value);
986 if ($mp->{type
} eq 'volume') {
987 &$check_content_type($mp);
988 $used_volids->{$mp->{volume
}} = 1;
989 &$rescan_volume($mp);
990 $conf->{$opt} = PVE
::LXC
::Config-
>print_ct_mountpoint($mp);
992 $conf->{$opt} = $value;
995 my $mp = PVE
::LXC
::Config-
>parse_ct_mountpoint($old);
996 if ($mp->{type
} eq 'volume') {
997 PVE
::LXC
::Config-
>add_unused_volume($conf, $mp->{volume
});
1001 } elsif ($opt eq 'rootfs') {
1002 next if $hotplug_error->($opt);
1003 PVE
::LXC
::Config-
>check_protection($conf, $check_protection_msg);
1004 my $old = $conf->{$opt};
1005 my $mp = PVE
::LXC
::Config-
>parse_ct_rootfs($value);
1006 if ($mp->{type
} eq 'volume') {
1007 &$check_content_type($mp);
1008 $used_volids->{$mp->{volume
}} = 1;
1009 &$rescan_volume($mp);
1010 $conf->{$opt} = PVE
::LXC
::Config-
>print_ct_mountpoint($mp, 1);
1012 $conf->{$opt} = $value;
1014 if (defined($old)) {
1015 my $mp = PVE
::LXC
::Config-
>parse_ct_rootfs($old);
1016 if ($mp->{type
} eq 'volume') {
1017 PVE
::LXC
::Config-
>add_unused_volume($conf, $mp->{volume
});
1021 } elsif ($opt eq 'unprivileged') {
1022 die "unable to modify read-only option: '$opt'\n";
1023 } elsif ($opt eq 'ostype') {
1024 next if $hotplug_error->($opt);
1025 $conf->{$opt} = $value;
1027 die "implement me: $opt";
1030 PVE
::LXC
::Config-
>write_config($vmid, $conf) if $running;
1033 # Apply deletions and creations of new volumes
1034 if (@deleted_volumes) {
1035 my $storage_cfg = PVE
::Storage
::config
();
1036 foreach my $volume (@deleted_volumes) {
1037 next if $used_volids->{$volume}; # could have been re-added, too
1038 # also check for references in snapshots
1039 next if $class->is_volume_in_use($conf, $volume, 1);
1040 PVE
::LXC
::delete_mountpoint_volume
($storage_cfg, $vmid, $volume);
1045 my $storage_cfg = PVE
::Storage
::config
();
1046 PVE
::LXC
::create_disks
($storage_cfg, $vmid, $conf, $conf);
1049 # This should be the last thing we do here
1050 if ($running && scalar(@nohotplug)) {
1051 die "unable to modify " . join(',', @nohotplug) . " while container is running\n";
1056 my ($class, $key, $value) = @_;
1058 die "unknown setting '$key'\n" if !$confdesc->{$key};
1060 my $type = $confdesc->{$key}->{type
};
1062 if (!defined($value)) {
1063 die "got undefined value\n";
1066 if ($value =~ m/[\n\r]/) {
1067 die "property contains a line feed\n";
1070 if ($type eq 'boolean') {
1071 return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
1072 return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
1073 die "type check ('boolean') failed - got '$value'\n";
1074 } elsif ($type eq 'integer') {
1075 return int($1) if $value =~ m/^(\d+)$/;
1076 die "type check ('integer') failed - got '$value'\n";
1077 } elsif ($type eq 'number') {
1078 return $value if $value =~ m/^(\d+)(\.\d+)?$/;
1079 die "type check ('number') failed - got '$value'\n";
1080 } elsif ($type eq 'string') {
1081 if (my $fmt = $confdesc->{$key}->{format
}) {
1082 PVE
::JSONSchema
::check_format
($fmt, $value);
1087 die "internal error"
1092 # add JSON properties for create and set function
1093 sub json_config_properties
{
1094 my ($class, $prop) = @_;
1096 foreach my $opt (keys %$confdesc) {
1097 next if $opt eq 'parent' || $opt eq 'snaptime';
1098 next if $prop->{$opt};
1099 $prop->{$opt} = $confdesc->{$opt};
1105 sub __parse_ct_mountpoint_full
{
1106 my ($class, $desc, $data, $noerr) = @_;
1111 eval { $res = PVE
::JSONSchema
::parse_property_string
($desc, $data) };
1113 return undef if $noerr;
1117 if (defined(my $size = $res->{size
})) {
1118 $size = PVE
::JSONSchema
::parse_size
($size);
1119 if (!defined($size)) {
1120 return undef if $noerr;
1121 die "invalid size: $size\n";
1123 $res->{size
} = $size;
1126 $res->{type
} = $class->classify_mountpoint($res->{volume
});
1131 sub parse_ct_rootfs
{
1132 my ($class, $data, $noerr) = @_;
1134 my $res = $class->__parse_ct_mountpoint_full($rootfs_desc, $data, $noerr);
1136 $res->{mp
} = '/' if defined($res);
1141 sub parse_ct_mountpoint
{
1142 my ($class, $data, $noerr) = @_;
1144 return $class->__parse_ct_mountpoint_full($mp_desc, $data, $noerr);
1147 sub print_ct_mountpoint
{
1148 my ($class, $info, $nomp) = @_;
1149 my $skip = [ 'type' ];
1150 push @$skip, 'mp' if $nomp;
1151 return PVE
::JSONSchema
::print_property_string
($info, $mp_desc, $skip);
1154 sub print_lxc_network
{
1155 my ($class, $net) = @_;
1156 return PVE
::JSONSchema
::print_property_string
($net, $netconf_desc);
1159 sub parse_lxc_network
{
1160 my ($class, $data) = @_;
1164 return $res if !$data;
1166 $res = PVE
::JSONSchema
::parse_property_string
($netconf_desc, $data);
1168 $res->{type
} = 'veth';
1169 if (!$res->{hwaddr
}) {
1170 my $dc = PVE
::Cluster
::cfs_read_file
('datacenter.cfg');
1171 $res->{hwaddr
} = PVE
::Tools
::random_ether_addr
($dc->{mac_prefix
});
1178 my ($class, $name) = @_;
1180 return defined($confdesc->{$name});
1182 # END JSON config code
1184 sub classify_mountpoint
{
1185 my ($class, $vol) = @_;
1186 if ($vol =~ m!^/!) {
1187 return 'device' if $vol =~ m!^/dev/!;
1193 my $is_volume_in_use = sub {
1194 my ($class, $config, $volid) = @_;
1197 $class->foreach_mountpoint($config, sub {
1198 my ($ms, $mountpoint) = @_;
1200 $used = $mountpoint->{type
} eq 'volume' && $mountpoint->{volume
} eq $volid;
1206 sub is_volume_in_use_by_snapshots
{
1207 my ($class, $config, $volid) = @_;
1209 if (my $snapshots = $config->{snapshots
}) {
1210 foreach my $snap (keys %$snapshots) {
1211 return 1 if $is_volume_in_use->($class, $snapshots->{$snap}, $volid);
1218 sub is_volume_in_use
{
1219 my ($class, $config, $volid, $include_snapshots) = @_;
1220 return 1 if $is_volume_in_use->($class, $config, $volid);
1221 return 1 if $include_snapshots && $class->is_volume_in_use_by_snapshots($config, $volid);
1225 sub has_dev_console
{
1226 my ($class, $conf) = @_;
1228 return !(defined($conf->{console
}) && !$conf->{console
});
1232 my ($class, $conf, $keyname) = @_;
1234 if (my $lxcconf = $conf->{lxc
}) {
1235 foreach my $entry (@$lxcconf) {
1236 my ($key, undef) = @$entry;
1237 return 1 if $key eq $keyname;
1245 my ($class, $conf) = @_;
1247 return $conf->{tty
} // $confdesc->{tty
}->{default};
1251 my ($class, $conf) = @_;
1253 return $conf->{cmode
} // $confdesc->{cmode
}->{default};
1256 sub mountpoint_names
{
1257 my ($class, $reverse) = @_;
1259 my @names = ('rootfs');
1261 for (my $i = 0; $i < $MAX_MOUNT_POINTS; $i++) {
1262 push @names, "mp$i";
1265 return $reverse ?
reverse @names : @names;
1268 sub foreach_mountpoint_full
{
1269 my ($class, $conf, $reverse, $func, @param) = @_;
1271 my $mps = [ grep { defined($conf->{$_}) } $class->mountpoint_names($reverse) ];
1272 foreach my $key (@$mps) {
1273 my $value = $conf->{$key};
1274 my $mountpoint = $key eq 'rootfs' ?
$class->parse_ct_rootfs($value, 1) : $class->parse_ct_mountpoint($value, 1);
1275 next if !defined($mountpoint);
1277 &$func($key, $mountpoint, @param);
1281 sub foreach_mountpoint
{
1282 my ($class, $conf, $func, @param) = @_;
1284 $class->foreach_mountpoint_full($conf, 0, $func, @param);
1287 sub foreach_mountpoint_reverse
{
1288 my ($class, $conf, $func, @param) = @_;
1290 $class->foreach_mountpoint_full($conf, 1, $func, @param);
1293 sub get_vm_volumes
{
1294 my ($class, $conf, $excludes) = @_;
1298 $class->foreach_mountpoint($conf, sub {
1299 my ($ms, $mountpoint) = @_;
1301 return if $excludes && $ms eq $excludes;
1303 my $volid = $mountpoint->{volume
};
1304 return if !$volid || $mountpoint->{type
} ne 'volume';
1306 my ($sid, $volname) = PVE
::Storage
::parse_volume_id
($volid, 1);
1309 push @$vollist, $volid;
1315 sub get_replicatable_volumes
{
1316 my ($class, $storecfg, $vmid, $conf, $cleanup, $noerr) = @_;
1320 my $test_volid = sub {
1321 my ($volid, $mountpoint) = @_;
1325 my $mptype = $mountpoint->{type
};
1326 my $replicate = $mountpoint->{replicate
} // 1;
1328 if ($mptype ne 'volume') {
1329 # skip bindmounts if replicate = 0 even for cleanup,
1330 # since bind mounts could not have been replicated ever
1331 return if !$replicate;
1332 die "unable to replicate mountpoint type '$mptype'\n";
1335 my ($storeid, $volname) = PVE
::Storage
::parse_volume_id
($volid, $noerr);
1336 return if !$storeid;
1338 my $scfg = PVE
::Storage
::storage_config
($storecfg, $storeid);
1339 return if $scfg->{shared
};
1341 my ($path, $owner, $vtype) = PVE
::Storage
::path
($storecfg, $volid);
1342 return if !$owner || ($owner != $vmid);
1344 die "unable to replicate volume '$volid', type '$vtype'\n" if $vtype ne 'images';
1346 return if !$cleanup && !$replicate;
1348 if (!PVE
::Storage
::volume_has_feature
($storecfg, 'replicate', $volid)) {
1349 return if $cleanup || $noerr;
1350 die "missing replicate feature on volume '$volid'\n";
1353 $volhash->{$volid} = 1;
1356 $class->foreach_mountpoint($conf, sub {
1357 my ($ms, $mountpoint) = @_;
1358 $test_volid->($mountpoint->{volume
}, $mountpoint);
1361 foreach my $snapname (keys %{$conf->{snapshots
}}) {
1362 my $snap = $conf->{snapshots
}->{$snapname};
1363 $class->foreach_mountpoint($snap, sub {
1364 my ($ms, $mountpoint) = @_;
1365 $test_volid->($mountpoint->{volume
}, $mountpoint);
1369 # add 'unusedX' volumes to volhash
1370 foreach my $key (keys %$conf) {
1371 if ($key =~ m/^unused/) {
1372 $test_volid->($conf->{$key}, { type
=> 'volume', replicate
=> 1 });