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