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

package PVE::QemuServer::Memory;

use strict;
use warnings;

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);

use PVE::QemuServer;
use PVE::QemuServer::Monitor qw(mon_cmd);

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

sub get_numa_node_list {
    my ($conf) = @_;
    my @numa_map;
    for (my $i = 0; $i < $MAX_NUMA; $i++) {
	my $entry = $conf->{"numa$i"} or next;
	my $numa = PVE::QemuServer::parse_numa($entry) or next;
	push @numa_map, $i;
    }
    return @numa_map if @numa_map;
    my $sockets = $conf->{sockets} || 1;
    return (0..($sockets-1));
}

# only valid when numa nodes map to a single host node
sub get_numa_guest_to_host_map {
    my ($conf) = @_;
    my $map = {};
    for (my $i = 0; $i < $MAX_NUMA; $i++) {
	my $entry = $conf->{"numa$i"} or next;
	my $numa = PVE::QemuServer::parse_numa($entry) or next;
	$map->{$i} = print_numa_hostnodes($numa->{hostnodes});
    }
    return $map if %$map;
    my $sockets = $conf->{sockets} || 1;
    return {map { $_ => $_ } (0..($sockets-1))};
}

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;

    my @numa_map = get_numa_node_list($conf);

    for (my $j = 0; $j < 8; $j++) {
	for (my $i = 0; $i < 32; $i++) {
	    my $name = "dimm${dimm_id}";
	    $dimm_id++;
	    my $numanode = $numa_map[$i % @numa_map];
	    $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;

    my @numa_map = get_numa_node_list($conf);

    for (my $j = 0; $j < 8; $j++) {
	for (my $i = 0; $i < 32; $i++) {
 	    my $name = "dimm${dimm_id}";
 	    $dimm_id--;
	    my $numanode = $numa_map[(31-$i) % @numa_map];
 	    $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) {

	my $numa_hostmap = get_numa_guest_to_host_map($conf) if $conf->{hugepages};

    	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 $host_numanode = $numa_hostmap->{$numanode};
		    my $hugepages_topology->{$hugepages_size}->{$host_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 { 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 { 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 { 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 = mon_cmd($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(',cpus=', map {
		my ($start, $end) = @$_;
		defined($end) ? "$start-$end" : $start
	    } @$cpulists);

	    # hostnodes
	    my $hostnodelists = $numa->{hostnodes};
	    if (defined($hostnodelists)) {

		my $hostnodes = print_numa_hostnodes($hostnodelists);

		# 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/" && $conf->{hugepages};

		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 print_numa_hostnodes {
    my ($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/";
	}
    }
    return $hostnodes;
}

sub hugepages_mount {

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

   foreach my $size (qw(2048 1048576)) {
	next 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};
    die "memory size '$size' is not a positive even integer; cannot use for hugepages\n"
	if $size <= 0 || $size & 1;

    my $page_chunk = sub { -d  "/sys/kernel/mm/hugepages/hugepages-". ($_[0] * 1024) ."kB" };
    die "your system doesn't support hugepages\n" if !$page_chunk->(2) && !$page_chunk->(1024);

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

	# try to use 1GB if available && memory size is matching
	if ($page_chunk->(1024) && ($size & 1023) == 0) {
	    return 1024;
	} elsif ($page_chunk->(2)) {
	    return 2;
	} else {
	    die "host only supports 1024 GB hugepages, but requested size '$size' is not a multiple of 1024 MB\n"
	}
    } else {

	my $hugepagesize = $conf->{hugepages};

	if (!$page_chunk->($hugepagesize)) {
	    die "your system doesn't support hugepages of $hugepagesize MB\n";
	} elsif (($size % $hugepagesize) != 0) {
	    die "Memory size $size is not a multiple of the requested hugepages size $hugepagesize\n";
	}

	return $hugepagesize
    }
}

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 $hostnodelists = $numa->{hostnodes};
	my $hostnodes = print_numa_hostnodes($hostnodelists);

        die "more than 1 hostnode value in numa node is not supported when hugepages are enabled" if $hostnodes !~ m/^(\d)$/;
        my $hugepages_size = hugepages_size($conf, $numa_memory);
        $hugepages_topology->{$hugepages_size}->{$hostnodes} += 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}) {
	my $numa_hostmap = get_numa_guest_to_host_map($conf);

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

	    $numanode = $numa_hostmap->{$numanode};

	    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_default_nr_hugepages {
    my ($size) = @_;

    my $cmdline = PVE::Tools::file_read_firstline("/proc/cmdline");
    my $args = PVE::Tools::split_args($cmdline);

    my $parsed_size = 2; # default is 2M

    foreach my $arg (@$args) {
	if ($arg eq "hugepagesz=2M") {
	    $parsed_size = 2;
	} elsif ($arg eq "hugepagesz=1G") {
	    $parsed_size = 1024;
	} elsif ($arg =~ m/^hugepages=(\d+)?$/) {
	    if ($parsed_size == $size) {
		return $1;
	    }
	}
    }

    return 0;
}

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 = hugepages_default_nr_hugepages($size);
	PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr);
    }
}

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