PVE/QemuServer/Memory.pm

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