PVE/QemuServer/Memory.pm

   1 package PVE::QemuServer::Memory;
   2
   3 use strict;
   4 use warnings;
   5 use PVE::QemuServer;
   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 my $MAX_NUMA = 8;
  10 my $MAX_MEM = 4194304;
  11 my $STATICMEM = 1024;
  12
  13 sub foreach_dimm{
  14     my ($conf, $vmid, $memory, $sockets, $func) = @_;
  15
  16     my $dimm_id = 0;
  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
  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;
  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
  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
  73 sub qemu_memory_hotplug {
  74     my ($vmid, $conf, $defaults, $opt, $value) = @_;
  75
  76     return $value if !PVE::QemuServer::check_running($vmid);
  77
  78     my $sockets = 1;
  79     $sockets = $conf->{sockets} if $conf->{sockets};
  80
  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;
  86     $static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
  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
  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
  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_size*1024*1024), '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_size*1024*1024) } ) };
 121                 }
 122
 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
 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;
 187
 188     if ($hotplug_features->{memory}) {
 189         die "NUMA needs to be enabled for memory hotplug\n" if !$conf->{numa};
 190         die "Total memory is bigger than ${MAX_MEM}MB\n" if $memory > $MAX_MEM;
 191         my $sockets = 1;
 192         $sockets = $conf->{sockets} if $conf->{sockets};
 193
 194         $static_memory = $STATICMEM;
 195         $static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
 196
 197         die "minimum memory must be ${static_memory}MB\n" if($memory < $static_memory);
 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
 206     die "numa needs to be enabled to use hugepages" if $conf->{hugepages} && !$conf->{numa};
 207
 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;
 219
 220             my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);
 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
 234                 my $hostnodes = print_numa_hostnodes($hostnodelists);
 235
 236                 # policy
 237                 my $policy = $numa->{policy};
 238                 die "you need to define a policy for hostnode $hostnodes\n" if !$policy;
 239                 $mem_object .= ",host-nodes=$hostnodes,policy=$policy";
 240             } else {
 241                 die "numa hostnodes need to be defined to use hugepages" if $conf->{hugepages};
 242             }
 243
 244             push @$cmd, '-object', $mem_object;
 245             push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
 246         }
 247
 248         die "total memory for NUMA nodes must be equal to vm static memory\n"
 249             if $numa_totalmemory && $numa_totalmemory != $static_memory;
 250
 251         #if no custom tology, we split memory and cores across numa nodes
 252         if(!$numa_totalmemory) {
 253
 254             my $numa_memory = ($static_memory / $sockets);
 255
 256             for (my $i = 0; $i < $sockets; $i++)  {
 257                 die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/" && $conf->{hugepages};
 258
 259                 my $cpustart = ($cores * $i);
 260                 my $cpuend = ($cpustart + $cores - 1) if $cores && $cores > 1;
 261                 my $cpus = $cpustart;
 262                 $cpus .= "-$cpuend" if $cpuend;
 263
 264                 my $mem_object = print_mem_object($conf, "ram-node$i", $numa_memory);
 265
 266                 push @$cmd, '-object', $mem_object;
 267                 push @$cmd, '-numa', "node,nodeid=$i,cpus=$cpus,memdev=ram-node$i";
 268             }
 269         }
 270     }
 271
 272     if ($hotplug_features->{memory}) {
 273         foreach_dimm($conf, $vmid, $memory, $sockets, sub {
 274             my ($conf, $vmid, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
 275
 276             my $mem_object = print_mem_object($conf, "mem-$name", $dimm_size);
 277
 278             push @$cmd, "-object" , $mem_object;
 279             push @$cmd, "-device", "pc-dimm,id=$name,memdev=mem-$name,node=$numanode";
 280
 281             #if dimm_memory is not aligned to dimm map
 282             if($current_size > $memory) {
 283                  $conf->{memory} = $current_size;
 284                  PVE::QemuConfig->write_config($vmid, $conf);
 285             }
 286         });
 287     }
 288 }
 289
 290 sub print_mem_object {
 291     my ($conf, $id, $size) = @_;
 292
 293     if ($conf->{hugepages}) {
 294
 295         my $hugepages_size = hugepages_size($conf, $size);
 296         my $path = hugepages_mount_path($hugepages_size);
 297
 298         return "memory-backend-file,id=$id,size=${size}M,mem-path=$path,share=on,prealloc=yes";
 299     } else {
 300         return "memory-backend-ram,id=$id,size=${size}M";
 301     }
 302
 303 }
 304
 305 sub print_numa_hostnodes {
 306     my ($hostnodelists) = @_;
 307
 308     my $hostnodes;
 309     foreach my $hostnoderange (@$hostnodelists) {
 310         my ($start, $end) = @$hostnoderange;
 311         $hostnodes .= ',' if $hostnodes;
 312         $hostnodes .= $start;
 313         $hostnodes .= "-$end" if defined($end);
 314         $end //= $start;
 315         for (my $i = $start; $i <= $end; ++$i ) {
 316             die "host NUMA node$i doesn't exist\n" if ! -d "/sys/devices/system/node/node$i/";
 317         }
 318     }
 319     return $hostnodes;
 320 }
 321
 322 sub hugepages_mount {
 323
 324    my $mountdata = PVE::ProcFSTools::parse_proc_mounts();
 325
 326    foreach my $size (qw(2048 1048576)) {
 327         return if (! -d "/sys/kernel/mm/hugepages/hugepages-${size}kB");
 328
 329         my $path = "/run/hugepages/kvm/${size}kB";
 330
 331         my $found = grep {
 332             $_->[2] =~ /^hugetlbfs/ &&
 333             $_->[1] eq $path
 334         } @$mountdata;
 335
 336         if (!$found) {
 337
 338             File::Path::make_path($path) if (!-d $path);
 339             my $cmd = ['/bin/mount', '-t', 'hugetlbfs', '-o', "pagesize=${size}k", 'hugetlbfs', $path];
 340             run_command($cmd, errmsg => "hugepage mount error");
 341         }
 342    }
 343 }
 344
 345 sub hugepages_mount_path {
 346    my ($size) = @_;
 347
 348    $size = $size * 1024;
 349    return "/run/hugepages/kvm/${size}kB";
 350
 351 }
 352
 353 sub hugepages_nr {
 354   my ($size, $hugepages_size) = @_;
 355
 356   return $size / $hugepages_size;
 357 }
 358
 359 sub hugepages_size {
 360    my ($conf, $size) = @_;
 361
 362    die "hugepages option is not enabled" if !$conf->{hugepages};
 363
 364    if ($conf->{hugepages} eq 'any') {
 365
 366         #try to use 1GB if available && memory size is matching
 367         if (-d "/sys/kernel/mm/hugepages/hugepages-1048576kB" && ($size % 1024 == 0)) {
 368             return 1024;
 369         } else {
 370             return 2;
 371         }
 372
 373    } else {
 374
 375         my $hugepagesize = $conf->{hugepages} * 1024 . "kB";
 376
 377         if (! -d "/sys/kernel/mm/hugepages/hugepages-$hugepagesize") {
 378                 die "your system doesn't support hugepages of $hugepagesize";
 379         }
 380         die "Memory size $size is not a multiple of the requested hugepages size $hugepagesize" if ($size % $conf->{hugepages}) != 0;
 381         return $conf->{hugepages};
 382    }
 383
 384 }
 385
 386 sub hugepages_topology {
 387     my ($conf) = @_;
 388
 389     my $hugepages_topology = {};
 390
 391     return if !$conf->{numa};
 392
 393     my $defaults = PVE::QemuServer::load_defaults();
 394     my $memory = $conf->{memory} || $defaults->{memory};
 395     my $static_memory = 0;
 396     my $sockets = 1;
 397     $sockets = $conf->{smp} if $conf->{smp}; # old style - no longer iused
 398     $sockets = $conf->{sockets} if $conf->{sockets};
 399     my $numa_custom_topology = undef;
 400     my $hotplug_features = PVE::QemuServer::parse_hotplug_features(defined($conf->{hotplug}) ? $conf->{hotplug} : '1');
 401
 402     if ($hotplug_features->{memory}) {
 403         $static_memory = $STATICMEM;
 404         $static_memory = $static_memory * $sockets if ($conf->{hugepages} && $conf->{hugepages} == 1024);
 405     } else {
 406         $static_memory = $memory;
 407     }
 408
 409     #custom numa topology
 410     for (my $i = 0; $i < $MAX_NUMA; $i++) {
 411         next if !$conf->{"numa$i"};
 412         my $numa = PVE::QemuServer::parse_numa($conf->{"numa$i"});
 413         next if !$numa;
 414
 415         $numa_custom_topology = 1;
 416         my $numa_memory = $numa->{memory};
 417         my $hostnodelists = $numa->{hostnodes};
 418         my $hostnodes = print_numa_hostnodes($hostnodelists);
 419
 420         die "more than 1 hostnode value in numa node is not supported when hugepages are enabled" if $hostnodes !~ m/^(\d)$/;
 421         my $hugepages_size = hugepages_size($conf, $numa_memory);
 422         $hugepages_topology->{$hugepages_size}->{$hostnodes} += hugepages_nr($numa_memory, $hugepages_size);
 423
 424     }
 425
 426     #if no custom numa tology, we split memory and cores across numa nodes
 427     if(!$numa_custom_topology) {
 428
 429         my $numa_memory = ($static_memory / $sockets);
 430
 431         for (my $i = 0; $i < $sockets; $i++)  {
 432
 433             my $hugepages_size = hugepages_size($conf, $numa_memory);
 434             $hugepages_topology->{$hugepages_size}->{$i} += hugepages_nr($numa_memory, $hugepages_size);
 435         }
 436     }
 437
 438     if ($hotplug_features->{memory}) {
 439         foreach_dimm($conf, undef, $memory, $sockets, sub {
 440             my ($conf, undef, $name, $dimm_size, $numanode, $current_size, $memory) = @_;
 441
 442             my $hugepages_size = hugepages_size($conf, $dimm_size);
 443             $hugepages_topology->{$hugepages_size}->{$numanode} += hugepages_nr($dimm_size, $hugepages_size);
 444         });
 445     }
 446
 447     return $hugepages_topology;
 448 }
 449
 450 sub hugepages_host_topology {
 451
 452     #read host hugepages
 453     my $hugepages_host_topology = {};
 454
 455     dir_glob_foreach("/sys/devices/system/node/", 'node(\d+)', sub {
 456         my ($nodepath, $numanode) = @_;
 457
 458         dir_glob_foreach("/sys/devices/system/node/$nodepath/hugepages/", 'hugepages\-(\d+)kB', sub {
 459             my ($hugepages_path, $hugepages_size) = @_;
 460
 461             $hugepages_size = $hugepages_size / 1024;
 462             my $hugepages_nr = PVE::Tools::file_read_firstline("/sys/devices/system/node/$nodepath/hugepages/$hugepages_path/nr_hugepages");
 463             $hugepages_host_topology->{$hugepages_size}->{$numanode} = $hugepages_nr;
 464         });
 465     });
 466
 467     return $hugepages_host_topology;
 468 }
 469
 470 sub hugepages_allocate {
 471     my ($hugepages_topology, $hugepages_host_topology) = @_;
 472
 473     #allocate new hupages if needed
 474     foreach my $size (sort keys %$hugepages_topology) {
 475
 476         my $nodes = $hugepages_topology->{$size};
 477
 478         foreach my $numanode (keys %$nodes) {
 479
 480             my $hugepages_size = $size * 1024;
 481             my $hugepages_requested = $hugepages_topology->{$size}->{$numanode};
 482             my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";
 483             my $hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
 484             my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");
 485
 486             if ($hugepages_requested > $hugepages_free) {
 487                 my $hugepages_needed = $hugepages_requested - $hugepages_free;
 488                 PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr + $hugepages_needed);
 489                 #verify that is correctly allocated
 490                 $hugepages_free = PVE::Tools::file_read_firstline($path."free_hugepages");
 491                 if ($hugepages_free < $hugepages_requested) {
 492                     #rollback to initial host config
 493                     hugepages_reset($hugepages_host_topology);
 494                     die "hugepage allocation failed";
 495                 }
 496             }
 497
 498         }
 499     }
 500
 501 }
 502
 503 sub hugepages_pre_deallocate {
 504     my ($hugepages_topology) = @_;
 505
 506     foreach my $size (sort keys %$hugepages_topology) {
 507
 508         my $hugepages_size = $size * 1024;
 509         my $path = "/sys/kernel/mm/hugepages/hugepages-${hugepages_size}kB/";
 510         my $hugepages_nr = PVE::Tools::file_read_firstline($path."nr_hugepages");
 511         PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", 0);
 512     }
 513 }
 514
 515 sub hugepages_reset {
 516     my ($hugepages_topology) = @_;
 517
 518     foreach my $size (sort keys %$hugepages_topology) {
 519
 520         my $nodes = $hugepages_topology->{$size};
 521         foreach my $numanode (keys %$nodes) {
 522
 523             my $hugepages_nr = $hugepages_topology->{$size}->{$numanode};
 524             my $hugepages_size = $size * 1024;
 525             my $path = "/sys/devices/system/node/node${numanode}/hugepages/hugepages-${hugepages_size}kB/";
 526
 527             PVE::ProcFSTools::write_proc_entry($path."nr_hugepages", $hugepages_nr);
 528         }
 529     }
 530 }
 531
 532 sub hugepages_update_locked {
 533     my ($code, @param) = @_;
 534
 535     my $timeout = 60; #could be long if a lot of hugepages need to be alocated
 536
 537     my $lock_filename = "/var/lock/hugepages.lck";
 538
 539     my $res = lock_file($lock_filename, $timeout, $code, @param);
 540     die $@ if $@;
 541
 542     return $res;
 543 }
 544 1;
 545