[qemu-server.git] / PVE / QemuServer / Memory.pm

package PVE::QemuServer::Memory;

use strict;
use warnings;
use PVE::QemuServer;
use PVE::Tools qw(run_command lock_file lock_file_full file_read_firstline dir_glob_foreach);
use PVE::Exception qw(raise raise_param_exc);

my $MAX_NUMA = 8;
my $MAX_MEM = 4194304;
my $STATICMEM = 1024;

sub foreach_dimm{
    my ($conf, $vmid, $memory, $sockets, $func) = @_;

    my $dimm_id = 0;
    my $current_size = 0;
    my $dimm_size = 0;

    if($conf->{hugepages} && $conf->{hugepages} == 1024) {
	$current_size = 1024 * $sockets;
	$dimm_size = 1024;
    } else {
	$current_size = 1024;
	$dimm_size = 512;
    }

    return if $current_size == $memory;

    for (my $j = 0; $j < 8; $j++) {
	for (my $i = 0; $i < 32; $i++) {
	    my $name = "dimm${dimm_id}";
	    $dimm_id++;
	    my $numanode = $i % $sockets;
	    $current_size += $dimm_size;
	    &$func($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory);
	    return  $current_size if $current_size >= $memory;
	}
	$dimm_size *= 2;
    }
}

sub foreach_reverse_dimm {
    my ($conf, $vmid, $memory, $sockets, $func) = @_;

    my $dimm_id = 253;
    my $current_size = 0;
    my $dimm_size = 0;

    if($conf->{hugepages} && $conf->{hugepages} == 1024) {
	$current_size = 8355840;
	$dimm_size = 131072;
    } else {
	$current_size = 4177920;
	$dimm_size = 65536;
    }

    return if $current_size == $memory;

    for (my $j = 0; $j < 8; $j++) {
	for (my $i = 0; $i < 32; $i++) {
 	    my $name = "dimm${dimm_id}";
 	    $dimm_id--;
 	    my $numanode = $i % $sockets;
 	    $current_size -= $dimm_size;
 	    &$func($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory);
	    return  $current_size if $current_size <= $memory;
	}
	$dimm_size /= 2;
    }
}

sub qemu_memory_hotplug {
    my ($vmid, $conf, $defaults, $opt, $value) = @_;

    return $value if !PVE::QemuServer::check_running($vmid);

    my $sockets = 1;
    $sockets = $conf->{sockets} if $conf->{sockets};

    my $memory = $conf->{memory} || $defaults->{memory};
    $value = $defaults->{memory} if !$value;
    return $value if $value == $memory;

    my $static_memory = $STATICMEM;
    $static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);

    die "memory can't be lower than $static_memory MB" if $value < $static_memory;
    die "you cannot add more memory than $MAX_MEM MB!\n" if $memory > $MAX_MEM;

    if($value > $memory) {

    	foreach_dimm($conf, $vmid, $value, $sockets, sub {
	    my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;

		return if $current_size <= $conf->{memory};

		if ($conf->{hugepages}) {

		    my $hugepages_size = hugepages_size($conf, $dimm_size);
		    my $path = hugepages_mount_path($hugepages_size);
		    my $hugepages_topology->{$hugepages_size}->{$numanode} = hugepages_nr($dimm_size, $hugepages_size);

		    my $code = sub {
			my $hugepages_host_topology = hugepages_host_topology();
			hugepages_allocate($hugepages_topology, $hugepages_host_topology);

			eval { PVE::QemuServer::vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-file", id => "mem-$name", props => {
					     size => int($dimm_size*1024*1024), 'mem-path' => $path, share => JSON::true, prealloc => JSON::true } ); };
			if (my $err = $@) {
			    hugepages_reset($hugepages_host_topology);
			    die $err;
			}

			hugepages_pre_deallocate($hugepages_topology);
		    };
		    eval { hugepages_update_locked($code); };

		} else {
		    eval { PVE::QemuServer::vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-ram", id => "mem-$name", props => { size => int($dimm_size*1024*1024) } ) };
		}

		if (my $err = $@) {
		    eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
		    die $err;
		}

		eval { PVE::QemuServer::vm_mon_cmd($vmid, "device_add", driver => "pc-dimm", id => "$name", memdev => "mem-$name", node => $numanode) };
		if (my $err = $@) {
		    eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
		    die $err;
		}
		#update conf after each succesful module hotplug
		$conf->{memory} = $current_size;
		PVE::QemuConfig->write_config($vmid, $conf);
	});

    } else {

    	foreach_reverse_dimm($conf, $vmid, $value, $sockets, sub {
	    my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;

		return if $current_size >= $conf->{memory};
		print "try to unplug memory dimm $name\n";

		my $retry = 0;
	        while (1) {
		    eval { PVE::QemuServer::qemu_devicedel($vmid, $name) };
		    sleep 3;
		    my $dimm_list = qemu_dimm_list($vmid);
		    last if !$dimm_list->{$name};
		    raise_param_exc({ $name => "error unplug memory module" }) if $retry > 5;
		    $retry++;
		}

		#update conf after each succesful module unplug
		$conf->{memory} = $current_size;

		eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
		PVE::QemuConfig->write_config($vmid, $conf);
	});
    }
}

sub qemu_dimm_list {
    my ($vmid) = @_;

    my $dimmarray = PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "query-memory-devices");
    my $dimms = {};

    foreach my $dimm (@$dimmarray) {

        $dimms->{$dimm->{data}->{id}}->{id} = $dimm->{data}->{id};
        $dimms->{$dimm->{data}->{id}}->{node} = $dimm->{data}->{node};
        $dimms->{$dimm->{data}->{id}}->{addr} = $dimm->{data}->{addr};
        $dimms->{$dimm->{data}->{id}}->{size} = $dimm->{data}->{size};
        $dimms->{$dimm->{data}->{id}}->{slot} = $dimm->{data}->{slot};
    }
    return $dimms;
}

sub config {
    my ($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd) = @_;
    
    my $memory = $conf->{memory} || $defaults->{memory};
    my $static_memory = 0;

    if ($hotplug_features->{memory}) {
	die "NUMA needs to be enabled for memory hotplug\n" if !$conf->{numa};
	die "Total memory is bigger than ${MAX_MEM}MB\n" if $memory > $MAX_MEM;
	my $sockets = 1;
	$sockets = $conf->{sockets} if $conf->{sockets};

	$static_memory = $STATICMEM;
	$static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);

	die "minimum memory must be ${static_memory}MB\n" if($memory < $static_memory);
	push @$cmd, '-m', "size=${static_memory},slots=255,maxmem=${MAX_MEM}M";

    } else {

	$static_memory = $memory;
	push @$cmd, '-m', $static_memory;
    }

    die "numa needs to be enabled to use hugepages" if $conf->{hugepages} && !$conf->{numa};

    if ($conf->{numa}) {

	my $numa_totalmemory = undef;
	for (my $i = 0; $i < $MAX_NUMA; $i++) {
	    next if !$conf->{"numa$i"};
	    my $numa = PVE::QemuServer::parse_numa($conf->{"numa$i"});
	    next if !$numa;
	    # memory
	    die "missing NUMA node$i memory value\n" if !$numa->{memory};
	    my $numa_memory = $numa->{memory};
	    $numa_totalmemory += $numa_memory;

	    my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);

	    # cpus
	    my $cpulists = $numa->{cpus};
	    die "missing NUMA node$i cpus\n" if !defined($cpulists);
	    my $cpus = join(',', map {
		my ($start, $end) = @$_;
		defined($end) ? "$start-$end" : $start
	    } @$cpulists);

	    # hostnodes
	    my $hostnodelists = $numa->{hostnodes};
	    if (defined($hostnodelists)) {
		my $hostnodes;
		foreach my $hostnoderange (@$hostnodelists) {
		    my ($start, $end) = @$hostnoderange;
		    $hostnodes .= ',' if $hostnodes;
		    $hostnodes .= $start;
		    $hostnodes .= "-$end" if defined($end);
		    $end //= $start;
		    for (my $i = $start; $i <= $end; ++$i ) {
			die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/";
		    }
		}

		# policy
		my $policy = $numa->{policy};
		die "you need to define a policy for hostnode $hostnodes\n" if !$policy;
		$mem_object .= ",host-nodes=$hostnodes,policy=$policy";
	    } else {
		die "numa hostnodes need to be defined to use hugepages" if $conf->{hugepages};
	    }

	    push @$cmd, '-object', $mem_object;
	    push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
	}

	die "total memory for NUMA nodes must be equal to vm static memory\n"
	    if $numa_totalmemory && $numa_totalmemory != $static_memory;

	#if no custom tology, we split memory and cores across numa nodes
	if(!$numa_totalmemory) {

	    my $numa_memory = ($static_memory / $sockets);

	    for (my $i = 0; $i < $sockets; $i++)  {
		die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/";

		my $cpustart = ($cores * $i);
		my $cpuend = ($cpustart + $cores - 1) if $cores && $cores > 1;
		my $cpus = $cpustart;
		$cpus .= "-$cpuend" if $cpuend;

		my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);

		push @$cmd, '-object', $mem_object;
		push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
	    }
	}
    }

    if ($hotplug_features->{memory}) {
	foreach_dimm($conf, $vmid, $memory, $sockets, sub {
	    my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;

	    my $mem_object = print_mem_object($conf, "mem-$name", $dimm_size);

	    push @$cmd, "-object" , $mem_object;
	    push @$cmd, "-device", "pc-dimm,id=$name,memdev=mem-$name,node=$numanode";

	    #if dimm_memory is not aligned to dimm map
	    if($current_size > $memory) {
	         $conf->{memory} = $current_size;
	         PVE::QemuConfig->write_config($vmid, $conf);
	    }
	});
    }
}

sub print_mem_object {
    my ($conf, $id, $size) = @_;

    if ($conf->{hugepages}) {

	my $hugepages_size = hugepages_size($conf, $size);
	my $path = hugepages_mount_path($hugepages_size);

	return "memory-backend-file,id=$id,size=${size}M,mem-path=$path,share=on,prealloc=yes";
    } else {
	return "memory-backend-ram,id=$id,size=${size}M";
    }

}

sub hugepages_mount {

   my $mountdata = PVE::ProcFSTools::parse_proc_mounts();

   foreach my $size (qw(2048 1048576)) {
	return if (! -d "/sys/kernel/mm/hugepages/hugepages-${size}kB");

	my $path = "/run/hugepages/kvm/${size}kB";

	my $found = grep {
	    $_->[2] =~ /^hugetlbfs/ &&
	    $_->[1] eq $path
	} @$mountdata;

	if (!$found) {

	    File::Path::make_path($path) if (!-d $path);
	    my $cmd = ['/bin/mount', '-t', 'hugetlbfs', '-o', "pagesize=${size}k", 'hugetlbfs', $path];
	    run_command($cmd, errmsg => "hugepage mount error");
	}
   }
}

sub hugepages_mount_path {
   my ($size) = @_;

   $size = $size * 1024;
   return "/run/hugepages/kvm/${size}kB";

}

sub hugepages_nr {
  my ($size, $hugepages_size) = @_;

  return $size / $hugepages_size;
}

sub hugepages_size {
   my ($conf, $size) = @_;

   die "hugepages option is not enabled" if !$conf->{hugepages};

   if ($conf->{hugepages} eq 'any') {

	#try to use 1GB if available && memory size is matching
	if (-d "/sys/kernel/mm/hugepages/hugepages-1048576kB" && ($size % 1024 == 0)) {
	    return 1024;
	} else {
	    return 2;
	}

   } else {

	my $hugepagesize = $conf->{hugepages} * 1024 . "kB";

	if (! -d "/sys/kernel/mm/hugepages/hugepages-$hugepagesize") {
		die "your system doesn't support hugepages of $hugepagesize";
	}
	die "Memory size $size is not a multiple of the requested hugepages size $hugepagesize" if ($size % $conf->{hugepages}) != 0;
	return $conf->{hugepages};
   }

}

sub hugepages_topology {
    my ($conf) = @_;

    my $hugepages_topology = {};

    return if !$conf->{numa};

    my $defaults = PVE::QemuServer::load_defaults();
    my $memory = $conf->{memory} || $defaults->{memory};
    my $static_memory = 0;
    my $sockets = 1;
    $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
    $sockets = $conf->{sockets} if $conf->{sockets};
    my $numa_custom_topology = undef;
    my $hotplug_features = PVE::QemuServer::parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');

    if ($hotplug_features->{memory}) {
	$static_memory = $STATICMEM;
	$static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
    } else {
	$static_memory = $memory;
    }

    #custom numa topology
    for (my $i = 0; $i < $MAX_NUMA; $i++) {
	next if !$conf->{"numa$i"};
	my $numa = PVE::QemuServer::parse_numa($conf->{"numa$i"});
	next if !$numa;

	$numa_custom_topology = 1;
	my $numa_memory = $numa->{memory};

        my $hugepages_size = hugepages_size($conf, $numa_memory);
        $hugepages_topology->{$hugepages_size}->{$i} += hugepages_nr($numa_memory, $hugepages_size);

    }

    #if no custom numa tology, we split memory and cores across numa nodes
    if(!$numa_custom_topology) {

	my $numa_memory = ($static_memory / $sockets);

	for (my $i = 0; $i < $sockets; $i++)  {

	    my $hugepages_size = hugepages_size($conf, $numa_memory);
	    $hugepages_topology->{$hugepages_size}->{$i} += hugepages_nr($numa_memory, $hugepages_size);
	}
    }

    if ($hotplug_features->{memory}) {
	foreach_dimm($conf, undef, $memory, $sockets, sub {
	    my ($conf, undef, $name, $dimm_size, $numanode, $current_size, $memory) = @_;

	    my $hugepages_size = hugepages_size($conf, $dimm_size);
	    $hugepages_topology->{$hugepages_size}->{$numanode} += hugepages_nr($dimm_size, $hugepages_size);
	});
    }

    return $hugepages_topology;
}

sub hugepages_host_topology {

    #read host hugepages
    my $hugepages_host_topology = {};

    dir_glob_foreach("/sys/devices/system/node/", 'node(\d+)', sub {
	my ($nodepath, $numanode) = @_;

	dir_glob_foreach("/sys/devices/system/node/$nodepath/hugepages/", 'hugepages\-(\d+)kB', sub {
	    my ($hugepages_path, $hugepages_size) = @_;

	    $hugepages_size = $hugepages_size / 1024;
	    my $hugepages_nr = PVE::Tools::file_read_firstline("/sys/devices/system/node/$nodepath/hugepages/$hugepages_path/nr_hugepages");
	    $hugepages_host_topology->{$hugepages_size}->{$numanode} = $hugepages_nr;
        });
    });

    return $hugepages_host_topology;
}

sub hugepages_allocate {
    my ($hugepages_topology, $hugepages_host_topology) = @_;

    #allocate new hupages if needed
    foreach my $size (sort keys %$hugepages_topology) {

	my $nodes = $hugepages_topology->{$size};

	foreach my $numanode (keys %$nodes) {

	    my $hugepages_size = $size * 1024;
	    my $hugepages_requested = $hugepages_topology->{$size}->{$numanode};
	    my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";
	    my $hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
	    my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");

	    if ($hugepages_requested > $hugepages_free) {
		my $hugepages_needed = $hugepages_requested - $hugepages_free;
		PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr + $hugepages_needed);
		#verify that is correctly allocated
		$hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
		if ($hugepages_free < $hugepages_requested) {
		    #rollback to initial host config
		    hugepages_reset($hugepages_host_topology);
		    die "hugepage allocation failed";
		}
	    }

	}
    }

}

sub hugepages_pre_deallocate {
    my ($hugepages_topology) = @_;

    foreach my $size (sort keys %$hugepages_topology) {

	my $hugepages_size = $size * 1024;
	my $path = "/sys/kernel/mm/hugepages/hugepages-${hugepages_size}kB/";
	my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");
	PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", 0);
    }
}

sub hugepages_reset {
    my ($hugepages_topology) = @_;

    foreach my $size (sort keys %$hugepages_topology) {

	my $nodes = $hugepages_topology->{$size};
	foreach my $numanode (keys %$nodes) {

	    my $hugepages_nr = $hugepages_topology->{$size}->{$numanode};
	    my $hugepages_size = $size * 1024;
	    my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";

	    PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr);
	}
    }
}

sub hugepages_update_locked {
    my ($code, @param) = @_;

    my $timeout = 60; #could be long if a lot of hugepages need to be alocated

    my $lock_filename = "/var/lock/hugepages.lck";

    my $res = lock_file($lock_filename, $timeout, $code, @param);
    die $@ if $@;

    return $res;
}
1;
Commit	Line	Data
a0649da2 AD	1	package PVE::QemuServer::Memory;
	2
	3	use strict;
	4	use warnings;
6779f1ac	5	use PVE::QemuServer;
7023f3ea	6	use PVE::Tools qw(run_command lock_file lock_file_full file_read_firstline dir_glob_foreach);
9a1c413f	7	use PVE::Exception qw(raise raise_param_exc);
a0649da2	8
0567a4d5	9	my $MAX_NUMA = 8;
6779f1ac AD	10	my $MAX_MEM = 4194304;
6779f1ac AD	11	my $STATICMEM = 1024;
a0649da2	12
3f669af2 AD	13	sub foreach_dimm{
	14	my ($conf, $vmid, $memory, $sockets, $func) = @_;
	15
	16	my $dimm_id = 0;
7023f3ea AD	17	my $current_size = 0;
	18	my $dimm_size = 0;
	19
	20	if($conf->{hugepages} && $conf->{hugepages} == 1024) {
	21	$current_size = 1024 * $sockets;
	22	$dimm_size = 1024;
	23	} else {
	24	$current_size = 1024;
	25	$dimm_size = 512;
	26	}
	27
3f669af2 AD	28	return if $current_size == $memory;
	29
	30	for (my $j = 0; $j < 8; $j++) {
	31	for (my $i = 0; $i < 32; $i++) {
	32	my $name = "dimm${dimm_id}";
	33	$dimm_id++;
	34	my $numanode = $i % $sockets;
	35	$current_size += $dimm_size;
	36	&$func($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory);
	37	return $current_size if $current_size >= $memory;
	38	}
	39	$dimm_size *= 2;
	40	}
	41	}
	42
	43	sub foreach_reverse_dimm {
	44	my ($conf, $vmid, $memory, $sockets, $func) = @_;
	45
	46	my $dimm_id = 253;
7023f3ea AD	47	my $current_size = 0;
	48	my $dimm_size = 0;
	49
	50	if($conf->{hugepages} && $conf->{hugepages} == 1024) {
	51	$current_size = 8355840;
	52	$dimm_size = 131072;
	53	} else {
	54	$current_size = 4177920;
	55	$dimm_size = 65536;
	56	}
	57
3f669af2 AD	58	return if $current_size == $memory;
	59
	60	for (my $j = 0; $j < 8; $j++) {
	61	for (my $i = 0; $i < 32; $i++) {
	62	my $name = "dimm${dimm_id}";
	63	$dimm_id--;
	64	my $numanode = $i % $sockets;
	65	$current_size -= $dimm_size;
	66	&$func($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory);
	67	return $current_size if $current_size <= $memory;
	68	}
	69	$dimm_size /= 2;
	70	}
	71	}
	72
6779f1ac AD	73	sub qemu_memory_hotplug {
	74	my ($vmid, $conf, $defaults, $opt, $value) = @_;
	75
37dbec89	76	return $value if !PVE::QemuServer::check_running($vmid);
6779f1ac	77
7023f3ea AD	78	my $sockets = 1;
	79	$sockets = $conf->{sockets} if $conf->{sockets};
	80
6779f1ac AD	81	my $memory = $conf->{memory} \|\| $defaults->{memory};
	82	$value = $defaults->{memory} if !$value;
	83	return $value if $value == $memory;
	84
	85	my $static_memory = $STATICMEM;
7023f3ea	86	$static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
6779f1ac AD	87
	88	die "memory can't be lower than $static_memory MB" if $value < $static_memory;
	89	die "you cannot add more memory than $MAX_MEM MB!\n" if $memory > $MAX_MEM;
	90
6779f1ac AD	91	if($value > $memory) {
	92
	93	foreach_dimm($conf, $vmid, $value, $sockets, sub {
	94	my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
	95
	96	return if $current_size <= $conf->{memory};
	97
7023f3ea AD	98	if ($conf->{hugepages}) {
	99
	100	my $hugepages_size = hugepages_size($conf, $dimm_size);
	101	my $path = hugepages_mount_path($hugepages_size);
	102	my $hugepages_topology->{$hugepages_size}->{$numanode} = hugepages_nr($dimm_size, $hugepages_size);
	103
	104	my $code = sub {
	105	my $hugepages_host_topology = hugepages_host_topology();
	106	hugepages_allocate($hugepages_topology, $hugepages_host_topology);
	107
	108	eval { PVE::QemuServer::vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-file", id => "mem-$name", props => {
	109	size => int($dimm_size10241024), 'mem-path' => $path, share => JSON::true, prealloc => JSON::true } ); };
	110	if (my $err = $@) {
	111	hugepages_reset($hugepages_host_topology);
	112	die $err;
	113	}
	114
	115	hugepages_pre_deallocate($hugepages_topology);
	116	};
	117	eval { hugepages_update_locked($code); };
	118
	119	} else {
	120	eval { PVE::QemuServer::vm_mon_cmd($vmid, "object-add", 'qom-type' => "memory-backend-ram", id => "mem-$name", props => { size => int($dimm_size10241024) } ) };
	121	}
	122
6779f1ac AD	123	if (my $err = $@) {
	124	eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
	125	die $err;
	126	}
	127
	128	eval { PVE::QemuServer::vm_mon_cmd($vmid, "device_add", driver => "pc-dimm", id => "$name", memdev => "mem-$name", node => $numanode) };
	129	if (my $err = $@) {
	130	eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
	131	die $err;
	132	}
	133	#update conf after each succesful module hotplug
	134	$conf->{memory} = $current_size;
	135	PVE::QemuConfig->write_config($vmid, $conf);
	136	});
	137
	138	} else {
	139
	140	foreach_reverse_dimm($conf, $vmid, $value, $sockets, sub {
	141	my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
	142
	143	return if $current_size >= $conf->{memory};
	144	print "try to unplug memory dimm $name\n";
	145
	146	my $retry = 0;
	147	while (1) {
	148	eval { PVE::QemuServer::qemu_devicedel($vmid, $name) };
	149	sleep 3;
	150	my $dimm_list = qemu_dimm_list($vmid);
	151	last if !$dimm_list->{$name};
	152	raise_param_exc({ $name => "error unplug memory module" }) if $retry > 5;
	153	$retry++;
	154	}
	155
	156	#update conf after each succesful module unplug
	157	$conf->{memory} = $current_size;
	158
	159	eval { PVE::QemuServer::qemu_objectdel($vmid, "mem-$name"); };
	160	PVE::QemuConfig->write_config($vmid, $conf);
	161	});
	162	}
	163	}
	164
	165	sub qemu_dimm_list {
	166	my ($vmid) = @_;
	167
	168	my $dimmarray = PVE::QemuServer::vm_mon_cmd_nocheck($vmid, "query-memory-devices");
	169	my $dimms = {};
	170
	171	foreach my $dimm (@$dimmarray) {
	172
	173	$dimms->{$dimm->{data}->{id}}->{id} = $dimm->{data}->{id};
	174	$dimms->{$dimm->{data}->{id}}->{node} = $dimm->{data}->{node};
	175	$dimms->{$dimm->{data}->{id}}->{addr} = $dimm->{data}->{addr};
	176	$dimms->{$dimm->{data}->{id}}->{size} = $dimm->{data}->{size};
	177	$dimms->{$dimm->{data}->{id}}->{slot} = $dimm->{data}->{slot};
	178	}
	179	return $dimms;
	180	}
	181
0567a4d5 AD	182	sub config {
	183	my ($conf, $vmid, $sockets, $cores, $defaults, $hotplug_features, $cmd) = @_;
	184
	185	my $memory = $conf->{memory} \|\| $defaults->{memory};
	186	my $static_memory = 0;
0567a4d5 AD	187
0567a4d5 AD	188	if ($hotplug_features->{memory}) {
7023f3ea	189	die "NUMA needs to be enabled for memory hotplug\n" if !$conf->{numa};
0567a4d5	190	die "Total memory is bigger than ${MAX_MEM}MB\n" if $memory > $MAX_MEM;
7023f3ea AD	191	my $sockets = 1;
	192	$sockets = $conf->{sockets} if $conf->{sockets};
	193
0567a4d5	194	$static_memory = $STATICMEM;
7023f3ea AD	195	$static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
7023f3ea AD	196
0567a4d5	197	die "minimum memory must be ${static_memory}MB\n" if($memory < $static_memory);
0567a4d5 AD	198	push @$cmd, '-m', "size=${static_memory},slots=255,maxmem=${MAX_MEM}M";
	199
	200	} else {
	201
	202	$static_memory = $memory;
	203	push @$cmd, '-m', $static_memory;
	204	}
	205
7023f3ea AD	206	die "numa needs to be enabled to use hugepages" if $conf->{hugepages} && !$conf->{numa};
7023f3ea AD	207
0567a4d5 AD	208	if ($conf->{numa}) {
	209
	210	my $numa_totalmemory = undef;
	211	for (my $i = 0; $i < $MAX_NUMA; $i++) {
	212	next if !$conf->{"numa$i"};
	213	my $numa = PVE::QemuServer::parse_numa($conf->{"numa$i"});
	214	next if !$numa;
	215	# memory
	216	die "missing NUMA node$i memory value\n" if !$numa->{memory};
	217	my $numa_memory = $numa->{memory};
	218	$numa_totalmemory += $numa_memory;
7023f3ea AD	219
7023f3ea AD	220	my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);
0567a4d5 AD	221
	222	# cpus
	223	my $cpulists = $numa->{cpus};
	224	die "missing NUMA node$i cpus\n" if !defined($cpulists);
	225	my $cpus = join(',', map {
	226	my ($start, $end) = @$_;
	227	defined($end) ? "$start-$end" : $start
	228	} @$cpulists);
	229
	230	# hostnodes
	231	my $hostnodelists = $numa->{hostnodes};
	232	if (defined($hostnodelists)) {
	233	my $hostnodes;
	234	foreach my $hostnoderange (@$hostnodelists) {
	235	my ($start, $end) = @$hostnoderange;
	236	$hostnodes .= ',' if $hostnodes;
	237	$hostnodes .= $start;
	238	$hostnodes .= "-$end" if defined($end);
	239	$end //= $start;
	240	for (my $i = $start; $i <= $end; ++$i ) {
7023f3ea	241	die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/";
0567a4d5 AD	242	}
	243	}
	244
	245	# policy
	246	my $policy = $numa->{policy};
	247	die "you need to define a policy for hostnode $hostnodes\n" if !$policy;
7023f3ea AD	248	$mem_object .= ",host-nodes=$hostnodes,policy=$policy";
	249	} else {
	250	die "numa hostnodes need to be defined to use hugepages" if $conf->{hugepages};
0567a4d5 AD	251	}
0567a4d5 AD	252
7023f3ea	253	push @$cmd, '-object', $mem_object;
0567a4d5 AD	254	push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
	255	}
	256
	257	die "total memory for NUMA nodes must be equal to vm static memory\n"
	258	if $numa_totalmemory && $numa_totalmemory != $static_memory;
	259
	260	#if no custom tology, we split memory and cores across numa nodes
	261	if(!$numa_totalmemory) {
	262
7023f3ea	263	my $numa_memory = ($static_memory / $sockets);
0567a4d5 AD	264
0567a4d5 AD	265	for (my $i = 0; $i < $sockets; $i++) {
7023f3ea	266	die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/";
0567a4d5 AD	267
	268	my $cpustart = ($cores * $i);
	269	my $cpuend = ($cpustart + $cores - 1) if $cores && $cores > 1;
	270	my $cpus = $cpustart;
	271	$cpus .= "-$cpuend" if $cpuend;
	272
7023f3ea AD	273	my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);
	274
	275	push @$cmd, '-object', $mem_object;
0567a4d5 AD	276	push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
	277	}
	278	}
	279	}
	280
	281	if ($hotplug_features->{memory}) {
	282	foreach_dimm($conf, $vmid, $memory, $sockets, sub {
	283	my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
7023f3ea AD	284
	285	my $mem_object = print_mem_object($conf, "mem-$name", $dimm_size);
	286
	287	push @$cmd, "-object" , $mem_object;
0567a4d5 AD	288	push @$cmd, "-device", "pc-dimm,id=$name,memdev=mem-$name,node=$numanode";
	289
	290	#if dimm_memory is not aligned to dimm map
	291	if($current_size > $memory) {
	292	$conf->{memory} = $current_size;
	293	PVE::QemuConfig->write_config($vmid, $conf);
	294	}
	295	});
	296	}
	297	}
	298
7023f3ea AD	299	sub print_mem_object {
	300	my ($conf, $id, $size) = @_;
	301
	302	if ($conf->{hugepages}) {
	303
	304	my $hugepages_size = hugepages_size($conf, $size);
	305	my $path = hugepages_mount_path($hugepages_size);
	306
	307	return "memory-backend-file,id=$id,size=${size}M,mem-path=$path,share=on,prealloc=yes";
	308	} else {
	309	return "memory-backend-ram,id=$id,size=${size}M";
	310	}
0567a4d5	311
7023f3ea AD	312	}
	313
	314	sub hugepages_mount {
	315
	316	my $mountdata = PVE::ProcFSTools::parse_proc_mounts();
	317
	318	foreach my $size (qw(2048 1048576)) {
	319	return if (! -d "/sys/kernel/mm/hugepages/hugepages-${size}kB");
	320
	321	my $path = "/run/hugepages/kvm/${size}kB";
	322
	323	my $found = grep {
	324	$_->[2] =~ /^hugetlbfs/ &&
	325	$_->[1] eq $path
	326	} @$mountdata;
	327
	328	if (!$found) {
	329
	330	File::Path::make_path($path) if (!-d $path);
	331	my $cmd = ['/bin/mount', '-t', 'hugetlbfs', '-o', "pagesize=${size}k", 'hugetlbfs', $path];
	332	run_command($cmd, errmsg => "hugepage mount error");
	333	}
	334	}
	335	}
	336
	337	sub hugepages_mount_path {
	338	my ($size) = @_;
	339
	340	$size = $size * 1024;
	341	return "/run/hugepages/kvm/${size}kB";
	342
	343	}
	344
	345	sub hugepages_nr {
	346	my ($size, $hugepages_size) = @_;
	347
	348	return $size / $hugepages_size;
	349	}
	350
	351	sub hugepages_size {
	352	my ($conf, $size) = @_;
	353
	354	die "hugepages option is not enabled" if !$conf->{hugepages};
	355
	356	if ($conf->{hugepages} eq 'any') {
	357
	358	#try to use 1GB if available && memory size is matching
	359	if (-d "/sys/kernel/mm/hugepages/hugepages-1048576kB" && ($size % 1024 == 0)) {
	360	return 1024;
	361	} else {
	362	return 2;
	363	}
	364
	365	} else {
	366
	367	my $hugepagesize = $conf->{hugepages} * 1024 . "kB";
	368
	369	if (! -d "/sys/kernel/mm/hugepages/hugepages-$hugepagesize") {
	370	die "your system doesn't support hugepages of $hugepagesize";
	371	}
	372	die "Memory size $size is not a multiple of the requested hugepages size $hugepagesize" if ($size % $conf->{hugepages}) != 0;
	373	return $conf->{hugepages};
	374	}
	375
376	}
377
378	sub hugepages_topology {
379	my ($conf) = @_;
380
381	my $hugepages_topology = {};
382
383	return if !$conf->{numa};
384
385	my $defaults = PVE::QemuServer::load_defaults();
386	my $memory = $conf->{memory} \|\| $defaults->{memory};
387	my $static_memory = 0;
388	my $sockets = 1;
389	$sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
390	$sockets = $conf->{sockets} if $conf->{sockets};
391	my $numa_custom_topology = undef;
392	my $hotplug_features = PVE::QemuServer::parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
393
394	if ($hotplug_features->{memory}) {
395	$static_memory = $STATICMEM;
396	$static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
397	} else {
398	$static_memory = $memory;
399	}
400
401	#custom numa topology
402	for (my $i = 0; $i < $MAX_NUMA; $i++) {
403	next if !$conf->{"numa$i"};
404	my $numa = PVE::QemuServer::parse_numa($conf->{"numa$i"});
405	next if !$numa;
406
407	$numa_custom_topology = 1;
408	my $numa_memory = $numa->{memory};
409
410	my $hugepages_size = hugepages_size($conf, $numa_memory);
411	$hugepages_topology->{$hugepages_size}->{$i} += hugepages_nr($numa_memory, $hugepages_size);
412
413	}
414
415	#if no custom numa tology, we split memory and cores across numa nodes
416	if(!$numa_custom_topology) {
417
418	my $numa_memory = ($static_memory / $sockets);
419
420	for (my $i = 0; $i < $sockets; $i++) {
421
422	my $hugepages_size = hugepages_size($conf, $numa_memory);
423	$hugepages_topology->{$hugepages_size}->{$i} += hugepages_nr($numa_memory, $hugepages_size);
424	}
425	}
426
427	if ($hotplug_features->{memory}) {
428	foreach_dimm($conf, undef, $memory, $sockets, sub {
429	my ($conf, undef, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
430
431	my $hugepages_size = hugepages_size($conf, $dimm_size);
432	$hugepages_topology->{$hugepages_size}->{$numanode} += hugepages_nr($dimm_size, $hugepages_size);
433	});
434	}
435
436	return $hugepages_topology;
437	}
438
439	sub hugepages_host_topology {
440
441	#read host hugepages
442	my $hugepages_host_topology = {};
443
444	dir_glob_foreach("/sys/devices/system/node/", 'node(\d+)', sub {
445	my ($nodepath, $numanode) = @_;
446
447	dir_glob_foreach("/sys/devices/system/node/$nodepath/hugepages/", 'hugepages\-(\d+)kB', sub {
448	my ($hugepages_path, $hugepages_size) = @_;
449
450	$hugepages_size = $hugepages_size / 1024;
451	my $hugepages_nr = PVE::Tools::file_read_firstline("/sys/devices/system/node/$nodepath/hugepages/$hugepages_path/nr_hugepages");
452	$hugepages_host_topology->{$hugepages_size}->{$numanode} = $hugepages_nr;
453	});
454	});
455
456	return $hugepages_host_topology;
457	}
458
459	sub hugepages_allocate {
460	my ($hugepages_topology, $hugepages_host_topology) = @_;
461
462	#allocate new hupages if needed
463	foreach my $size (sort keys %$hugepages_topology) {
464
465	my $nodes = $hugepages_topology->{$size};
466
467	foreach my $numanode (keys %$nodes) {
468
469	my $hugepages_size = $size * 1024;
470	my $hugepages_requested = $hugepages_topology->{$size}->{$numanode};
471	my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";
472	my $hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
473	my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");
474
475	if ($hugepages_requested > $hugepages_free) {
476	my $hugepages_needed = $hugepages_requested - $hugepages_free;
477	PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr + $hugepages_needed);
478	#verify that is correctly allocated
479	$hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
480	if ($hugepages_free < $hugepages_requested) {
481	#rollback to initial host config
482	hugepages_reset($hugepages_host_topology);
483	die "hugepage allocation failed";
484	}
485	}
486
487	}
488	}
489
490	}
491
492	sub hugepages_pre_deallocate {
493	my ($hugepages_topology) = @_;
494
495	foreach my $size (sort keys %$hugepages_topology) {
496
497	my $hugepages_size = $size * 1024;
498	my $path = "/sys/kernel/mm/hugepages/hugepages-${hugepages_size}kB/";
499	my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");
500	PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", 0);
501	}
502	}
503
504	sub hugepages_reset {
505	my ($hugepages_topology) = @_;
506
507	foreach my $size (sort keys %$hugepages_topology) {
508
509	my $nodes = $hugepages_topology->{$size};
510	foreach my $numanode (keys %$nodes) {
511
512	my $hugepages_nr = $hugepages_topology->{$size}->{$numanode};
513	my $hugepages_size = $size * 1024;
514	my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";
515
516	PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr);
517	}
518	}
519	}
520
521	sub hugepages_update_locked {
522	my ($code, @param) = @_;
523
524	my $timeout = 60; #could be long if a lot of hugepages need to be alocated
525
526	my $lock_filename = "/var/lock/hugepages.lck";
527
528	my $res = lock_file($lock_filename, $timeout, $code, @param);
529	die $@ if $@;
530
531	return $res;
532	}
3f669af2	533	1;
a0649da2	534