src/PVE/LXC/Config.pm

   1 package PVE::LXC::Config;
   2
   3 use strict;
   4 use warnings;
   5
   6 use PVE::AbstractConfig;
   7 use PVE::Cluster qw(cfs_register_file);
   8 use PVE::DataCenterConfig;
   9 use PVE::GuestHelpers;
  10 use PVE::INotify;
  11 use PVE::JSONSchema qw(get_standard_option);
  12 use PVE::Tools;
  13
  14 use base qw(PVE::AbstractConfig);
  15
  16 my $nodename = PVE::INotify::nodename();
  17 my $lock_handles =  {};
  18 my $lockdir = "/run/lock/lxc";
  19 mkdir $lockdir;
  20 mkdir "/etc/pve/nodes/$nodename/lxc";
  21 my $MAX_MOUNT_POINTS = 256;
  22 my $MAX_UNUSED_DISKS = $MAX_MOUNT_POINTS;
  23
  24 # BEGIN implemented abstract methods from PVE::AbstractConfig
  25
  26 sub guest_type {
  27     return "CT";
  28 }
  29
  30 sub __config_max_unused_disks {
  31     my ($class) = @_;
  32
  33     return $MAX_UNUSED_DISKS;
  34 }
  35
  36 sub config_file_lock {
  37     my ($class, $vmid) = @_;
  38
  39     return "$lockdir/pve-config-${vmid}.lock";
  40 }
  41
  42 sub cfs_config_path {
  43     my ($class, $vmid, $node) = @_;
  44
  45     $node = $nodename if !$node;
  46     return "nodes/$node/lxc/$vmid.conf";
  47 }
  48
  49 sub mountpoint_backup_enabled {
  50     my ($class, $mp_key, $mountpoint) = @_;
  51
  52     my $enabled;
  53     my $reason;
  54
  55     if ($mp_key eq 'rootfs') {
  56         $enabled = 1;
  57         $reason = 'rootfs';
  58     } elsif ($mountpoint->{type} ne 'volume') {
  59         $enabled = 0;
  60         $reason = 'not a volume';
  61     } elsif ($mountpoint->{backup}) {
  62         $enabled = 1;
  63         $reason = 'enabled';
  64     } else {
  65         $enabled = 0;
  66         $reason = 'disabled';
  67     }
  68     return wantarray ? ($enabled, $reason) : $enabled;
  69 }
  70
  71 sub has_feature {
  72     my ($class, $feature, $conf, $storecfg, $snapname, $running, $backup_only) = @_;
  73     my $err;
  74
  75     my $opts;
  76     if ($feature eq 'copy' || $feature eq 'clone') {
  77         $opts = {'valid_target_formats' => ['raw', 'subvol']};
  78     }
  79
  80     $class->foreach_volume($conf, sub {
  81         my ($ms, $mountpoint) = @_;
  82
  83         return if $err; # skip further test
  84         return if $backup_only && !$class->mountpoint_backup_enabled($ms, $mountpoint);
  85
  86         $err = 1
  87             if !PVE::Storage::volume_has_feature($storecfg, $feature,
  88                                                  $mountpoint->{volume},
  89                                                  $snapname, $running, $opts);
  90     });
  91
  92     return $err ? 0 : 1;
  93 }
  94
  95 sub __snapshot_save_vmstate {
  96     my ($class, $vmid, $conf, $snapname, $storecfg) = @_;
  97     die "implement me - snapshot_save_vmstate\n";
  98 }
  99
 100 sub __snapshot_check_running {
 101     my ($class, $vmid) = @_;
 102     return PVE::LXC::check_running($vmid);
 103 }
 104
 105 sub __snapshot_check_freeze_needed {
 106     my ($class, $vmid, $config, $save_vmstate) = @_;
 107
 108     my $ret = $class->__snapshot_check_running($vmid);
 109     return ($ret, $ret);
 110 }
 111
 112 sub __snapshot_freeze {
 113     my ($class, $vmid, $unfreeze) = @_;
 114
 115     if ($unfreeze) {
 116         eval { PVE::LXC::thaw($vmid); };
 117         warn $@ if $@;
 118     } else {
 119         PVE::LXC::freeze($vmid);
 120         PVE::LXC::sync_container_namespace($vmid);
 121     }
 122 }
 123
 124 sub __snapshot_create_vol_snapshot {
 125     my ($class, $vmid, $ms, $mountpoint, $snapname) = @_;
 126
 127     my $storecfg = PVE::Storage::config();
 128
 129     return if $snapname eq 'vzdump' &&
 130         !$class->mountpoint_backup_enabled($ms, $mountpoint);
 131
 132     PVE::Storage::volume_snapshot($storecfg, $mountpoint->{volume}, $snapname);
 133 }
 134
 135 sub __snapshot_delete_remove_drive {
 136     my ($class, $snap, $remove_drive) = @_;
 137
 138     if ($remove_drive eq 'vmstate') {
 139         die "implement me - saving vmstate\n";
 140     } else {
 141         my $value = $snap->{$remove_drive};
 142         my $mountpoint = $class->parse_volume($remove_drive, $value, 1);
 143         delete $snap->{$remove_drive};
 144
 145         $class->add_unused_volume($snap, $mountpoint->{volume})
 146             if ($mountpoint->{type} eq 'volume');
 147     }
 148 }
 149
 150 sub __snapshot_delete_vmstate_file {
 151     my ($class, $snap, $force) = @_;
 152
 153     die "implement me - saving vmstate\n";
 154 }
 155
 156 sub __snapshot_delete_vol_snapshot {
 157     my ($class, $vmid, $ms, $mountpoint, $snapname, $unused) = @_;
 158
 159     return if $snapname eq 'vzdump' &&
 160         !$class->mountpoint_backup_enabled($ms, $mountpoint);
 161
 162     my $storecfg = PVE::Storage::config();
 163     PVE::Storage::volume_snapshot_delete($storecfg, $mountpoint->{volume}, $snapname);
 164     push @$unused, $mountpoint->{volume};
 165 }
 166
 167 sub __snapshot_rollback_vol_possible {
 168     my ($class, $mountpoint, $snapname) = @_;
 169
 170     my $storecfg = PVE::Storage::config();
 171     PVE::Storage::volume_rollback_is_possible($storecfg, $mountpoint->{volume}, $snapname);
 172 }
 173
 174 sub __snapshot_rollback_vol_rollback {
 175     my ($class, $mountpoint, $snapname) = @_;
 176
 177     my $storecfg = PVE::Storage::config();
 178     PVE::Storage::volume_snapshot_rollback($storecfg, $mountpoint->{volume}, $snapname);
 179 }
 180
 181 sub __snapshot_rollback_vm_stop {
 182     my ($class, $vmid) = @_;
 183
 184     PVE::LXC::vm_stop($vmid, 1)
 185         if $class->__snapshot_check_running($vmid);
 186 }
 187
 188 sub __snapshot_rollback_vm_start {
 189     my ($class, $vmid, $vmstate, $data);
 190
 191     die "implement me - save vmstate\n";
 192 }
 193
 194 sub __snapshot_rollback_get_unused {
 195     my ($class, $conf, $snap) = @_;
 196
 197     my $unused = [];
 198
 199     $class->foreach_volume($conf, sub {
 200         my ($vs, $volume) = @_;
 201
 202         return if $volume->{type} ne 'volume';
 203
 204         my $found = 0;
 205         my $volid = $volume->{volume};
 206
 207         $class->foreach_volume($snap, sub {
 208             my ($ms, $mountpoint) = @_;
 209
 210             return if $found;
 211             return if ($mountpoint->{type} ne 'volume');
 212
 213             $found = 1
 214                 if ($mountpoint->{volume} && $mountpoint->{volume} eq $volid);
 215         });
 216
 217         push @$unused, $volid if !$found;
 218     });
 219
 220     return $unused;
 221 }
 222
 223 # END implemented abstract methods from PVE::AbstractConfig
 224
 225 # BEGIN JSON config code
 226
 227 cfs_register_file('/lxc/', \&parse_pct_config, \&write_pct_config);
 228
 229
 230 my $valid_mount_option_re = qr/(noatime|nodev|nosuid|noexec)/;
 231
 232 sub is_valid_mount_option {
 233     my ($option) = @_;
 234     return $option =~ $valid_mount_option_re;
 235 }
 236
 237 my $rootfs_desc = {
 238     volume => {
 239         type => 'string',
 240         default_key => 1,
 241         format => 'pve-lxc-mp-string',
 242         format_description => 'volume',
 243         description => 'Volume, device or directory to mount into the container.',
 244     },
 245     size => {
 246         type => 'string',
 247         format => 'disk-size',
 248         format_description => 'DiskSize',
 249         description => 'Volume size (read only value).',
 250         optional => 1,
 251     },
 252     acl => {
 253         type => 'boolean',
 254         description => 'Explicitly enable or disable ACL support.',
 255         optional => 1,
 256     },
 257     mountoptions => {
 258         optional => 1,
 259         type => 'string',
 260         description => 'Extra mount options for rootfs/mps.',
 261         format_description => 'opt[;opt...]',
 262         pattern => qr/$valid_mount_option_re(;$valid_mount_option_re)*/,
 263     },
 264     ro => {
 265         type => 'boolean',
 266         description => 'Read-only mount point',
 267         optional => 1,
 268     },
 269     quota => {
 270         type => 'boolean',
 271         description => 'Enable user quotas inside the container (not supported with zfs subvolumes)',
 272         optional => 1,
 273     },
 274     replicate => {
 275         type => 'boolean',
 276         description => 'Will include this volume to a storage replica job.',
 277         optional => 1,
 278         default => 1,
 279     },
 280     shared => {
 281         type => 'boolean',
 282         description => 'Mark this non-volume mount point as available on multiple nodes (see \'nodes\')',
 283         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!",
 284         optional => 1,
 285         default => 0,
 286     },
 287 };
 288
 289 PVE::JSONSchema::register_standard_option('pve-ct-rootfs', {
 290     type => 'string', format => $rootfs_desc,
 291     description => "Use volume as container root.",
 292     optional => 1,
 293 });
 294
 295 my $features_desc = {
 296     mount => {
 297         optional => 1,
 298         type => 'string',
 299         description => "Allow mounting file systems of specific types."
 300             ." This should be a list of file system types as used with the mount command."
 301             ." Note that this can have negative effects on the container's security."
 302             ." With access to a loop device, mounting a file can circumvent the mknod"
 303             ." permission of the devices cgroup, mounting an NFS file system can"
 304             ." block the host's I/O completely and prevent it from rebooting, etc.",
 305         format_description => 'fstype;fstype;...',
 306         pattern => qr/[a-zA-Z0-9_; ]+/,
 307     },
 308     nesting => {
 309         optional => 1,
 310         type => 'boolean',
 311         default => 0,
 312         description => "Allow nesting."
 313             ." Best used with unprivileged containers with additional id mapping."
 314             ." Note that this will expose procfs and sysfs contents of the host"
 315             ." to the guest.",
 316     },
 317     keyctl => {
 318         optional => 1,
 319         type => 'boolean',
 320         default => 0,
 321         description => "For unprivileged containers only: Allow the use of the keyctl() system call."
 322             ." This is required to use docker inside a container."
 323             ." By default unprivileged containers will see this system call as non-existent."
 324             ." This is mostly a workaround for systemd-networkd, as it will treat it as a fatal"
 325             ." error when some keyctl() operations are denied by the kernel due to lacking permissions."
 326             ." Essentially, you can choose between running systemd-networkd or docker.",
 327     },
 328     fuse => {
 329         optional => 1,
 330         type => 'boolean',
 331         default => 0,
 332         description => "Allow using 'fuse' file systems in a container."
 333             ." Note that interactions between fuse and the freezer cgroup can potentially cause I/O deadlocks.",
 334     },
 335     mknod => {
 336         optional => 1,
 337         type => 'boolean',
 338         default => 0,
 339         description => "Allow unprivileged containers to use mknod() to add certain device nodes."
 340             ." This requires a kernel with seccomp trap to user space support (5.3 or newer)."
 341             ." This is experimental.",
 342     },
 343     force_rw_sys => {
 344         optional => 1,
 345         type => 'boolean',
 346         default => 0,
 347         description => "Mount /sys in unprivileged containers as `rw` instead of `mixed`."
 348             ." This can break networking under newer (>= v245) systemd-network use."
 349     },
 350 };
 351
 352 my $confdesc = {
 353     lock => {
 354         optional => 1,
 355         type => 'string',
 356         description => "Lock/unlock the VM.",
 357         enum => [qw(backup create destroyed disk fstrim migrate mounted rollback snapshot snapshot-delete)],
 358     },
 359     onboot => {
 360         optional => 1,
 361         type => 'boolean',
 362         description => "Specifies whether a VM will be started during system bootup.",
 363         default => 0,
 364     },
 365     startup => get_standard_option('pve-startup-order'),
 366     template => {
 367         optional => 1,
 368         type => 'boolean',
 369         description => "Enable/disable Template.",
 370         default => 0,
 371     },
 372     arch => {
 373         optional => 1,
 374         type => 'string',
 375         enum => ['amd64', 'i386', 'arm64', 'armhf'],
 376         description => "OS architecture type.",
 377         default => 'amd64',
 378     },
 379     ostype => {
 380         optional => 1,
 381         type => 'string',
 382         enum => [qw(debian ubuntu centos fedora opensuse archlinux alpine gentoo unmanaged)],
 383         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.",
 384     },
 385     console => {
 386         optional => 1,
 387         type => 'boolean',
 388         description => "Attach a console device (/dev/console) to the container.",
 389         default => 1,
 390     },
 391     tty => {
 392         optional => 1,
 393         type => 'integer',
 394         description => "Specify the number of tty available to the container",
 395         minimum => 0,
 396         maximum => 6,
 397         default => 2,
 398     },
 399     cores => {
 400         optional => 1,
 401         type => 'integer',
 402         description => "The number of cores assigned to the container. A container can use all available cores by default.",
 403         minimum => 1,
 404         maximum => 128,
 405     },
 406     cpulimit => {
 407         optional => 1,
 408         type => 'number',
 409         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.",
 410         minimum => 0,
 411         maximum => 128,
 412         default => 0,
 413     },
 414     cpuunits => {
 415         optional => 1,
 416         type => 'integer',
 417         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.",
 418         minimum => 0,
 419         maximum => 500000,
 420         default => 1024,
 421     },
 422     memory => {
 423         optional => 1,
 424         type => 'integer',
 425         description => "Amount of RAM for the VM in MB.",
 426         minimum => 16,
 427         default => 512,
 428     },
 429     swap => {
 430         optional => 1,
 431         type => 'integer',
 432         description => "Amount of SWAP for the VM in MB.",
 433         minimum => 0,
 434         default => 512,
 435     },
 436     hostname => {
 437         optional => 1,
 438         description => "Set a host name for the container.",
 439         type => 'string', format => 'dns-name',
 440         maxLength => 255,
 441     },
 442     description => {
 443         optional => 1,
 444         type => 'string',
 445         description => "Container description. Only used on the configuration web interface.",
 446     },
 447     searchdomain => {
 448         optional => 1,
 449         type => 'string', format => 'dns-name-list',
 450         description => "Sets DNS search domains for a container. Create will automatically use the setting from the host if you neither set searchdomain nor nameserver.",
 451     },
 452     nameserver => {
 453         optional => 1,
 454         type => 'string', format => 'address-list',
 455         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.",
 456     },
 457     timezone => {
 458         optional => 1,
 459         type => 'string', format => 'pve-ct-timezone',
 460         description => "Time zone to use in the container. If option isn't set, then nothing will be done. Can be set to 'host' to match the host time zone, or an arbitrary time zone option from /usr/share/zoneinfo/zone.tab",
 461     },
 462     rootfs => get_standard_option('pve-ct-rootfs'),
 463     parent => {
 464         optional => 1,
 465         type => 'string', format => 'pve-configid',
 466         maxLength => 40,
 467         description => "Parent snapshot name. This is used internally, and should not be modified.",
 468     },
 469     snaptime => {
 470         optional => 1,
 471         description => "Timestamp for snapshots.",
 472         type => 'integer',
 473         minimum => 0,
 474     },
 475     cmode => {
 476         optional => 1,
 477         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).",
 478         type => 'string',
 479         enum => ['shell', 'console', 'tty'],
 480         default => 'tty',
 481     },
 482     protection => {
 483         optional => 1,
 484         type => 'boolean',
 485         description => "Sets the protection flag of the container. This will prevent the CT or CT's disk remove/update operation.",
 486         default => 0,
 487     },
 488     unprivileged => {
 489         optional => 1,
 490         type => 'boolean',
 491         description => "Makes the container run as unprivileged user. (Should not be modified manually.)",
 492         default => 0,
 493     },
 494     features => {
 495         optional => 1,
 496         type => 'string',
 497         format => $features_desc,
 498         description => "Allow containers access to advanced features.",
 499     },
 500     hookscript => {
 501         optional => 1,
 502         type => 'string',
 503         format => 'pve-volume-id',
 504         description => 'Script that will be exectued during various steps in the containers lifetime.',
 505     },
 506     tags => {
 507         type => 'string', format => 'pve-tag-list',
 508         description => 'Tags of the Container. This is only meta information.',
 509         optional => 1,
 510     },
 511     debug => {
 512         optional => 1,
 513         type => 'boolean',
 514         description => "Try to be more verbose. For now this only enables debug log-level on start.",
 515         default => 0,
 516     },
 517 };
 518
 519 my $valid_lxc_conf_keys = {
 520     'lxc.apparmor.profile' => 1,
 521     'lxc.apparmor.allow_incomplete' => 1,
 522     'lxc.apparmor.allow_nesting' => 1,
 523     'lxc.apparmor.raw' => 1,
 524     'lxc.selinux.context' => 1,
 525     'lxc.include' => 1,
 526     'lxc.arch' => 1,
 527     'lxc.uts.name' => 1,
 528     'lxc.signal.halt' => 1,
 529     'lxc.signal.reboot' => 1,
 530     'lxc.signal.stop' => 1,
 531     'lxc.init.cmd' => 1,
 532     'lxc.pty.max' => 1,
 533     'lxc.console.logfile' => 1,
 534     'lxc.console.path' => 1,
 535     'lxc.tty.max' => 1,
 536     'lxc.devtty.dir' => 1,
 537     'lxc.hook.autodev' => 1,
 538     'lxc.autodev' => 1,
 539     'lxc.kmsg' => 1,
 540     'lxc.mount.fstab' => 1,
 541     'lxc.mount.entry' => 1,
 542     'lxc.mount.auto' => 1,
 543     'lxc.rootfs.path' => 'lxc.rootfs.path is auto generated from rootfs',
 544     'lxc.rootfs.mount' => 1,
 545     'lxc.rootfs.options' => 'lxc.rootfs.options is not supported' .
 546                             ', please use mount point options in the "rootfs" key',
 547     # lxc.cgroup.*
 548     # lxc.prlimit.*
 549     # lxc.net.*
 550     'lxc.cap.drop' => 1,
 551     'lxc.cap.keep' => 1,
 552     'lxc.seccomp.profile' => 1,
 553     'lxc.seccomp.notify.proxy' => 1,
 554     'lxc.seccomp.notify.cookie' => 1,
 555     'lxc.idmap' => 1,
 556     'lxc.hook.pre-start' => 1,
 557     'lxc.hook.pre-mount' => 1,
 558     'lxc.hook.mount' => 1,
 559     'lxc.hook.start' => 1,
 560     'lxc.hook.stop' => 1,
 561     'lxc.hook.post-stop' => 1,
 562     'lxc.hook.clone' => 1,
 563     'lxc.hook.destroy' => 1,
 564     'lxc.hook.version' => 1,
 565     'lxc.log.level' => 1,
 566     'lxc.log.file' => 1,
 567     'lxc.start.auto' => 1,
 568     'lxc.start.delay' => 1,
 569     'lxc.start.order' => 1,
 570     'lxc.group' => 1,
 571     'lxc.environment' => 1,
 572
 573     # All these are namespaced via CLONE_NEWIPC (see namespaces(7)).
 574     'lxc.sysctl.fs.mqueue' => 1,
 575     'lxc.sysctl.kernel.msgmax' => 1,
 576     'lxc.sysctl.kernel.msgmnb' => 1,
 577     'lxc.sysctl.kernel.msgmni' => 1,
 578     'lxc.sysctl.kernel.sem' => 1,
 579     'lxc.sysctl.kernel.shmall' => 1,
 580     'lxc.sysctl.kernel.shmmax' => 1,
 581     'lxc.sysctl.kernel.shmmni' => 1,
 582     'lxc.sysctl.kernel.shm_rmid_forced' => 1,
 583 };
 584
 585 my $deprecated_lxc_conf_keys = {
 586     # Deprecated (removed with lxc 3.0):
 587     'lxc.aa_profile'           => 'lxc.apparmor.profile',
 588     'lxc.aa_allow_incomplete'  => 'lxc.apparmor.allow_incomplete',
 589     'lxc.console'              => 'lxc.console.path',
 590     'lxc.devttydir'            => 'lxc.tty.dir',
 591     'lxc.haltsignal'           => 'lxc.signal.halt',
 592     'lxc.rebootsignal'         => 'lxc.signal.reboot',
 593     'lxc.stopsignal'           => 'lxc.signal.stop',
 594     'lxc.id_map'               => 'lxc.idmap',
 595     'lxc.init_cmd'             => 'lxc.init.cmd',
 596     'lxc.loglevel'             => 'lxc.log.level',
 597     'lxc.logfile'              => 'lxc.log.file',
 598     'lxc.mount'                => 'lxc.mount.fstab',
 599     'lxc.network.type'         => 'lxc.net.INDEX.type',
 600     'lxc.network.flags'        => 'lxc.net.INDEX.flags',
 601     'lxc.network.link'         => 'lxc.net.INDEX.link',
 602     'lxc.network.mtu'          => 'lxc.net.INDEX.mtu',
 603     'lxc.network.name'         => 'lxc.net.INDEX.name',
 604     'lxc.network.hwaddr'       => 'lxc.net.INDEX.hwaddr',
 605     'lxc.network.ipv4'         => 'lxc.net.INDEX.ipv4.address',
 606     'lxc.network.ipv4.gateway' => 'lxc.net.INDEX.ipv4.gateway',
 607     'lxc.network.ipv6'         => 'lxc.net.INDEX.ipv6.address',
 608     'lxc.network.ipv6.gateway' => 'lxc.net.INDEX.ipv6.gateway',
 609     'lxc.network.script.up'    => 'lxc.net.INDEX.script.up',
 610     'lxc.network.script.down'  => 'lxc.net.INDEX.script.down',
 611     'lxc.pts'                  => 'lxc.pty.max',
 612     'lxc.se_context'           => 'lxc.selinux.context',
 613     'lxc.seccomp'              => 'lxc.seccomp.profile',
 614     'lxc.tty'                  => 'lxc.tty.max',
 615     'lxc.utsname'              => 'lxc.uts.name',
 616 };
 617
 618 sub is_valid_lxc_conf_key {
 619     my ($vmid, $key) = @_;
 620     if ($key =~ /^lxc\.limit\./) {
 621         warn "vm $vmid - $key: lxc.limit.* was renamed to lxc.prlimit.*\n";
 622         return 1;
 623     }
 624     if (defined(my $new_name = $deprecated_lxc_conf_keys->{$key})) {
 625         warn "vm $vmid - $key is deprecated and was renamed to $new_name\n";
 626         return 1;
 627     }
 628     my $validity = $valid_lxc_conf_keys->{$key};
 629     return $validity if defined($validity);
 630     return 1 if $key =~ /^lxc\.cgroup2?\./  # allow all cgroup values
 631              || $key =~ /^lxc\.prlimit\./ # allow all prlimits
 632              || $key =~ /^lxc\.net\./;    # allow custom network definitions
 633     return 0;
 634 }
 635
 636 our $netconf_desc = {
 637     type => {
 638         type => 'string',
 639         optional => 1,
 640         description => "Network interface type.",
 641         enum => [qw(veth)],
 642     },
 643     name => {
 644         type => 'string',
 645         format_description => 'string',
 646         description => 'Name of the network device as seen from inside the container. (lxc.network.name)',
 647         pattern => '[-_.\w\d]+',
 648     },
 649     bridge => {
 650         type => 'string',
 651         format_description => 'bridge',
 652         description => 'Bridge to attach the network device to.',
 653         pattern => '[-_.\w\d]+',
 654         optional => 1,
 655     },
 656     hwaddr => get_standard_option('mac-addr', {
 657         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)',
 658         }),
 659     mtu => {
 660         type => 'integer',
 661         description => 'Maximum transfer unit of the interface. (lxc.network.mtu)',
 662         minimum => 64, # minimum ethernet frame is 64 bytes
 663         optional => 1,
 664     },
 665     ip => {
 666         type => 'string',
 667         format => 'pve-ipv4-config',
 668         format_description => '(IPv4/CIDR|dhcp|manual)',
 669         description => 'IPv4 address in CIDR format.',
 670         optional => 1,
 671     },
 672     gw => {
 673         type => 'string',
 674         format => 'ipv4',
 675         format_description => 'GatewayIPv4',
 676         description => 'Default gateway for IPv4 traffic.',
 677         optional => 1,
 678     },
 679     ip6 => {
 680         type => 'string',
 681         format => 'pve-ipv6-config',
 682         format_description => '(IPv6/CIDR|auto|dhcp|manual)',
 683         description => 'IPv6 address in CIDR format.',
 684         optional => 1,
 685     },
 686     gw6 => {
 687         type => 'string',
 688         format => 'ipv6',
 689         format_description => 'GatewayIPv6',
 690         description => 'Default gateway for IPv6 traffic.',
 691         optional => 1,
 692     },
 693     firewall => {
 694         type => 'boolean',
 695         description => "Controls whether this interface's firewall rules should be used.",
 696         optional => 1,
 697     },
 698     tag => {
 699         type => 'integer',
 700         minimum => 1,
 701         maximum => 4094,
 702         description => "VLAN tag for this interface.",
 703         optional => 1,
 704     },
 705     trunks => {
 706         type => 'string',
 707         pattern => qr/\d+(?:;\d+)*/,
 708         format_description => 'vlanid[;vlanid...]',
 709         description => "VLAN ids to pass through the interface",
 710         optional => 1,
 711     },
 712     rate => {
 713         type => 'number',
 714         format_description => 'mbps',
 715         description => "Apply rate limiting to the interface",
 716         optional => 1,
 717     },
 718 };
 719 PVE::JSONSchema::register_format('pve-lxc-network', $netconf_desc);
 720
 721 my $MAX_LXC_NETWORKS = 32;
 722 for (my $i = 0; $i < $MAX_LXC_NETWORKS; $i++) {
 723     $confdesc->{"net$i"} = {
 724         optional => 1,
 725         type => 'string', format => $netconf_desc,
 726         description => "Specifies network interfaces for the container.",
 727     };
 728 }
 729
 730 PVE::JSONSchema::register_format('pve-ct-timezone', \&verify_ct_timezone);
 731 sub verify_ct_timezone {
 732     my ($timezone, $noerr) = @_;
 733
 734     return if $timezone eq 'host'; # using host settings
 735
 736     PVE::JSONSchema::pve_verify_timezone($timezone);
 737 }
 738
 739 PVE::JSONSchema::register_format('pve-lxc-mp-string', \&verify_lxc_mp_string);
 740 sub verify_lxc_mp_string {
 741     my ($mp, $noerr) = @_;
 742
 743     # do not allow:
 744     # /./ or /../
 745     # /. or /.. at the end
 746     # ../ at the beginning
 747
 748     if($mp =~ m@/\.\.?/@ ||
 749        $mp =~ m@/\.\.?$@ ||
 750        $mp =~ m@^\.\./@) {
 751         return undef if $noerr;
 752         die "$mp contains illegal character sequences\n";
 753     }
 754     return $mp;
 755 }
 756
 757 my $mp_desc = {
 758     %$rootfs_desc,
 759     backup => {
 760         type => 'boolean',
 761         description => 'Whether to include the mount point in backups.',
 762         verbose_description => 'Whether to include the mount point in backups '.
 763                                '(only used for volume mount points).',
 764         optional => 1,
 765     },
 766     mp => {
 767         type => 'string',
 768         format => 'pve-lxc-mp-string',
 769         format_description => 'Path',
 770         description => 'Path to the mount point as seen from inside the container '.
 771                        '(must not contain symlinks).',
 772         verbose_description => "Path to the mount point as seen from inside the container.\n\n".
 773                                "NOTE: Must not contain any symlinks for security reasons."
 774     },
 775 };
 776 PVE::JSONSchema::register_format('pve-ct-mountpoint', $mp_desc);
 777
 778 my $unused_desc = {
 779     volume => {
 780         type => 'string',
 781         default_key => 1,
 782         format => 'pve-volume-id',
 783         format_description => 'volume',
 784         description => 'The volume that is not used currently.',
 785     }
 786 };
 787
 788 for (my $i = 0; $i < $MAX_MOUNT_POINTS; $i++) {
 789     $confdesc->{"mp$i"} = {
 790         optional => 1,
 791         type => 'string', format => $mp_desc,
 792         description => "Use volume as container mount point.",
 793         optional => 1,
 794     };
 795 }
 796
 797 for (my $i = 0; $i < $MAX_UNUSED_DISKS; $i++) {
 798     $confdesc->{"unused$i"} = {
 799         optional => 1,
 800         type => 'string', format => $unused_desc,
 801         description => "Reference to unused volumes. This is used internally, and should not be modified manually.",
 802     }
 803 }
 804
 805 sub parse_pct_config {
 806     my ($filename, $raw) = @_;
 807
 808     return undef if !defined($raw);
 809
 810     my $res = {
 811         digest => Digest::SHA::sha1_hex($raw),
 812         snapshots => {},
 813         pending => {},
 814     };
 815
 816     $filename =~ m|/lxc/(\d+).conf$|
 817         || die "got strange filename '$filename'";
 818
 819     my $vmid = $1;
 820
 821     my $conf = $res;
 822     my $descr = '';
 823     my $section = '';
 824
 825     my @lines = split(/\n/, $raw);
 826     foreach my $line (@lines) {
 827         next if $line =~ m/^\s*$/;
 828
 829         if ($line =~ m/^\[pve:pending\]\s*$/i) {
 830             $section = 'pending';
 831             $conf->{description} = $descr if $descr;
 832             $descr = '';
 833             $conf = $res->{$section} = {};
 834             next;
 835         } elsif ($line =~ m/^\[([a-z][a-z0-9_\-]+)\]\s*$/i) {
 836             $section = $1;
 837             $conf->{description} = $descr if $descr;
 838             $descr = '';
 839             $conf = $res->{snapshots}->{$section} = {};
 840             next;
 841         }
 842
 843         if ($line =~ m/^\#(.*)\s*$/) {
 844             $descr .= PVE::Tools::decode_text($1) . "\n";
 845             next;
 846         }
 847
 848         if ($line =~ m/^(lxc\.[a-z0-9_\-\.]+)(:|\s*=)\s*(.*?)\s*$/) {
 849             my $key = $1;
 850             my $value = $3;
 851             my $validity = is_valid_lxc_conf_key($vmid, $key);
 852             if ($validity eq 1) {
 853                 push @{$conf->{lxc}}, [$key, $value];
 854             } elsif (my $errmsg = $validity) {
 855                 warn "vm $vmid - $key: $errmsg\n";
 856             } else {
 857                 warn "vm $vmid - unable to parse config: $line\n";
 858             }
 859         } elsif ($line =~ m/^(description):\s*(.*\S)\s*$/) {
 860             $descr .= PVE::Tools::decode_text($2);
 861         } elsif ($line =~ m/snapstate:\s*(prepare|delete)\s*$/) {
 862             $conf->{snapstate} = $1;
 863         } elsif ($line =~ m/^delete:\s*(.*\S)\s*$/) {
 864             my $value = $1;
 865             if ($section eq 'pending') {
 866                 $conf->{delete} = $value;
 867             } else {
 868                 warn "vm $vmid - property 'delete' is only allowed in [pve:pending]\n";
 869             }
 870         } elsif ($line =~ m/^([a-z][a-z_]*\d*):\s*(\S.*)\s*$/) {
 871             my $key = $1;
 872             my $value = $2;
 873             eval { $value = PVE::LXC::Config->check_type($key, $value); };
 874             warn "vm $vmid - unable to parse value of '$key' - $@" if $@;
 875             $conf->{$key} = $value;
 876         } else {
 877             warn "vm $vmid - unable to parse config: $line\n";
 878         }
 879     }
 880
 881     $conf->{description} = $descr if $descr;
 882
 883     delete $res->{snapstate}; # just to be sure
 884
 885     return $res;
 886 }
 887
 888 sub write_pct_config {
 889     my ($filename, $conf) = @_;
 890
 891     delete $conf->{snapstate}; # just to be sure
 892
 893     my $volidlist = PVE::LXC::Config->get_vm_volumes($conf);
 894     my $used_volids = {};
 895     foreach my $vid (@$volidlist) {
 896         $used_volids->{$vid} = 1;
 897     }
 898
 899     # remove 'unusedX' settings if the volume is still used
 900     foreach my $key (keys %$conf) {
 901         my $value = $conf->{$key};
 902         if ($key =~ m/^unused/ && $used_volids->{$value}) {
 903             delete $conf->{$key};
 904         }
 905     }
 906
 907     my $generate_raw_config = sub {
 908         my ($conf) = @_;
 909
 910         my $raw = '';
 911
 912         # add description as comment to top of file
 913         my $descr = $conf->{description} || '';
 914         foreach my $cl (split(/\n/, $descr)) {
 915             $raw .= '#' . PVE::Tools::encode_text($cl) . "\n";
 916         }
 917
 918         foreach my $key (sort keys %$conf) {
 919             next if $key eq 'digest' || $key eq 'description' ||
 920                     $key eq 'pending' || $key eq 'snapshots' ||
 921                     $key eq 'snapname' || $key eq 'lxc';
 922             my $value = $conf->{$key};
 923             die "detected invalid newline inside property '$key'\n"
 924                 if $value =~ m/\n/;
 925             $raw .= "$key: $value\n";
 926         }
 927
 928         if (my $lxcconf = $conf->{lxc}) {
 929             foreach my $entry (@$lxcconf) {
 930                 my ($k, $v) = @$entry;
 931                 $raw .= "$k: $v\n";
 932             }
 933         }
 934
 935         return $raw;
 936     };
 937
 938     my $raw = &$generate_raw_config($conf);
 939
 940     if (scalar(keys %{$conf->{pending}})){
 941         $raw .= "\n[pve:pending]\n";
 942         $raw .= &$generate_raw_config($conf->{pending});
 943     }
 944
 945     foreach my $snapname (sort keys %{$conf->{snapshots}}) {
 946         $raw .= "\n[$snapname]\n";
 947         $raw .= &$generate_raw_config($conf->{snapshots}->{$snapname});
 948     }
 949
 950     return $raw;
 951 }
 952
 953 sub update_pct_config {
 954     my ($class, $vmid, $conf, $running, $param, $delete, $revert) = @_;
 955
 956     my $storage_cfg = PVE::Storage::config();
 957
 958     foreach my $opt (@$revert) {
 959         delete $conf->{pending}->{$opt};
 960         $class->remove_from_pending_delete($conf, $opt); # also remove from deletion queue
 961     }
 962
 963     # write updates to pending section
 964     my $modified = {}; # record modified options
 965
 966     foreach my $opt (@$delete) {
 967         if (!defined($conf->{$opt}) && !defined($conf->{pending}->{$opt})) {
 968             warn "cannot delete '$opt' - not set in current configuration!\n";
 969             next;
 970         }
 971         $modified->{$opt} = 1;
 972         if ($opt eq 'memory' || $opt eq 'rootfs' || $opt eq 'ostype') {
 973             die "unable to delete required option '$opt'\n";
 974         } elsif ($opt =~ m/^unused(\d+)$/) {
 975             $class->check_protection($conf, "can't remove CT $vmid drive '$opt'");
 976         } elsif ($opt =~ m/^mp(\d+)$/) {
 977             $class->check_protection($conf, "can't remove CT $vmid drive '$opt'");
 978         } elsif ($opt eq 'unprivileged') {
 979             die "unable to delete read-only option: '$opt'\n";
 980         }
 981         $class->add_to_pending_delete($conf, $opt);
 982     }
 983
 984     my $check_content_type = sub {
 985         my ($mp) = @_;
 986         my $sid = PVE::Storage::parse_volume_id($mp->{volume});
 987         my $storage_config = PVE::Storage::storage_config($storage_cfg, $sid);
 988         die "storage '$sid' does not allow content type 'rootdir' (Container)\n"
 989             if !$storage_config->{content}->{rootdir};
 990     };
 991
 992     foreach my $opt (sort keys %$param) { # add/change
 993         $modified->{$opt} = 1;
 994         my $value = $param->{$opt};
 995         if ($opt =~ m/^mp(\d+)$/ || $opt eq 'rootfs') {
 996             $class->check_protection($conf, "can't update CT $vmid drive '$opt'");
 997             my $mp = $class->parse_volume($opt, $value);
 998             $check_content_type->($mp) if ($mp->{type} eq 'volume');
 999         } elsif ($opt eq 'hookscript') {
1000             PVE::GuestHelpers::check_hookscript($value);
1001         } elsif ($opt eq 'nameserver') {
1002             $value = PVE::LXC::verify_nameserver_list($value);
1003         } elsif ($opt eq 'searchdomain') {
1004             $value = PVE::LXC::verify_searchdomain_list($value);
1005         } elsif ($opt eq 'unprivileged') {
1006             die "unable to modify read-only option: '$opt'\n";
1007         }
1008         $conf->{pending}->{$opt} = $value;
1009         $class->remove_from_pending_delete($conf, $opt);
1010     }
1011
1012     my $changes = $class->cleanup_pending($conf);
1013
1014     my $errors = {};
1015     if ($running) {
1016         $class->vmconfig_hotplug_pending($vmid, $conf, $storage_cfg, $modified, $errors);
1017     } else {
1018         $class->vmconfig_apply_pending($vmid, $conf, $storage_cfg, $modified, $errors);
1019     }
1020
1021     return $errors;
1022 }
1023
1024 sub check_type {
1025     my ($class, $key, $value) = @_;
1026
1027     die "unknown setting '$key'\n" if !$confdesc->{$key};
1028
1029     my $type = $confdesc->{$key}->{type};
1030
1031     if (!defined($value)) {
1032         die "got undefined value\n";
1033     }
1034
1035     if ($value =~ m/[\n\r]/) {
1036         die "property contains a line feed\n";
1037     }
1038
1039     if ($type eq 'boolean') {
1040         return 1 if ($value eq '1') || ($value =~ m/^(on|yes|true)$/i);
1041         return 0 if ($value eq '0') || ($value =~ m/^(off|no|false)$/i);
1042         die "type check ('boolean') failed - got '$value'\n";
1043     } elsif ($type eq 'integer') {
1044         return int($1) if $value =~ m/^(\d+)$/;
1045         die "type check ('integer') failed - got '$value'\n";
1046     } elsif ($type eq 'number') {
1047         return $value if $value =~ m/^(\d+)(\.\d+)?$/;
1048         die "type check ('number') failed - got '$value'\n";
1049     } elsif ($type eq 'string') {
1050         if (my $fmt = $confdesc->{$key}->{format}) {
1051             PVE::JSONSchema::check_format($fmt, $value);
1052             return $value;
1053         }
1054         return $value;
1055     } else {
1056         die "internal error"
1057     }
1058 }
1059
1060
1061 # add JSON properties for create and set function
1062 sub json_config_properties {
1063     my ($class, $prop) = @_;
1064
1065     foreach my $opt (keys %$confdesc) {
1066         next if $opt eq 'parent' || $opt eq 'snaptime';
1067         next if $prop->{$opt};
1068         $prop->{$opt} = $confdesc->{$opt};
1069     }
1070
1071     return $prop;
1072 }
1073
1074 my $parse_ct_mountpoint_full = sub {
1075     my ($class, $desc, $data, $noerr) = @_;
1076
1077     $data //= '';
1078
1079     my $res;
1080     eval { $res = PVE::JSONSchema::parse_property_string($desc, $data) };
1081     if ($@) {
1082         return undef if $noerr;
1083         die $@;
1084     }
1085
1086     if (defined(my $size = $res->{size})) {
1087         $size = PVE::JSONSchema::parse_size($size);
1088         if (!defined($size)) {
1089             return undef if $noerr;
1090             die "invalid size: $size\n";
1091         }
1092         $res->{size} = $size;
1093     }
1094
1095     $res->{type} = $class->classify_mountpoint($res->{volume});
1096
1097     return $res;
1098 };
1099
1100 sub print_ct_mountpoint {
1101     my ($class, $info, $nomp) = @_;
1102     my $skip = [ 'type' ];
1103     push @$skip, 'mp' if $nomp;
1104     return PVE::JSONSchema::print_property_string($info, $mp_desc, $skip);
1105 }
1106
1107 sub parse_volume {
1108     my ($class, $key, $volume_string, $noerr) = @_;
1109
1110     if ($key eq 'rootfs') {
1111         my $res =  $parse_ct_mountpoint_full->($class, $rootfs_desc, $volume_string, $noerr);
1112         $res->{mp} = '/' if defined($res);
1113         return $res;
1114     } elsif ($key =~ m/^mp\d+$/) {
1115         return $parse_ct_mountpoint_full->($class, $mp_desc, $volume_string, $noerr);
1116     } elsif ($key =~ m/^unused\d+$/) {
1117         return $parse_ct_mountpoint_full->($class, $unused_desc, $volume_string, $noerr);
1118     }
1119
1120     die "parse_volume - unknown type: $key\n";
1121 }
1122
1123 sub print_volume {
1124     my ($class, $key, $volume) = @_;
1125
1126     return $class->print_ct_mountpoint($volume, $key eq 'rootfs');
1127 }
1128
1129 sub volid_key {
1130     my ($class) = @_;
1131
1132     return 'volume';
1133 }
1134
1135 sub print_lxc_network {
1136     my ($class, $net) = @_;
1137     return PVE::JSONSchema::print_property_string($net, $netconf_desc);
1138 }
1139
1140 sub parse_lxc_network {
1141     my ($class, $data) = @_;
1142
1143     my $res = {};
1144
1145     return $res if !$data;
1146
1147     $res = PVE::JSONSchema::parse_property_string($netconf_desc, $data);
1148
1149     $res->{type} = 'veth';
1150     if (!$res->{hwaddr}) {
1151         my $dc = PVE::Cluster::cfs_read_file('datacenter.cfg');
1152         $res->{hwaddr} = PVE::Tools::random_ether_addr($dc->{mac_prefix});
1153     }
1154
1155     return $res;
1156 }
1157
1158 sub parse_features {
1159     my ($class, $data) = @_;
1160     return {} if !$data;
1161     return PVE::JSONSchema::parse_property_string($features_desc, $data);
1162 }
1163
1164 sub option_exists {
1165     my ($class, $name) = @_;
1166
1167     return defined($confdesc->{$name});
1168 }
1169 # END JSON config code
1170
1171 my $LXC_FASTPLUG_OPTIONS= {
1172     'description' => 1,
1173     'onboot' => 1,
1174     'startup' => 1,
1175     'protection' => 1,
1176     'hostname' => 1,
1177     'hookscript' => 1,
1178     'cores' => 1,
1179     'tags' => 1,
1180     'lock' => 1,
1181 };
1182
1183 sub vmconfig_hotplug_pending {
1184     my ($class, $vmid, $conf, $storecfg, $selection, $errors) = @_;
1185
1186     my $pid = PVE::LXC::find_lxc_pid($vmid);
1187     my $rootdir = "/proc/$pid/root";
1188
1189     my $add_hotplug_error = sub {
1190         my ($opt, $msg) = @_;
1191         $errors->{$opt} = "unable to hotplug $opt: $msg";
1192     };
1193
1194     foreach my $opt (sort keys %{$conf->{pending}}) { # add/change
1195         next if $selection && !$selection->{$opt};
1196         if ($LXC_FASTPLUG_OPTIONS->{$opt}) {
1197             $conf->{$opt} = delete $conf->{pending}->{$opt};
1198         }
1199     }
1200
1201     my $cgroup = PVE::LXC::CGroup->new($vmid);
1202
1203     # There's no separate swap size to configure, there's memory and "total"
1204     # memory (iow. memory+swap). This means we have to change them together.
1205     my $hotplug_memory_done;
1206     my $hotplug_memory = sub {
1207         my ($wanted_memory, $wanted_swap) = @_;
1208
1209         $wanted_memory = int($wanted_memory * 1024 * 1024) if defined($wanted_memory);
1210         $wanted_swap = int($wanted_swap * 1024 * 1024) if defined($wanted_swap);
1211         $cgroup->change_memory_limit($wanted_memory, $wanted_swap);
1212
1213         $hotplug_memory_done = 1;
1214     };
1215
1216     my $pending_delete_hash = $class->parse_pending_delete($conf->{pending}->{delete});
1217     # FIXME: $force deletion is not implemented for CTs
1218     foreach my $opt (sort keys %$pending_delete_hash) {
1219         next if $selection && !$selection->{$opt};
1220         eval {
1221             if ($LXC_FASTPLUG_OPTIONS->{$opt}) {
1222                 # pass
1223             } elsif ($opt =~ m/^unused(\d+)$/) {
1224                 PVE::LXC::delete_mountpoint_volume($storecfg, $vmid, $conf->{$opt})
1225                     if !$class->is_volume_in_use($conf, $conf->{$opt}, 1, 1);
1226             } elsif ($opt eq 'swap') {
1227                 $hotplug_memory->(undef, 0);
1228             } elsif ($opt eq 'cpulimit') {
1229                 $cgroup->change_cpu_quota(-1, 100000);
1230             } elsif ($opt eq 'cpuunits') {
1231                 $cgroup->change_cpu_shares(undef, $confdesc->{cpuunits}->{default});
1232             } elsif ($opt =~ m/^net(\d)$/) {
1233                 my $netid = $1;
1234                 PVE::Network::veth_delete("veth${vmid}i$netid");
1235             } else {
1236                 die "skip\n"; # skip non-hotpluggable opts
1237             }
1238         };
1239         if (my $err = $@) {
1240             $add_hotplug_error->($opt, $err) if $err ne "skip\n";
1241         } else {
1242             delete $conf->{$opt};
1243             $class->remove_from_pending_delete($conf, $opt);
1244         }
1245     }
1246
1247     foreach my $opt (sort keys %{$conf->{pending}}) {
1248         next if $opt eq 'delete'; # just to be sure
1249         next if $selection && !$selection->{$opt};
1250         my $value = $conf->{pending}->{$opt};
1251         eval {
1252             if ($opt eq 'cpulimit') {
1253                 my $quota = 100000 * $value;
1254                 $cgroup->change_cpu_quota(int(100000 * $value), 100000);
1255             } elsif ($opt eq 'cpuunits') {
1256                 $cgroup->change_cpu_shares($value, $confdesc->{cpuunits}->{default});
1257             } elsif ($opt =~ m/^net(\d+)$/) {
1258                 my $netid = $1;
1259                 my $net = $class->parse_lxc_network($value);
1260                 $value = $class->print_lxc_network($net);
1261                 PVE::LXC::update_net($vmid, $conf, $opt, $net, $netid, $rootdir);
1262             } elsif ($opt eq 'memory' || $opt eq 'swap') {
1263                 if (!$hotplug_memory_done) { # don't call twice if both opts are passed
1264                     $hotplug_memory->($conf->{pending}->{memory}, $conf->{pending}->{swap});
1265                 }
1266             } elsif ($opt =~ m/^mp(\d+)$/) {
1267                 if (!PVE::LXC::Tools::can_use_new_mount_api()) {
1268                     die "skip\n";
1269                 }
1270
1271                 if (exists($conf->{$opt})) {
1272                     die "skip\n"; # don't try to hotplug over existing mp
1273                 }
1274
1275                 $class->apply_pending_mountpoint($vmid, $conf, $opt, $storecfg, 1);
1276                 # apply_pending_mountpoint modifies the value if it creates a new disk
1277                 $value = $conf->{pending}->{$opt};
1278             } else {
1279                 die "skip\n"; # skip non-hotpluggable
1280             }
1281         };
1282         if (my $err = $@) {
1283             $add_hotplug_error->($opt, $err) if $err ne "skip\n";
1284         } else {
1285             $conf->{$opt} = $value;
1286             delete $conf->{pending}->{$opt};
1287         }
1288     }
1289 }
1290
1291 sub vmconfig_apply_pending {
1292     my ($class, $vmid, $conf, $storecfg, $selection, $errors) = @_;
1293
1294     my $add_apply_error = sub {
1295         my ($opt, $msg) = @_;
1296         my $err_msg = "unable to apply pending change $opt : $msg";
1297         $errors->{$opt} = $err_msg;
1298         warn $err_msg;
1299     };
1300
1301     my $pending_delete_hash = $class->parse_pending_delete($conf->{pending}->{delete});
1302     # FIXME: $force deletion is not implemented for CTs
1303     foreach my $opt (sort keys %$pending_delete_hash) {
1304         next if $selection && !$selection->{$opt};
1305         eval {
1306             if ($opt =~ m/^mp(\d+)$/) {
1307                 my $mp = $class->parse_volume($opt, $conf->{$opt});
1308                 if ($mp->{type} eq 'volume') {
1309                     $class->add_unused_volume($conf, $mp->{volume})
1310                         if !$class->is_volume_in_use($conf, $conf->{$opt}, 1, 1);
1311                 }
1312             } elsif ($opt =~ m/^unused(\d+)$/) {
1313                 PVE::LXC::delete_mountpoint_volume($storecfg, $vmid, $conf->{$opt})
1314                     if !$class->is_volume_in_use($conf, $conf->{$opt}, 1, 1);
1315             }
1316         };
1317         if (my $err = $@) {
1318             $add_apply_error->($opt, $err);
1319         } else {
1320             delete $conf->{$opt};
1321             $class->remove_from_pending_delete($conf, $opt);
1322         }
1323     }
1324
1325     $class->cleanup_pending($conf);
1326
1327     foreach my $opt (sort keys %{$conf->{pending}}) { # add/change
1328         next if $opt eq 'delete'; # just to be sure
1329         next if $selection && !$selection->{$opt};
1330         eval {
1331             if ($opt =~ m/^mp(\d+)$/) {
1332                 $class->apply_pending_mountpoint($vmid, $conf, $opt, $storecfg, 0);
1333             } elsif ($opt =~ m/^net(\d+)$/) {
1334                 my $netid = $1;
1335                 my $net = $class->parse_lxc_network($conf->{pending}->{$opt});
1336                 $conf->{pending}->{$opt} = $class->print_lxc_network($net);
1337             }
1338         };
1339         if (my $err = $@) {
1340             $add_apply_error->($opt, $err);
1341         } else {
1342             $conf->{$opt} = delete $conf->{pending}->{$opt};
1343         }
1344     }
1345 }
1346
1347 my $rescan_volume = sub {
1348     my ($storecfg, $mp) = @_;
1349     eval {
1350         $mp->{size} = PVE::Storage::volume_size_info($storecfg, $mp->{volume}, 5);
1351     };
1352     warn "Could not rescan volume size - $@\n" if $@;
1353 };
1354
1355 sub apply_pending_mountpoint {
1356     my ($class, $vmid, $conf, $opt, $storecfg, $running) = @_;
1357
1358     my $mp = $class->parse_volume($opt, $conf->{pending}->{$opt});
1359     my $old = $conf->{$opt};
1360     if ($mp->{type} eq 'volume') {
1361         if ($mp->{volume} =~ $PVE::LXC::NEW_DISK_RE) {
1362             my $original_value = $conf->{pending}->{$opt};
1363             my $vollist = PVE::LXC::create_disks(
1364                 $storecfg,
1365                 $vmid,
1366                 { $opt => $original_value },
1367                 $conf,
1368                 1,
1369             );
1370             if ($running) {
1371                 # Re-parse mount point:
1372                 my $mp = $class->parse_volume($opt, $conf->{pending}->{$opt});
1373                 eval {
1374                     PVE::LXC::mountpoint_hotplug($vmid, $conf, $opt, $mp, $storecfg);
1375                 };
1376                 my $err = $@;
1377                 if ($err) {
1378                     PVE::LXC::destroy_disks($storecfg, $vollist);
1379                     # The pending-changes code collects errors but keeps on looping through further
1380                     # pending changes, so unroll the change in $conf as well if destroy_disks()
1381                     # didn't die().
1382                     $conf->{pending}->{$opt} = $original_value;
1383                     die $err;
1384                 }
1385             }
1386         } else {
1387             die "skip\n" if $running && defined($old); # TODO: "changing" mount points?
1388             $rescan_volume->($storecfg, $mp);
1389             if ($running) {
1390                 PVE::LXC::mountpoint_hotplug($vmid, $conf, $opt, $mp, $storecfg);
1391             }
1392             $conf->{pending}->{$opt} = $class->print_ct_mountpoint($mp);
1393         }
1394     }
1395
1396     if (defined($old)) {
1397         my $mp = $class->parse_volume($opt, $old);
1398         if ($mp->{type} eq 'volume') {
1399             $class->add_unused_volume($conf, $mp->{volume})
1400                 if !$class->is_volume_in_use($conf, $conf->{$opt}, 1, 1);
1401         }
1402     }
1403 }
1404
1405 sub classify_mountpoint {
1406     my ($class, $vol) = @_;
1407     if ($vol =~ m!^/!) {
1408         return 'device' if $vol =~ m!^/dev/!;
1409         return 'bind';
1410     }
1411     return 'volume';
1412 }
1413
1414 my $__is_volume_in_use = sub {
1415     my ($class, $config, $volid) = @_;
1416     my $used = 0;
1417
1418     $class->foreach_volume($config, sub {
1419         my ($ms, $mountpoint) = @_;
1420         return if $used;
1421         $used = $mountpoint->{type} eq 'volume' && $mountpoint->{volume} eq $volid;
1422     });
1423
1424     return $used;
1425 };
1426
1427 sub is_volume_in_use_by_snapshots {
1428     my ($class, $config, $volid) = @_;
1429
1430     if (my $snapshots = $config->{snapshots}) {
1431         foreach my $snap (keys %$snapshots) {
1432             return 1 if $__is_volume_in_use->($class, $snapshots->{$snap}, $volid);
1433         }
1434     }
1435
1436     return 0;
1437 }
1438
1439 sub is_volume_in_use {
1440     my ($class, $config, $volid, $include_snapshots, $include_pending) = @_;
1441     return 1 if $__is_volume_in_use->($class, $config, $volid);
1442     return 1 if $include_snapshots && $class->is_volume_in_use_by_snapshots($config, $volid);
1443     return 1 if $include_pending && $__is_volume_in_use->($class, $config->{pending}, $volid);
1444     return 0;
1445 }
1446
1447 sub has_dev_console {
1448     my ($class, $conf) = @_;
1449
1450     return !(defined($conf->{console}) && !$conf->{console});
1451 }
1452
1453 sub has_lxc_entry {
1454     my ($class, $conf, $keyname) = @_;
1455
1456     if (my $lxcconf = $conf->{lxc}) {
1457         foreach my $entry (@$lxcconf) {
1458             my ($key, undef) = @$entry;
1459             return 1 if $key eq $keyname;
1460         }
1461     }
1462
1463     return 0;
1464 }
1465
1466 sub get_tty_count {
1467     my ($class, $conf) = @_;
1468
1469     return $conf->{tty} // $confdesc->{tty}->{default};
1470 }
1471
1472 sub get_cmode {
1473     my ($class, $conf) = @_;
1474
1475     return $conf->{cmode} // $confdesc->{cmode}->{default};
1476 }
1477
1478 sub valid_volume_keys {
1479     my ($class, $reverse) = @_;
1480
1481     my @names = ('rootfs');
1482
1483     for (my $i = 0; $i < $MAX_MOUNT_POINTS; $i++) {
1484         push @names, "mp$i";
1485     }
1486
1487     return $reverse ? reverse @names : @names;
1488 }
1489
1490 sub get_vm_volumes {
1491     my ($class, $conf, $excludes) = @_;
1492
1493     my $vollist = [];
1494
1495     $class->foreach_volume($conf, sub {
1496         my ($ms, $mountpoint) = @_;
1497
1498         return if $excludes && $ms eq $excludes;
1499
1500         my $volid = $mountpoint->{volume};
1501         return if !$volid || $mountpoint->{type} ne 'volume';
1502
1503         my ($sid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
1504         return if !$sid;
1505
1506         push @$vollist, $volid;
1507     });
1508
1509     return $vollist;
1510 }
1511
1512 sub get_replicatable_volumes {
1513     my ($class, $storecfg, $vmid, $conf, $cleanup, $noerr) = @_;
1514
1515     my $volhash = {};
1516
1517     my $test_volid = sub {
1518         my ($volid, $mountpoint) = @_;
1519
1520         return if !$volid;
1521
1522         my $mptype = $mountpoint->{type};
1523         my $replicate = $mountpoint->{replicate} // 1;
1524
1525         if ($mptype ne 'volume') {
1526             # skip bindmounts if replicate = 0 even for cleanup,
1527             # since bind mounts could not have been replicated ever
1528             return if !$replicate;
1529             die "unable to replicate mountpoint type '$mptype'\n";
1530         }
1531
1532         my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, $noerr);
1533         return if !$storeid;
1534
1535         my $scfg = PVE::Storage::storage_config($storecfg, $storeid);
1536         return if $scfg->{shared};
1537
1538         my ($path, $owner, $vtype) = PVE::Storage::path($storecfg, $volid);
1539         return if !$owner || ($owner != $vmid);
1540
1541         die "unable to replicate volume '$volid', type '$vtype'\n" if $vtype ne 'images';
1542
1543         return if !$cleanup && !$replicate;
1544
1545         if (!PVE::Storage::volume_has_feature($storecfg, 'replicate', $volid)) {
1546             return if $cleanup || $noerr;
1547             die "missing replicate feature on volume '$volid'\n";
1548         }
1549
1550         $volhash->{$volid} = 1;
1551     };
1552
1553     $class->foreach_volume($conf, sub {
1554         my ($ms, $mountpoint) = @_;
1555         $test_volid->($mountpoint->{volume}, $mountpoint);
1556     });
1557
1558     foreach my $snapname (keys %{$conf->{snapshots}}) {
1559         my $snap = $conf->{snapshots}->{$snapname};
1560         $class->foreach_volume($snap, sub {
1561             my ($ms, $mountpoint) = @_;
1562             $test_volid->($mountpoint->{volume}, $mountpoint);
1563         });
1564     }
1565
1566     # add 'unusedX' volumes to volhash
1567     foreach my $key (keys %$conf) {
1568         if ($key =~ m/^unused/) {
1569             $test_volid->($conf->{$key}, { type => 'volume', replicate => 1 });
1570         }
1571     }
1572
1573     return $volhash;
1574 }
1575
1576 sub get_backup_volumes {
1577     my ($class, $conf) = @_;
1578
1579     my $return_volumes = [];
1580
1581     my $test_mountpoint = sub {
1582         my ($key, $volume) = @_;
1583
1584         my ($included, $reason) = $class->mountpoint_backup_enabled($key, $volume);
1585
1586         push @$return_volumes, {
1587             key => $key,
1588             included => $included,
1589             reason => $reason,
1590             volume_config => $volume,
1591         };
1592     };
1593
1594     PVE::LXC::Config->foreach_volume($conf, $test_mountpoint);
1595
1596     return $return_volumes;
1597 }
1598
1599 1;