Make text section 2MB aligned for hugepages.

chromeos/hugepage_text/hugepage_text.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 // Author: Ken Chen <kenchen@google.com>
 //
 // hugepage text library to remap process executable segment with hugepages.
 
 #include "chromeos/hugepage_text/hugepage_text.h"
 
 #include <link.h>
@@ skipping 18 matching lines @@
 
 const int kHpageShift = 21;
 const int kHpageSize = (1 << kHpageShift);
 const int kHpageMask = (~(kHpageSize - 1));
 
 const int kProtection = (PROT_READ | PROT_WRITE);
 const int kMmapFlags = (MAP_ANONYMOUS | MAP_SHARED);
 const int kMmapHtlbFlags = (kMmapFlags | MAP_HUGETLB);
 const int kMremapFlags = (MREMAP_MAYMOVE | MREMAP_FIXED);
 
-// The number of hugepages we want to use to map chrome text section
-// to hugepages. With the help of AutoFDO, the hot functions are grouped
-// in to a small area of the binary.
-const int kNumHugePages = 15;
-
 // mremap syscall is always supported for small page segment on all kernels.
 // However, it is not the case for hugepage.
 // If not used carefully, mremap() a hugepage segment directly onto small page
 // text segment will cause irreversible damage to the existing text mapping
 // and cause process to segfault. This function will dynamically at run time
 // determine whether a process can safely execute mremap on a hugepage segment
 // without taking the process down.
 //
 // Inputs: none
 // Return: true if mremap on hugepage segment is supported on the host OS.
@@ skipping 70 matching lines @@
 // backing physical memory will be changed from small page to hugetlb page.
 //
 // Inputs: vaddr, the starting virtual address to remap to hugepage
 //         hsize, size of the memory segment to remap in bytes
 // Return: none
 // Effect: physical backing page changed from small page to hugepage. If there
 //         are error condition, the remapping operation is aborted.
 static void MremapHugetlbText(void* vaddr, const size_t hsize) {
   void* haddr = MAP_FAILED;
 
   if ((reinterpret_cast<intptr_t>(vaddr) & ~kHpageMask) == 0 &&

[rickyz (no longer on Chrome), 2016/02/03 21:01:31]

You can probably just DCHECK_EQ(0, reinterpret_cast<uintptr_t>(vaddr) &
~kHpageMask) in this function now

[yunlian, 2016/02/03 21:21:51]

What is the difference between the expression and the DCHECK_EQ?
My understanding is DCHECK_EQ can store the result in the log, it that
right?

[rickyz (no longer on Chrome), 2016/02/03 21:28:24]

On debug builds, DCHECK would cause a crash if the condition isn't true. With
this change, it looks like MremapHugetlbText should only ever be called with a
hugepage aligned address, so I was suggesting that instead of checking for a
condition that should be always true, you could just make it a requirement of
the function (and assert that the requirement is satisfied with a DCHECK).

[yunlian, 2016/02/03 21:34:57]

Done.

       HugetlbMremapSupported()) {
     // Try anon hugepage from static hugepage pool only if the source address
     // is hugepage aligned, otherwise, mremap below has non-recoverable error.
     haddr = mmap(NULL, hsize, kProtection, kMmapHtlbFlags, 0, 0);
   }
 
   if (haddr == MAP_FAILED) {
     PLOG(INFO) << "static hugepage not available, trying transparent hugepage";
     haddr = GetTransparentHugepageMapping(hsize);
     if (haddr == NULL)
@@ skipping 20 matching lines @@
 }
 
 // Top level text remapping function.
 //
 // Inputs: vaddr, the starting virtual address to remap to hugepage
 //         hsize, size of the memory segment to remap in bytes
 // Return: none
 // Effect: physical backing page changed from small page to hugepage. If there
 //         are error condition, the remaping operation is aborted.
 static void RemapHugetlbText(void* vaddr, const size_t segsize) {
-  int hsize = segsize;
-  if (segsize > kHpageSize * kNumHugePages)
-    hsize = kHpageSize * kNumHugePages;
+  // remove unaligned head regions
+  size_t head_gap = (kHpageSize - static_cast<size_t>(vaddr) % kHpageSize)
+                    % kHpageSize;
+  size_t addr = static_cast<size_t>(vaddr) + head_gap;
+
+  int hsize = segsize - head_gap;
   hsize = hsize & kHpageMask;
 
   if (hsize == 0)
     return;
 
-  MremapHugetlbText(vaddr, hsize);
+  MremapHugetlbText(static_cast<void *>(addr), hsize);
 }
 
 // For a given ELF program header descriptor, iterates over all segments within
 // it and find the first segment that has PT_LOAD and is executable, call
 // RemapHugetlbText().
 //
 // Inputs: info: pointer to a struct dl_phdr_info that describes the DSO.
 //         size: size of the above structure (not used in this function).
 //         data: user param (not used in this function).
 // Return: always return true.  The value is propagated by dl_iterate_phdr().
@@ skipping 18 matching lines @@
 
 // Main library function.  This function will iterate all ELF segments and
 // attempt to remap text segment from small page to hugepage.
 // If remapping is successful.  All error conditions are soft fail such that
 // effect will be rolled back and remap operation will be aborted.
 void ReloadElfTextInHugePages(void) {
   dl_iterate_phdr(FilterElfHeader, 0);
 }
 
 }  // namespace chromeos