From 6b9dd7bb070129123d25d3f30057fd7c44ff40a8 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Thu, 20 Jun 2019 22:23:11 +0100
Subject: [PATCH 01/18] src: large pages option: FreeBSD support proposal

Enabling on amd64 and as Linux, are 2MB large.
The ELF section linkage script is compatible only with GNU ld.

PR-URL: https://github.com/nodejs/node/pull/28331
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 configure.py                       |  17 ++--
 node.gyp                           |   2 +-
 src/large_pages/node_large_page.cc | 121 ++++++++++++++++++++++++++---
 3 files changed, 122 insertions(+), 18 deletions(-)

diff --git a/configure.py b/configure.py
index 22861a10eeac54..15a3cf176e08b3 100755
--- a/configure.py
+++ b/configure.py
@@ -1025,22 +1025,23 @@ def configure_node(o):
   else:
     o['variables']['node_use_dtrace'] = 'false'
 
-  if options.node_use_large_pages and flavor != 'linux':
+  if options.node_use_large_pages and not flavor in ('linux', 'freebsd'):
     raise Exception(
       'Large pages are supported only on Linux Systems.')
-  if options.node_use_large_pages and flavor == 'linux':
+  if options.node_use_large_pages and flavor in ('linux', 'freebsd'):
     if options.shared or options.enable_static:
       raise Exception(
         'Large pages are supported only while creating node executable.')
     if target_arch!="x64":
       raise Exception(
         'Large pages are supported only x64 platform.')
-    # Example full version string: 2.6.32-696.28.1.el6.x86_64
-    FULL_KERNEL_VERSION=os.uname()[2]
-    KERNEL_VERSION=FULL_KERNEL_VERSION.split('-')[0]
-    if KERNEL_VERSION < "2.6.38":
-      raise Exception(
-        'Large pages need Linux kernel version >= 2.6.38')
+    if flavor == 'linux':
+      # Example full version string: 2.6.32-696.28.1.el6.x86_64
+      FULL_KERNEL_VERSION=os.uname()[2]
+      KERNEL_VERSION=FULL_KERNEL_VERSION.split('-')[0]
+      if KERNEL_VERSION < "2.6.38" and flavor == 'linux':
+        raise Exception(
+          'Large pages need Linux kernel version >= 2.6.38')
   o['variables']['node_use_large_pages'] = b(options.node_use_large_pages)
 
   if options.no_ifaddrs:
diff --git a/node.gyp b/node.gyp
index dd60ea4a937691..1676935214b254 100644
--- a/node.gyp
+++ b/node.gyp
@@ -606,7 +606,7 @@
             'src/tls_wrap.h'
           ],
         }],
-        [ 'node_use_large_pages=="true" and OS=="linux"', {
+        [ 'node_use_large_pages=="true" and OS in "linux freebsd"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
           # The current implementation of Large Pages is under Linux.
           # Other implementations are possible but not currently supported.
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 4b860d9ccb47ca..79cc013deef402 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -20,22 +20,32 @@
 //
 // SPDX-License-Identifier: MIT
 
-#include <errno.h>
+#include "node_large_page.h"
+#include "util.h"
+#include "uv.h"
+
 #include <fcntl.h>  // _O_RDWR
-#include <limits.h>  // PATH_MAX
-#include <locale.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
 #include <sys/types.h>
 #include <sys/mman.h>
+#if defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#include <sys/user.h>
+#endif
+#include <unistd.h>  // readlink
+
+#include <cerrno>   // NOLINT(build/include)
+#include <climits>  // PATH_MAX
+#include <clocale>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
 #include <string>
 #include <fstream>
 #include <iostream>
 #include <sstream>
-#include <unistd.h>  // readlink
+#include <vector>
 
 // The functions in this file map the text segment of node into 2M pages.
 // The algorithm is simple
@@ -85,6 +95,7 @@ inline int64_t hugepage_align_down(int64_t addr) {
 // This is also handling the case where the first line is not the binary
 
 static struct text_region FindNodeTextRegion() {
+#if defined(__linux__)
   std::ifstream ifs;
   std::string map_line;
   std::string permission;
@@ -138,9 +149,68 @@ static struct text_region FindNodeTextRegion() {
   }
 
   ifs.close();
+#elif defined(__FreeBSD__)
+  struct text_region nregion;
+  nregion.found_text_region = false;
+
+  std::string exename;
+  {
+    char selfexe[PATH_MAX];
+    size_t count = sizeof(selfexe);
+    if (uv_exepath(selfexe, &count))
+      return nregion;
+
+    exename = std::string(selfexe, count);
+  }
+
+  size_t numpg;
+  int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid()};
+  const size_t miblen = arraysize(mib);
+  if (sysctl(mib, miblen, nullptr, &numpg, nullptr, 0) == -1) {
+    return nregion;
+  }
+
+  // for struct kinfo_vmentry
+  numpg = numpg * 4 / 3;
+  auto alg = std::vector<char>(numpg);
+
+  if (sysctl(mib, miblen, alg.data(), &numpg, nullptr, 0) == -1) {
+    return nregion;
+  }
+
+  char* start = alg.data();
+  char* end = start + numpg;
+
+  while (start < end) {
+    kinfo_vmentry* entry = reinterpret_cast<kinfo_vmentry*>(start);
+    const size_t cursz = entry->kve_structsize;
+    if (cursz == 0) {
+      break;
+    }
+
+    if (entry->kve_path[0] == '\0') {
+      continue;
+    }
+    bool excmapping = ((entry->kve_protection & KVME_PROT_READ) &&
+     (entry->kve_protection & KVME_PROT_EXEC));
+
+    if (!strcmp(exename.c_str(), entry->kve_path) && excmapping) {
+      size_t size = entry->kve_end - entry->kve_start;
+      nregion.found_text_region = true;
+      nregion.from =
+         reinterpret_cast<char*>(hugepage_align_up(entry->kve_start));
+      nregion.to =
+         reinterpret_cast<char*>(hugepage_align_down(entry->kve_end));
+      nregion.total_hugepages = size / hps;
+      break;
+    }
+    start += cursz;
+  }
+#endif
   return nregion;
 }
 
+#if defined(__linux__)
 static bool IsTransparentHugePagesEnabled() {
   std::ifstream ifs;
 
@@ -168,6 +238,19 @@ static bool IsTransparentHugePagesEnabled() {
   ifs.close();
   return ret_status;
 }
+#elif defined(__FreeBSD__)
+static bool IsSuperPagesEnabled() {
+  // It is enabled by default on amd64
+  unsigned int super_pages = 0;
+  size_t super_pages_length = sizeof(super_pages);
+  if (sysctlbyname("vm.pmap.pg_ps_enabled", &super_pages,
+      &super_pages_length, nullptr, 0) == -1 ||
+      super_pages < 1) {
+    return false;
+  }
+  return true;
+}
+#endif
 
 // Moving the text region to large pages. We need to be very careful.
 // 1: This function itself should not be moved.
@@ -203,6 +286,7 @@ MoveTextRegionToLargePages(const text_region& r) {
 
   memcpy(nmem, r.from, size);
 
+#if defined(__linux__)
 // We already know the original page is r-xp
 // (PROT_READ, PROT_EXEC, MAP_PRIVATE)
 // We want PROT_WRITE because we are writing into it.
@@ -230,6 +314,17 @@ MoveTextRegionToLargePages(const text_region& r) {
 
     return -1;
   }
+#elif defined(__FreeBSD__)
+  tmem = mmap(start, size,
+              PROT_READ | PROT_WRITE | PROT_EXEC,
+              MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED |
+              MAP_ALIGNED_SUPER, -1 , 0);
+  if (tmem == MAP_FAILED) {
+    PrintSystemError(errno);
+    munmap(nmem, size);
+    return -1;
+  }
+#endif
 
   memcpy(start, nmem, size);
   ret = mprotect(start, size, PROT_READ | PROT_EXEC);
@@ -263,14 +358,22 @@ int MapStaticCodeToLargePages() {
     return -1;
   }
 
+#if defined(__linux__)
   if (r.from > reinterpret_cast<void*>(&MoveTextRegionToLargePages))
     return MoveTextRegionToLargePages(r);
 
   return -1;
+#elif defined(__FreeBSD__)
+  return MoveTextRegionToLargePages(r);
+#endif
 }
 
 bool IsLargePagesEnabled() {
+#if defined(__linux__)
   return IsTransparentHugePagesEnabled();
+#else
+  return IsSuperPagesEnabled();
+#endif
 }
 
 }  // namespace node

From 6d93a8a0c2c887bf311b0346d57ef99191e44d92 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Fri, 21 Jun 2019 11:16:05 +0200
Subject: [PATCH 02/18] src: readlink("/proc/self/exe") -> uv_exename()

This commit also adds error handling. A THP-enabled build terminated
with an out-of-memory error on a system without /proc because it cast
the -1 from readlink() to size_t (i.e. ULONG_MAX) and then tried to
allocate a string of that size.

PR-URL: https://github.com/nodejs/node/pull/28333
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/large_pages/node_large_page.cc | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 79cc013deef402..e6829708aa0803 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -115,8 +115,12 @@ static struct text_region FindNodeTextRegion() {
   std::string exename;
   {
       char selfexe[PATH_MAX];
-      ssize_t count = readlink("/proc/self/exe", selfexe, PATH_MAX);
-      exename = std::string(selfexe, count);
+
+      size_t size = sizeof(selfexe);
+      if (uv_exepath(selfexe, &size))
+        return nregion;
+
+      exename = std::string(selfexe, size);
   }
 
   while (std::getline(ifs, map_line)) {

From bbaa065a25e71df574ac8c2b86809370aebff399 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Wed, 17 Jul 2019 19:26:14 +0100
Subject: [PATCH 03/18] src: large pages fix FreeBSD fix region size

Makes the size aligned to huge page size by
calculating it from the aligned lower and upper
boundary of the executable address.

PR-URL: https://github.com/nodejs/node/pull/28735
Reviewed-By: Rod Vagg <rod@vagg.org>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 src/large_pages/node_large_page.cc | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index e6829708aa0803..d87ccfaa26abcd 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -199,12 +199,14 @@ static struct text_region FindNodeTextRegion() {
      (entry->kve_protection & KVME_PROT_EXEC));
 
     if (!strcmp(exename.c_str(), entry->kve_path) && excmapping) {
-      size_t size = entry->kve_end - entry->kve_start;
+      char* estart =
+        reinterpret_cast<char*>(hugepage_align_up(entry->kve_start));
+      char* eend =
+        reinterpret_cast<char*>(hugepage_align_down(entry->kve_end));
+      size_t size = eend - estart;
       nregion.found_text_region = true;
-      nregion.from =
-         reinterpret_cast<char*>(hugepage_align_up(entry->kve_start));
-      nregion.to =
-         reinterpret_cast<char*>(hugepage_align_down(entry->kve_end));
+      nregion.from = estart;
+      nregion.to = eend;
       nregion.total_hugepages = size / hps;
       break;
     }

From 86419d831b464a9c040b44744e7d4574f7fd68dc Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Fri, 2 Aug 2019 11:57:02 +0100
Subject: [PATCH 04/18] build: enable linux large pages LLVM lld linkage
 support

The custom linker script is compatible with GNU ld only.
As such, providin a new expliciting option to redirect to
a different one. lld seems unable to migrate this
large section w/o segfaulting so providing only the
base address anchor for now.

PR-URL: https://github.com/nodejs/node/pull/28938
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 configure.py                           |  6 ++++++
 node.gypi                              | 14 +++++++++++++-
 src/large_pages/ld.implicit.script.lld |  3 +++
 3 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 src/large_pages/ld.implicit.script.lld

diff --git a/configure.py b/configure.py
index 15a3cf176e08b3..4867e4d66ff5a8 100755
--- a/configure.py
+++ b/configure.py
@@ -398,6 +398,11 @@
     help='build with Large Pages support. This feature is supported only on Linux kernel' +
          '>= 2.6.38 with Transparent Huge pages enabled')
 
+parser.add_option('--use-largepages-script-lld',
+    action='store_true',
+    dest='node_use_large_pages_script_lld',
+    help='link against the LLVM ld linker script. Implies -fuse-ld=lld in the linker flags')
+
 intl_optgroup.add_option('--with-intl',
     action='store',
     dest='with_intl',
@@ -1043,6 +1048,7 @@ def configure_node(o):
         raise Exception(
           'Large pages need Linux kernel version >= 2.6.38')
   o['variables']['node_use_large_pages'] = b(options.node_use_large_pages)
+  o['variables']['node_use_large_pages_script_lld'] = b(options.node_use_large_pages_script_lld)
 
   if options.no_ifaddrs:
     o['defines'] += ['SUNOS_NO_IFADDRS']
diff --git a/node.gypi b/node.gypi
index 466a1746811cfa..d9285a966968b7 100644
--- a/node.gypi
+++ b/node.gypi
@@ -304,12 +304,24 @@
       'ldflags': [ '-Wl,-z,relro',
                    '-Wl,-z,now' ]
     }],
-    [ 'OS=="linux" and target_arch=="x64" and node_use_large_pages=="true"', {
+    [ 'OS=="linux" and '
+      'target_arch=="x64" and '
+      'node_use_large_pages=="true" and '
+      'node_use_large_pages_script_lld=="false"', {
       'ldflags': [
         '-Wl,-T',
         '<!(realpath src/large_pages/ld.implicit.script)',
       ]
     }],
+    [ 'OS=="linux" and '
+      'target_arch=="x64" and '
+      'node_use_large_pages=="true" and '
+      'node_use_large_pages_script_lld=="true"', {
+      'ldflags': [
+        '-Wl,-T',
+        '<!(realpath src/large_pages/ld.implicit.script.lld)',
+      ]
+    }],
     [ 'node_use_openssl=="true"', {
       'defines': [ 'HAVE_OPENSSL=1' ],
       'conditions': [
diff --git a/src/large_pages/ld.implicit.script.lld b/src/large_pages/ld.implicit.script.lld
new file mode 100644
index 00000000000000..b85510bcf07eeb
--- /dev/null
+++ b/src/large_pages/ld.implicit.script.lld
@@ -0,0 +1,3 @@
+  PROVIDE (__nodetext = .);
+  PROVIDE (_nodetext = .);
+  PROVIDE (nodetext = .);

From 01de6c22db3123e9436545254d5b9953fabc24df Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Mon, 5 Aug 2019 14:00:15 +0100
Subject: [PATCH 05/18] src: add large page support for macOS

Proposal to bring the support for this platform.
We assume the pse36 cpu flag is present for 2MB
large page support present in recent years
in mac line (not to be backported to 10.x anyway).
Recommended better for mac production servers rather
than casual mac books.

PR-URL: https://github.com/nodejs/node/pull/28977
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 configure.py                       |   8 ++-
 node.gyp                           |   2 +-
 src/large_pages/node_large_page.cc | 105 +++++++++++++++++++++++------
 3 files changed, 90 insertions(+), 25 deletions(-)

diff --git a/configure.py b/configure.py
index 4867e4d66ff5a8..e45606a0ad030a 100755
--- a/configure.py
+++ b/configure.py
@@ -1030,16 +1030,18 @@ def configure_node(o):
   else:
     o['variables']['node_use_dtrace'] = 'false'
 
-  if options.node_use_large_pages and not flavor in ('linux', 'freebsd'):
+  if options.node_use_large_pages and not flavor in ('linux', 'freebsd', 'mac'):
     raise Exception(
-      'Large pages are supported only on Linux Systems.')
-  if options.node_use_large_pages and flavor in ('linux', 'freebsd'):
+      'Large pages are supported only on Linux, FreeBSD and MacOS Systems.')
+  if options.node_use_large_pages and flavor in ('linux', 'freebsd', 'mac'):
     if options.shared or options.enable_static:
       raise Exception(
         'Large pages are supported only while creating node executable.')
     if target_arch!="x64":
       raise Exception(
         'Large pages are supported only x64 platform.')
+    if flavor == 'mac':
+      info('macOS server with 32GB or more is recommended')
     if flavor == 'linux':
       # Example full version string: 2.6.32-696.28.1.el6.x86_64
       FULL_KERNEL_VERSION=os.uname()[2]
diff --git a/node.gyp b/node.gyp
index 1676935214b254..d3e766ebaa3964 100644
--- a/node.gyp
+++ b/node.gyp
@@ -606,7 +606,7 @@
             'src/tls_wrap.h'
           ],
         }],
-        [ 'node_use_large_pages=="true" and OS in "linux freebsd"', {
+        [ 'node_use_large_pages=="true" and OS in "linux freebsd mac"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
           # The current implementation of Large Pages is under Linux.
           # Other implementations are possible but not currently supported.
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index d87ccfaa26abcd..1e75f2af44fbf2 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -30,6 +30,8 @@
 #if defined(__FreeBSD__)
 #include <sys/sysctl.h>
 #include <sys/user.h>
+#elif defined(__APPLE__)
+#include <mach/vm_map.h>
 #endif
 #include <unistd.h>  // readlink
 
@@ -47,6 +49,13 @@
 #include <sstream>
 #include <vector>
 
+// Define MAP_ANONYMOUS as an alias for MAP_ANON to support OSX 10.10.
+#if defined(__APPLE__)
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+#endif
+
 // The functions in this file map the text segment of node into 2M pages.
 // The algorithm is simple
 // Find the text region of node binary in memory
@@ -212,6 +221,42 @@ static struct text_region FindNodeTextRegion() {
     }
     start += cursz;
   }
+#elif defined(__APPLE__)
+  struct text_region nregion;
+  nregion.found_text_region = false;
+  struct vm_region_submap_info_64 map;
+  mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;
+  vm_address_t addr = 0UL;
+  vm_size_t size = 0;
+  natural_t depth = 1;
+
+  while (true) {
+    if (vm_region_recurse_64(mach_task_self(), &addr, &size, &depth,
+                             reinterpret_cast<vm_region_info_64_t>(&map),
+                             &count) != KERN_SUCCESS) {
+      break;
+    }
+
+    if (map.is_submap) {
+      depth++;
+    } else {
+      char* start = reinterpret_cast<char*>(hugepage_align_up(addr));
+      char* end = reinterpret_cast<char*>(hugepage_align_down(addr+size));
+      size_t esize = end - start;
+
+      if (end > start && (map.protection & VM_PROT_READ) != 0 &&
+          (map.protection & VM_PROT_EXECUTE) != 0) {
+        nregion.found_text_region = true;
+        nregion.from = start;
+        nregion.to = end;
+        nregion.total_hugepages = esize / hps;
+        break;
+      }
+
+      addr += size;
+      size = 0;
+    }
+  }
 #endif
   return nregion;
 }
@@ -267,11 +312,15 @@ static bool IsSuperPagesEnabled() {
 // 2: This function should not call any function(s) that might be moved.
 // a. map a new area and copy the original code there
 // b. mmap using the start address with MAP_FIXED so we get exactly
-//    the same virtual address
+//    the same virtual address (except on macOS).
 // c. madvise with MADV_HUGE_PAGE
 // d. If successful copy the code there and unmap the original region
 int
+#if !defined(__APPLE__)
 __attribute__((__section__(".lpstub")))
+#else
+__attribute__((__section__("__TEXT,__lpstub")))
+#endif
 __attribute__((__aligned__(hps)))
 __attribute__((__noinline__))
 MoveTextRegionToLargePages(const text_region& r) {
@@ -289,6 +338,9 @@ MoveTextRegionToLargePages(const text_region& r) {
     PrintSystemError(errno);
     return -1;
   }
+  OnScopeLeave munmap_on_return([nmem, size]() {
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
+  });
 
   memcpy(nmem, r.from, size);
 
@@ -302,7 +354,6 @@ MoveTextRegionToLargePages(const text_region& r) {
               MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1 , 0);
   if (tmem == MAP_FAILED) {
     PrintSystemError(errno);
-    munmap(nmem, size);
     return -1;
   }
 
@@ -313,11 +364,6 @@ MoveTextRegionToLargePages(const text_region& r) {
     if (ret == -1) {
       PrintSystemError(errno);
     }
-    ret = munmap(nmem, size);
-    if (ret == -1) {
-      PrintSystemError(errno);
-    }
-
     return -1;
   }
 #elif defined(__FreeBSD__)
@@ -327,32 +373,46 @@ MoveTextRegionToLargePages(const text_region& r) {
               MAP_ALIGNED_SUPER, -1 , 0);
   if (tmem == MAP_FAILED) {
     PrintSystemError(errno);
-    munmap(nmem, size);
     return -1;
   }
-#endif
-
-  memcpy(start, nmem, size);
-  ret = mprotect(start, size, PROT_READ | PROT_EXEC);
+#elif defined(__APPLE__)
+  // There is not enough room to reserve the mapping close
+  // to the region address so we content to give a hint
+  // without forcing the new address being closed to.
+  // We explicitally gives all permission since we plan
+  // to write into it.
+  tmem = mmap(start, size,
+              PROT_READ | PROT_WRITE | PROT_EXEC,
+              MAP_PRIVATE | MAP_ANONYMOUS,
+              VM_FLAGS_SUPERPAGE_SIZE_2MB, 0);
+  if (tmem == MAP_FAILED) {
+    PrintSystemError(errno);
+    return -1;
+  }
+  memcpy(tmem, nmem, size);
+  ret = mprotect(start, size, PROT_READ | PROT_WRITE | PROT_EXEC);
   if (ret == -1) {
     PrintSystemError(errno);
     ret = munmap(tmem, size);
     if (ret == -1) {
       PrintSystemError(errno);
     }
-    ret = munmap(nmem, size);
-    if (ret == -1) {
-      PrintSystemError(errno);
-    }
     return -1;
   }
+  memcpy(start, tmem, size);
+#else
+  memcpy(start, nmem, size);
+#endif
 
-  // Release the old/temporary mapped region
-  ret = munmap(nmem, size);
+  ret = mprotect(start, size, PROT_READ | PROT_EXEC);
   if (ret == -1) {
     PrintSystemError(errno);
+    ret = munmap(tmem, size);
+    if (ret == -1) {
+      PrintSystemError(errno);
+    }
+    return -1;
   }
-
   return ret;
 }
 
@@ -369,7 +429,7 @@ int MapStaticCodeToLargePages() {
     return MoveTextRegionToLargePages(r);
 
   return -1;
-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__APPLE__)
   return MoveTextRegionToLargePages(r);
 #endif
 }
@@ -377,8 +437,11 @@ int MapStaticCodeToLargePages() {
 bool IsLargePagesEnabled() {
 #if defined(__linux__)
   return IsTransparentHugePagesEnabled();
-#else
+#elif defined(__FreeBSD__)
   return IsSuperPagesEnabled();
+#elif defined(__APPLE__)
+  // pse-36 flag is present in recent mac x64 products.
+  return true;
 #endif
 }
 

From 2b373bd270567dfd6a0ac08e627c54cdf2081f45 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 9 Oct 2019 15:50:21 -0700
Subject: [PATCH 06/18] src: fix largepages regression

During the addition of macOS support for large pages, a `memcpy` ended
up under the wrong preprocessor directive. As a result, the newly
allocated large pages were not initialized with a copy of the text
section.

Thanks to Suresh Srinivas <suresh.srinivas@intel.com>!

PR-URL: https://github.com/nodejs/node/pull/29914
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
---
 src/large_pages/node_large_page.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 1e75f2af44fbf2..61d89b009ac5da 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -366,6 +366,7 @@ MoveTextRegionToLargePages(const text_region& r) {
     }
     return -1;
   }
+  memcpy(start, nmem, size);
 #elif defined(__FreeBSD__)
   tmem = mmap(start, size,
               PROT_READ | PROT_WRITE | PROT_EXEC,
@@ -400,8 +401,6 @@ MoveTextRegionToLargePages(const text_region& r) {
     return -1;
   }
   memcpy(start, tmem, size);
-#else
-  memcpy(start, nmem, size);
 #endif
 
   ret = mprotect(start, size, PROT_READ | PROT_EXEC);

From d5b5b227bdaaab191648e5769ea85785a81dda11 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 9 Oct 2019 13:27:26 -0700
Subject: [PATCH 07/18] src: refine maps parsing for large pages

Multiple sections may be marked as "r-xp" and with the executable's
path. We use the location of the `__nodetext` symbol added by the linker
script to ensure that the range we retrieve from the maps file does
indeed contain the Node.js text section.

Thanks to Suresh Srinivas <suresh.srinivas@intel.com>!

PR-URL: https://github.com/nodejs/node/pull/29973
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
---
 src/large_pages/node_large_page.cc | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 61d89b009ac5da..7e0fb5fcef47ef 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -90,11 +90,11 @@ static void PrintSystemError(int error) {
   return;
 }
 
-inline int64_t hugepage_align_up(int64_t addr) {
+inline uintptr_t hugepage_align_up(uintptr_t addr) {
   return (((addr) + (hps) - 1) & ~((hps) - 1));
 }
 
-inline int64_t hugepage_align_down(int64_t addr) {
+inline uintptr_t hugepage_align_down(uintptr_t addr) {
   return ((addr) & ~((hps) - 1));
 }
 
@@ -110,7 +110,7 @@ static struct text_region FindNodeTextRegion() {
   std::string permission;
   std::string dev;
   char dash;
-  int64_t  start, end, offset, inode;
+  uintptr_t start, end, offset, inode;
   struct text_region nregion;
 
   nregion.found_text_region = false;
@@ -145,18 +145,20 @@ static struct text_region FindNodeTextRegion() {
       std::string pathname;
       iss >> pathname;
       if (pathname == exename && permission == "r-xp") {
-        start = reinterpret_cast<uint64_t>(&__nodetext);
-        char* from = reinterpret_cast<char*>(hugepage_align_up(start));
-        char* to = reinterpret_cast<char*>(hugepage_align_down(end));
-
-        if (from < to) {
-          size_t size = to - from;
-          nregion.found_text_region = true;
-          nregion.from = from;
-          nregion.to = to;
-          nregion.total_hugepages = size / hps;
+        uintptr_t ntext = reinterpret_cast<uintptr_t>(&__nodetext);
+        if (ntext >= start && ntext < end) {
+          char* from = reinterpret_cast<char*>(hugepage_align_up(ntext));
+          char* to = reinterpret_cast<char*>(hugepage_align_down(end));
+
+          if (from < to) {
+            size_t size = to - from;
+            nregion.found_text_region = true;
+            nregion.from = from;
+            nregion.to = to;
+            nregion.total_hugepages = size / hps;
+          }
+          break;
         }
-        break;
       }
     }
   }

From b4d01ba466e9118481144048e2fc09cab2111323 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 13 Dec 2019 11:59:37 -0800
Subject: [PATCH 08/18] src: make --use-largepages a runtime option

Moves the option that instructs Node.js to-remap its static code to
large pages from a configure-time option to a runtime option. This
should make it easy to assess the performance impact of such a change
without having to custom-build.

PR-URL: https://github.com/nodejs/node/pull/30954
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: David Carlier <devnexen@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Co-authored-by: David Carlier <devnexen@gmail.com>
---
 configure.py                              | 33 -----------------------
 doc/api/cli.md                            | 17 ++++++++++++
 doc/node.1                                | 10 +++++++
 node.gyp                                  |  5 ++--
 node.gypi                                 |  6 ++---
 src/large_pages/node_large_page.cc        | 20 ++++++++------
 src/node.cc                               | 30 ++++++++++++++-------
 src/node_options.cc                       |  9 +++++++
 src/node_options.h                        |  1 +
 test/parallel/test-startup-large-pages.js | 29 ++++++++++++++++++++
 10 files changed, 102 insertions(+), 58 deletions(-)
 create mode 100644 test/parallel/test-startup-large-pages.js

diff --git a/configure.py b/configure.py
index e45606a0ad030a..5ac4122bdb54cc 100755
--- a/configure.py
+++ b/configure.py
@@ -392,17 +392,6 @@
     dest='with_etw',
     help='build with ETW (default is true on Windows)')
 
-parser.add_option('--use-largepages',
-    action='store_true',
-    dest='node_use_large_pages',
-    help='build with Large Pages support. This feature is supported only on Linux kernel' +
-         '>= 2.6.38 with Transparent Huge pages enabled')
-
-parser.add_option('--use-largepages-script-lld',
-    action='store_true',
-    dest='node_use_large_pages_script_lld',
-    help='link against the LLVM ld linker script. Implies -fuse-ld=lld in the linker flags')
-
 intl_optgroup.add_option('--with-intl',
     action='store',
     dest='with_intl',
@@ -1030,28 +1019,6 @@ def configure_node(o):
   else:
     o['variables']['node_use_dtrace'] = 'false'
 
-  if options.node_use_large_pages and not flavor in ('linux', 'freebsd', 'mac'):
-    raise Exception(
-      'Large pages are supported only on Linux, FreeBSD and MacOS Systems.')
-  if options.node_use_large_pages and flavor in ('linux', 'freebsd', 'mac'):
-    if options.shared or options.enable_static:
-      raise Exception(
-        'Large pages are supported only while creating node executable.')
-    if target_arch!="x64":
-      raise Exception(
-        'Large pages are supported only x64 platform.')
-    if flavor == 'mac':
-      info('macOS server with 32GB or more is recommended')
-    if flavor == 'linux':
-      # Example full version string: 2.6.32-696.28.1.el6.x86_64
-      FULL_KERNEL_VERSION=os.uname()[2]
-      KERNEL_VERSION=FULL_KERNEL_VERSION.split('-')[0]
-      if KERNEL_VERSION < "2.6.38" and flavor == 'linux':
-        raise Exception(
-          'Large pages need Linux kernel version >= 2.6.38')
-  o['variables']['node_use_large_pages'] = b(options.node_use_large_pages)
-  o['variables']['node_use_large_pages_script_lld'] = b(options.node_use_large_pages_script_lld)
-
   if options.no_ifaddrs:
     o['defines'] += ['SUNOS_NO_IFADDRS']
 
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 57e2f8e8f0fb46..7eb43c648e2167 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -480,6 +480,22 @@ environment variables.
 
 See `SSL_CERT_DIR` and `SSL_CERT_FILE`.
 
+### `--use-largepages=mode`
+<!-- YAML
+added: REPLACEME
+-->
+
+Re-map the Node.js static code to large memory pages at startup. If supported on
+the target system, this will cause the Node.js static code to be moved onto 2
+MiB pages instead of 4 KiB pages.
+
+The following values are valid for `mode`:
+* `off`: No mapping will be attempted. This is the default.
+* `on`: If supported by the OS, mapping will be attempted. Failure to map will
+  be ignored and a message will be printed to standard error.
+* `silent`: If supported by the OS, mapping will be attempted. Failure to map
+  will be ignored and will not be reported.
+
 ### `--v8-options`
 <!-- YAML
 added: v0.1.3
@@ -676,6 +692,7 @@ Node.js options that are allowed are:
 - `--track-heap-objects`
 - `--unhandled-rejections`
 - `--use-bundled-ca`
+- `--use-largepages`
 - `--use-openssl-ca`
 - `--v8-pool-size`
 - `--zero-fill-buffers`
diff --git a/doc/node.1 b/doc/node.1
index 36017c7e5247ee..c11840f9444af3 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -259,6 +259,16 @@ See
 and
 .Ev SSL_CERT_FILE .
 .
+.It Fl -use-largepages Ns = Ns Ar mode
+Re-map the Node.js static code to large memory pages at startup. If supported on
+the target system, this will cause the Node.js static code to be moved onto 2
+MiB pages instead of 4 KiB pages.
+.Pp
+.Ar mode
+must have one of the following values:
+`off` (the default value, meaning do not map), `on` (map and ignore failure,
+reporting it to stderr), or `silent` (map and silently ignore failure).
+.
 .It Fl -v8-options
 Print V8 command-line options.
 .
diff --git a/node.gyp b/node.gyp
index d3e766ebaa3964..42591107e5f75f 100644
--- a/node.gyp
+++ b/node.gyp
@@ -606,10 +606,9 @@
             'src/tls_wrap.h'
           ],
         }],
-        [ 'node_use_large_pages=="true" and OS in "linux freebsd mac"', {
+        [ 'OS in "linux freebsd mac" and '
+          'target_arch=="x64"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
-          # The current implementation of Large Pages is under Linux.
-          # Other implementations are possible but not currently supported.
           'sources': [
             'src/large_pages/node_large_page.cc',
             'src/large_pages/node_large_page.h'
diff --git a/node.gypi b/node.gypi
index d9285a966968b7..33ce674ec1f0fd 100644
--- a/node.gypi
+++ b/node.gypi
@@ -306,8 +306,7 @@
     }],
     [ 'OS=="linux" and '
       'target_arch=="x64" and '
-      'node_use_large_pages=="true" and '
-      'node_use_large_pages_script_lld=="false"', {
+      'llvm_version==0', {
       'ldflags': [
         '-Wl,-T',
         '<!(realpath src/large_pages/ld.implicit.script)',
@@ -315,8 +314,7 @@
     }],
     [ 'OS=="linux" and '
       'target_arch=="x64" and '
-      'node_use_large_pages=="true" and '
-      'node_use_large_pages_script_lld=="true"', {
+      'llvm_version!=0', {
       'ldflags': [
         '-Wl,-T',
         '<!(realpath src/large_pages/ld.implicit.script.lld)',
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 7e0fb5fcef47ef..610aa8f753587e 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -20,6 +20,7 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include "node_internals.h"
 #include "node_large_page.h"
 #include "util.h"
 #include "uv.h"
@@ -69,7 +70,7 @@
 // Map a new area and copy the original code there
 // Use mmap using the start address with MAP_FIXED so we get exactly the
 // same virtual address
-// Use madvise with MADV_HUGE_PAGE to use Anonymous 2M Pages
+// Use madvise with MADV_HUGEPAGE to use Anonymous 2M Pages
 // If successful copy the code there and unmap the original region.
 
 extern char __nodetext;
@@ -315,7 +316,7 @@ static bool IsSuperPagesEnabled() {
 // a. map a new area and copy the original code there
 // b. mmap using the start address with MAP_FIXED so we get exactly
 //    the same virtual address (except on macOS).
-// c. madvise with MADV_HUGE_PAGE
+// c. madvise with MADV_HUGEPAGE
 // d. If successful copy the code there and unmap the original region
 int
 #if !defined(__APPLE__)
@@ -340,9 +341,6 @@ MoveTextRegionToLargePages(const text_region& r) {
     PrintSystemError(errno);
     return -1;
   }
-  OnScopeLeave munmap_on_return([nmem, size]() {
-    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
-  });
 
   memcpy(nmem, r.from, size);
 
@@ -359,13 +357,14 @@ MoveTextRegionToLargePages(const text_region& r) {
     return -1;
   }
 
-  ret = madvise(tmem, size, MADV_HUGEPAGE);
+  ret = madvise(tmem, size, 14 /* MADV_HUGEPAGE */);
   if (ret == -1) {
     PrintSystemError(errno);
     ret = munmap(tmem, size);
     if (ret == -1) {
       PrintSystemError(errno);
     }
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
     return -1;
   }
   memcpy(start, nmem, size);
@@ -376,6 +375,7 @@ MoveTextRegionToLargePages(const text_region& r) {
               MAP_ALIGNED_SUPER, -1 , 0);
   if (tmem == MAP_FAILED) {
     PrintSystemError(errno);
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
     return -1;
   }
 #elif defined(__APPLE__)
@@ -390,6 +390,7 @@ MoveTextRegionToLargePages(const text_region& r) {
               VM_FLAGS_SUPERPAGE_SIZE_2MB, 0);
   if (tmem == MAP_FAILED) {
     PrintSystemError(errno);
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
     return -1;
   }
   memcpy(tmem, nmem, size);
@@ -400,6 +401,7 @@ MoveTextRegionToLargePages(const text_region& r) {
     if (ret == -1) {
       PrintSystemError(errno);
     }
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
     return -1;
   }
   memcpy(start, tmem, size);
@@ -412,8 +414,10 @@ MoveTextRegionToLargePages(const text_region& r) {
     if (ret == -1) {
       PrintSystemError(errno);
     }
+    if (-1 == munmap(nmem, size)) PrintSystemError(errno);
     return -1;
   }
+  if (-1 == munmap(nmem, size)) PrintSystemError(errno);
   return ret;
 }
 
@@ -425,12 +429,12 @@ int MapStaticCodeToLargePages() {
     return -1;
   }
 
-#if defined(__linux__)
+#if defined(__linux__) || defined(__FreeBSD__)
   if (r.from > reinterpret_cast<void*>(&MoveTextRegionToLargePages))
     return MoveTextRegionToLargePages(r);
 
   return -1;
-#elif defined(__FreeBSD__) || defined(__APPLE__)
+#elif defined(__APPLE__)
   return MoveTextRegionToLargePages(r);
 #endif
 }
diff --git a/src/node.cc b/src/node.cc
index 7c0118758dfd94..c082bb6be5554b 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -74,9 +74,7 @@
 #include "../deps/v8/src/third_party/vtune/v8-vtune.h"
 #endif
 
-#ifdef NODE_ENABLE_LARGE_CODE_PAGES
 #include "large_pages/node_large_page.h"
-#endif
 
 #include <errno.h>
 #include <fcntl.h>  // _O_RDWR
@@ -3021,14 +3019,6 @@ int Start(int argc, char** argv) {
 
   CHECK_GT(argc, 0);
 
-#ifdef NODE_ENABLE_LARGE_CODE_PAGES
-  if (node::IsLargePagesEnabled()) {
-    if (node::MapStaticCodeToLargePages() != 0) {
-      fprintf(stderr, "Reverting to default page size\n");
-    }
-  }
-#endif
-
   // Hack around with the argv pointer. Used for process.title = "blah".
   argv = uv_setup_args(argc, argv);
 
@@ -3037,6 +3027,26 @@ int Start(int argc, char** argv) {
   // This needs to run *before* V8::Initialize().
   Init(&args, &exec_args);
 
+#if defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
+  if (per_process_opts->use_largepages == "on" ||
+      per_process_opts->use_largepages == "silent") {
+    if (node::IsLargePagesEnabled()) {
+      if (node::MapStaticCodeToLargePages() != 0 &&
+          per_process_opts->use_largepages != "silent") {
+        fprintf(stderr,
+                "Mapping code to large pages failed. Reverting to default page "
+                "size.\n");
+      }
+    } else if (per_process_opts->use_largepages != "silent") {
+      fprintf(stderr, "Large pages are not enabled.\n");
+    }
+  }
+#else
+  if (per_process_opts->use_largepages == "on") {
+    fprintf(stderr, "Mapping to large pages is not supported.\n");
+  }
+#endif  // NODE_ENABLE_LARGE_CODE_PAGES
+
 #if HAVE_OPENSSL
   {
     std::string extra_ca_certs;
diff --git a/src/node_options.cc b/src/node_options.cc
index 7980e303a97074..2ee1a3535cd4a8 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -24,6 +24,11 @@ void PerProcessOptions::CheckOptions(std::vector<std::string>* errors) {
                       "used, not both");
   }
 #endif
+  if (use_largepages != "off" &&
+      use_largepages != "on" &&
+      use_largepages != "silent") {
+    errors->push_back("invalid value for --use-largepages");
+  }
   per_isolate->CheckOptions(errors);
 }
 
@@ -355,6 +360,10 @@ PerProcessOptionsParser::PerProcessOptionsParser() {
             kAllowedInEnvironment);
 #endif
 #endif
+  AddOption("--use-largepages",
+            "Map the Node.js static code to large pages",
+            &PerProcessOptions::use_largepages,
+            kAllowedInEnvironment);
 
   Insert(&PerIsolateOptionsParser::instance,
          &PerProcessOptions::get_per_isolate_options);
diff --git a/src/node_options.h b/src/node_options.h
index 62e28372fc2643..895d4c118150ab 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -153,6 +153,7 @@ class PerProcessOptions : public Options {
   bool force_fips_crypto = false;
 #endif
 #endif
+  std::string use_largepages = "off";
 
   inline PerIsolateOptions* get_per_isolate_options();
   void CheckOptions(std::vector<std::string>* errors);
diff --git a/test/parallel/test-startup-large-pages.js b/test/parallel/test-startup-large-pages.js
new file mode 100644
index 00000000000000..d5589ee547f760
--- /dev/null
+++ b/test/parallel/test-startup-large-pages.js
@@ -0,0 +1,29 @@
+'use strict';
+
+// Make sure that Node.js runs correctly with the --use-largepages option.
+
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+{
+  const child = spawnSync(process.execPath,
+                          [ '--use-largepages=on', '-p', '42' ]);
+  const stdout = child.stdout.toString().match(/\S+/g);
+  assert.strictEqual(child.status, 0);
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(stdout.length, 1);
+  assert.strictEqual(stdout[0], '42');
+}
+
+{
+  const child = spawnSync(process.execPath,
+                          [ '--use-largepages=xyzzy', '-p', '42' ]);
+  assert.strictEqual(child.status, 9);
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(child.stderr.toString().match(/\S+/g).slice(1).join(' '),
+                     'invalid value for --use-largepages');
+}
+
+// TODO(gabrielschulhof): Make assertions about the stderr, which may or may not
+// contain a message indicating that mapping to large pages has failed.

From 7502e313d3f8ca5d31bc1f2b95e6d861ca118ae8 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 23 Dec 2019 18:20:45 -0800
Subject: [PATCH 09/18] build: re-introduce --use-largepages as no-op

Re-introduce the build-time option as a no-op in order to retain
backward compatibility for LTS purposes.

Re: https://github.com/nodejs/node/pull/31063#pullrequestreview-336045756
PR_URL: https://github.com/nodejs/node/pull/31075
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Beth Griggs <Bethany.Griggs@uk.ibm.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 configure.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/configure.py b/configure.py
index 5ac4122bdb54cc..6dde8e1740ad34 100755
--- a/configure.py
+++ b/configure.py
@@ -392,6 +392,11 @@
     dest='with_etw',
     help='build with ETW (default is true on Windows)')
 
+parser.add_option('--use-largepages',
+    action='store_true',
+    dest='node_use_large_pages',
+    help='This option has no effect. --use-largepages is now a runtime option.')
+
 intl_optgroup.add_option('--with-intl',
     action='store',
     dest='with_intl',

From ed5e50d2e8de66ce734f2c0cf68ef841c6282fa9 Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Wed, 25 Dec 2019 16:22:21 -0800
Subject: [PATCH 10/18] build: switch realpath to pwd

PR-URL: https://github.com/nodejs/node/pull/31095
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 node.gypi | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/node.gypi b/node.gypi
index 33ce674ec1f0fd..6acba079212412 100644
--- a/node.gypi
+++ b/node.gypi
@@ -309,7 +309,7 @@
       'llvm_version==0', {
       'ldflags': [
         '-Wl,-T',
-        '<!(realpath src/large_pages/ld.implicit.script)',
+        '<!(echo "$(pwd)/src/large_pages/ld.implicit.script")',
       ]
     }],
     [ 'OS=="linux" and '
@@ -317,7 +317,7 @@
       'llvm_version!=0', {
       'ldflags': [
         '-Wl,-T',
-        '<!(realpath src/large_pages/ld.implicit.script.lld)',
+        '<!(echo "$(pwd)/src/large_pages/ld.implicit.script.lld")',
       ]
     }],
     [ 'node_use_openssl=="true"', {

From 7075e9d7d1b243346905283fc9e04d8b987fadef Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Tue, 24 Dec 2019 13:42:48 +0200
Subject: [PATCH 11/18] src: make large_pages node.cc include conditional

The usage of the relevant methods from the file is conditional so make
the include conditional too.

PR-URL: https://github.com/nodejs/node/pull/31078
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: David Carlier <devnexen@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 src/node.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/node.cc b/src/node.cc
index c082bb6be5554b..2b54e0dd6418aa 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -74,7 +74,9 @@
 #include "../deps/v8/src/third_party/vtune/v8-vtune.h"
 #endif
 
+#ifdef NODE_ENABLE_LARGE_CODE_PAGES
 #include "large_pages/node_large_page.h"
+#endif
 
 #include <errno.h>
 #include <fcntl.h>  // _O_RDWR

From 88b76d12ff96596a658440b76d6faadbd685d026 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 26 Dec 2019 09:04:43 -0800
Subject: [PATCH 12/18] build: warn upon --use-largepages config option

Emit a warning when the user configures with `--use-largepages` and/or
`--use-largepages-script-lld` informing them that the option is now
available as a Node.js runtime option once it is built.

Refs: https://github.com/nodejs/node/pull/31063#discussion_r361143460
PR-URL: https://github.com/nodejs/node/pull/31103
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
---
 configure.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/configure.py b/configure.py
index 6dde8e1740ad34..16c1365c1a62bf 100755
--- a/configure.py
+++ b/configure.py
@@ -1024,6 +1024,13 @@ def configure_node(o):
   else:
     o['variables']['node_use_dtrace'] = 'false'
 
+  if options.node_use_large_pages:
+    warn('''The `--use-largepages` option has no effect during build time.
+         Support for mapping to large pages is now a runtime option of Node.js.
+         Run `node --use-largepages` or add `--use-largepages` to the
+         `NODE_OPTIONS` environment variable once Node.js is built to enable
+         mapping to large pages.''')
+
   if options.no_ifaddrs:
     o['defines'] += ['SUNOS_NO_IFADDRS']
 

From 75947e11c7abb76075e6341de2b791cc98c28d54 Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Sun, 5 Jan 2020 16:20:12 +0200
Subject: [PATCH 13/18] src: clean up large_pages code

PR-URL: https://github.com/nodejs/node/pull/31196
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: David Carlier <devnexen@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 src/large_pages/node_large_page.cc | 53 +++++++++++++-----------------
 1 file changed, 23 insertions(+), 30 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 610aa8f753587e..16ae964b863f19 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -86,9 +86,12 @@ struct text_region {
 
 static const size_t hps = 2L * 1024 * 1024;
 
+static void PrintWarning(const char* warn) {
+  fprintf(stderr, "Hugepages WARNING: %s\n", warn);
+}
+
 static void PrintSystemError(int error) {
-  fprintf(stderr, "Hugepages WARNING: %s\n", strerror(error));
-  return;
+  PrintWarning(strerror(error));
 }
 
 inline uintptr_t hugepage_align_up(uintptr_t addr) {
@@ -102,7 +105,7 @@ inline uintptr_t hugepage_align_down(uintptr_t addr) {
 // The format of the maps file is the following
 // address           perms offset  dev   inode       pathname
 // 00400000-00452000 r-xp 00000000 08:02 173521      /usr/bin/dbus-daemon
-// This is also handling the case where the first line is not the binary
+// This is also handling the case where the first line is not the binary.
 
 static struct text_region FindNodeTextRegion() {
 #if defined(__linux__)
@@ -118,7 +121,7 @@ static struct text_region FindNodeTextRegion() {
 
   ifs.open("/proc/self/maps");
   if (!ifs) {
-    fprintf(stderr, "Could not open /proc/self/maps\n");
+    PrintWarning("could not open /proc/self/maps");
     return nregion;
   }
 
@@ -186,7 +189,7 @@ static struct text_region FindNodeTextRegion() {
     return nregion;
   }
 
-  // for struct kinfo_vmentry
+  // Enough for struct kinfo_vmentry.
   numpg = numpg * 4 / 3;
   auto alg = std::vector<char>(numpg);
 
@@ -270,39 +273,29 @@ static bool IsTransparentHugePagesEnabled() {
 
   ifs.open("/sys/kernel/mm/transparent_hugepage/enabled");
   if (!ifs) {
-    fprintf(stderr, "Could not open file: " \
-                    "/sys/kernel/mm/transparent_hugepage/enabled\n");
+    PrintWarning("could not open /sys/kernel/mm/transparent_hugepage/enabled");
     return false;
   }
 
-  std::string always, madvise, never;
+  std::string always, madvise;
   if (ifs.is_open()) {
-    while (ifs >> always >> madvise >> never) {}
+    while (ifs >> always >> madvise) {}
   }
-
-  int ret_status = false;
-
-  if (always.compare("[always]") == 0)
-    ret_status = true;
-  else if (madvise.compare("[madvise]") == 0)
-    ret_status = true;
-  else if (never.compare("[never]") == 0)
-    ret_status = false;
-
   ifs.close();
-  return ret_status;
+
+  return always == "[always]" || madvise == "[madvise]";
 }
 #elif defined(__FreeBSD__)
 static bool IsSuperPagesEnabled() {
-  // It is enabled by default on amd64
+  // It is enabled by default on amd64.
   unsigned int super_pages = 0;
   size_t super_pages_length = sizeof(super_pages);
-  if (sysctlbyname("vm.pmap.pg_ps_enabled", &super_pages,
-      &super_pages_length, nullptr, 0) == -1 ||
-      super_pages < 1) {
-    return false;
-  }
-  return true;
+  return sysctlbyname("vm.pmap.pg_ps_enabled",
+                      &super_pages,
+                      &super_pages_length,
+                      nullptr,
+                      0) != -1 &&
+         super_pages >= 1;
 }
 #endif
 
@@ -334,7 +327,7 @@ MoveTextRegionToLargePages(const text_region& r) {
   size_t size = r.to - r.from;
   void* start = r.from;
 
-  // Allocate temporary region preparing for copy
+  // Allocate temporary region preparing for copy.
   nmem = mmap(nullptr, size,
               PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (nmem == MAP_FAILED) {
@@ -421,11 +414,11 @@ MoveTextRegionToLargePages(const text_region& r) {
   return ret;
 }
 
-// This is the primary API called from main
+// This is the primary API called from main.
 int MapStaticCodeToLargePages() {
   struct text_region r = FindNodeTextRegion();
   if (r.found_text_region == false) {
-    fprintf(stderr, "Hugepages WARNING: failed to find text region\n");
+    PrintWarning("failed to find text region");
     return -1;
   }
 

From 269351021e9759d2065e5134fb54be7250b33584 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 16 Jan 2020 11:27:51 -0800
Subject: [PATCH 14/18] src: reduce large pages code duplication
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Declaring and initializing a `struct text_region` is common to all
three implementations of the large pages mapping code. Let's make it
unconditional.

PR-URL: https://github.com/nodejs/node/pull/31385
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
Reviewed-By: JungMinu - Minwoo Jung <jmwsoft@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 src/large_pages/node_large_page.cc | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 16ae964b863f19..ca1c2c3cf96ef9 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -108,6 +108,8 @@ inline uintptr_t hugepage_align_down(uintptr_t addr) {
 // This is also handling the case where the first line is not the binary.
 
 static struct text_region FindNodeTextRegion() {
+  struct text_region nregion;
+  nregion.found_text_region = false;
 #if defined(__linux__)
   std::ifstream ifs;
   std::string map_line;
@@ -115,9 +117,6 @@ static struct text_region FindNodeTextRegion() {
   std::string dev;
   char dash;
   uintptr_t start, end, offset, inode;
-  struct text_region nregion;
-
-  nregion.found_text_region = false;
 
   ifs.open("/proc/self/maps");
   if (!ifs) {
@@ -169,9 +168,6 @@ static struct text_region FindNodeTextRegion() {
 
   ifs.close();
 #elif defined(__FreeBSD__)
-  struct text_region nregion;
-  nregion.found_text_region = false;
-
   std::string exename;
   {
     char selfexe[PATH_MAX];
@@ -228,8 +224,6 @@ static struct text_region FindNodeTextRegion() {
     start += cursz;
   }
 #elif defined(__APPLE__)
-  struct text_region nregion;
-  nregion.found_text_region = false;
   struct vm_region_submap_info_64 map;
   mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;
   vm_address_t addr = 0UL;

From 56305eeaa3d78262a5fb9d34b441c9dcc0e98488 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Tue, 28 Jan 2020 11:01:32 +0100
Subject: [PATCH 15/18] src: use __executable_start for linux hugepages

`__executable_start` is provided by GNU's and LLVM's default linker
scripts, obviating the need to plug in a custom linker script.

The problem with our bespoke linker script is that it works with ld.bfd
but not ld.gold and cannot easily be ported because the latter linker
doesn't understand the `INSERT BEFORE` directive.

The /proc/self/maps scanner is updated to account for the fact that
there are a number of sections between `&__executable_start` and
the start of the .text section.

Fortunately, those sections are all mapped into the same memory segment
so we only need to look at the next line to find the start of our text
segment.

Fixes: https://github.com/nodejs/node/issues/31520

PR-URL: https://github.com/nodejs/node/pull/31547
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
---
 node.gyp                               |  3 +-
 node.gypi                              | 16 -----
 src/large_pages/ld.implicit.script     | 10 ----
 src/large_pages/ld.implicit.script.lld |  3 -
 src/large_pages/node_large_page.cc     | 83 ++++++++++++++------------
 5 files changed, 47 insertions(+), 68 deletions(-)
 delete mode 100644 src/large_pages/ld.implicit.script
 delete mode 100644 src/large_pages/ld.implicit.script.lld

diff --git a/node.gyp b/node.gyp
index 42591107e5f75f..a6c7423aa48b5c 100644
--- a/node.gyp
+++ b/node.gyp
@@ -607,7 +607,8 @@
           ],
         }],
         [ 'OS in "linux freebsd mac" and '
-          'target_arch=="x64"', {
+          'target_arch=="x64" and '
+          'node_target_type=="executable"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
           'sources': [
             'src/large_pages/node_large_page.cc',
diff --git a/node.gypi b/node.gypi
index 6acba079212412..2637d984b22718 100644
--- a/node.gypi
+++ b/node.gypi
@@ -304,22 +304,6 @@
       'ldflags': [ '-Wl,-z,relro',
                    '-Wl,-z,now' ]
     }],
-    [ 'OS=="linux" and '
-      'target_arch=="x64" and '
-      'llvm_version==0', {
-      'ldflags': [
-        '-Wl,-T',
-        '<!(echo "$(pwd)/src/large_pages/ld.implicit.script")',
-      ]
-    }],
-    [ 'OS=="linux" and '
-      'target_arch=="x64" and '
-      'llvm_version!=0', {
-      'ldflags': [
-        '-Wl,-T',
-        '<!(echo "$(pwd)/src/large_pages/ld.implicit.script.lld")',
-      ]
-    }],
     [ 'node_use_openssl=="true"', {
       'defines': [ 'HAVE_OPENSSL=1' ],
       'conditions': [
diff --git a/src/large_pages/ld.implicit.script b/src/large_pages/ld.implicit.script
deleted file mode 100644
index 7f12e4bd7df9e5..00000000000000
--- a/src/large_pages/ld.implicit.script
+++ /dev/null
@@ -1,10 +0,0 @@
-  SECTIONS {
-    .lpstub            : {
-       *libc.a:*(.text .text.*)
-       *(.lpstub)
-     }
-  }
-  PROVIDE (__nodetext = .);
-  PROVIDE (_nodetext = .);
-  PROVIDE (nodetext = .);
-  INSERT BEFORE .text;
diff --git a/src/large_pages/ld.implicit.script.lld b/src/large_pages/ld.implicit.script.lld
deleted file mode 100644
index b85510bcf07eeb..00000000000000
--- a/src/large_pages/ld.implicit.script.lld
+++ /dev/null
@@ -1,3 +0,0 @@
-  PROVIDE (__nodetext = .);
-  PROVIDE (_nodetext = .);
-  PROVIDE (nodetext = .);
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index ca1c2c3cf96ef9..004d57362eee71 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -73,7 +73,11 @@
 // Use madvise with MADV_HUGEPAGE to use Anonymous 2M Pages
 // If successful copy the code there and unmap the original region.
 
-extern char __nodetext;
+#if defined(__linux__)
+extern "C" {
+extern char __executable_start;
+}  // extern "C"
+#endif  // defined(__linux__)
 
 namespace node {
 
@@ -124,17 +128,6 @@ static struct text_region FindNodeTextRegion() {
     return nregion;
   }
 
-  std::string exename;
-  {
-      char selfexe[PATH_MAX];
-
-      size_t size = sizeof(selfexe);
-      if (uv_exepath(selfexe, &size))
-        return nregion;
-
-      exename = std::string(selfexe, size);
-  }
-
   while (std::getline(ifs, map_line)) {
     std::istringstream iss(map_line);
     iss >> std::hex >> start;
@@ -144,26 +137,42 @@ static struct text_region FindNodeTextRegion() {
     iss >> offset;
     iss >> dev;
     iss >> inode;
-    if (inode != 0) {
-      std::string pathname;
-      iss >> pathname;
-      if (pathname == exename && permission == "r-xp") {
-        uintptr_t ntext = reinterpret_cast<uintptr_t>(&__nodetext);
-        if (ntext >= start && ntext < end) {
-          char* from = reinterpret_cast<char*>(hugepage_align_up(ntext));
-          char* to = reinterpret_cast<char*>(hugepage_align_down(end));
-
-          if (from < to) {
-            size_t size = to - from;
-            nregion.found_text_region = true;
-            nregion.from = from;
-            nregion.to = to;
-            nregion.total_hugepages = size / hps;
-          }
-          break;
-        }
-      }
-    }
+
+    if (inode == 0)
+      continue;
+
+    std::string pathname;
+    iss >> pathname;
+
+    if (start != reinterpret_cast<uintptr_t>(&__executable_start))
+      continue;
+
+    // The next line is our .text section.
+    if (!std::getline(ifs, map_line))
+      break;
+
+    iss = std::istringstream(map_line);
+    iss >> std::hex >> start;
+    iss >> dash;
+    iss >> std::hex >> end;
+    iss >> permission;
+
+    if (permission != "r-xp")
+      break;
+
+    char* from = reinterpret_cast<char*>(hugepage_align_up(start));
+    char* to = reinterpret_cast<char*>(hugepage_align_down(end));
+
+    if (from >= to)
+      break;
+
+    size_t size = to - from;
+    nregion.found_text_region = true;
+    nregion.from = from;
+    nregion.to = to;
+    nregion.total_hugepages = size / hps;
+
+    break;
   }
 
   ifs.close();
@@ -416,14 +425,12 @@ int MapStaticCodeToLargePages() {
     return -1;
   }
 
-#if defined(__linux__) || defined(__FreeBSD__)
-  if (r.from > reinterpret_cast<void*>(&MoveTextRegionToLargePages))
-    return MoveTextRegionToLargePages(r);
+#if defined(__FreeBSD__)
+  if (r.from < reinterpret_cast<void*>(&MoveTextRegionToLargePages))
+    return -1;
+#endif
 
-  return -1;
-#elif defined(__APPLE__)
   return MoveTextRegionToLargePages(r);
-#endif
 }
 
 bool IsLargePagesEnabled() {

From 8a7f607c1610ad1299e90aad3db44f5388128d83 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 21 Feb 2020 08:26:29 -0800
Subject: [PATCH 16/18] src: include large pages source unconditionally

Restrict the usage of the C preprocessor directive enabling large
pages support to the large pages implementation. This cleans up the
code in src/node.cc.

PR-URL: https://github.com/nodejs/node/pull/31904
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: David Carlier <devnexen@gmail.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
---
 node.gyp                           |  6 +--
 src/large_pages/node_large_page.cc | 69 +++++++++++++++++++++++-------
 src/large_pages/node_large_page.h  |  3 +-
 src/node.cc                        | 20 ++-------
 4 files changed, 59 insertions(+), 39 deletions(-)

diff --git a/node.gyp b/node.gyp
index a6c7423aa48b5c..409ea60c5a2d5c 100644
--- a/node.gyp
+++ b/node.gyp
@@ -406,6 +406,8 @@
         'src/env-inl.h',
         'src/handle_wrap.h',
         'src/js_stream.h',
+        'src/large_pages/node_large_page.cc',
+        'src/large_pages/node_large_page.h'
         'src/module_wrap.h',
         'src/node.h',
         'src/node_buffer.h',
@@ -610,10 +612,6 @@
           'target_arch=="x64" and '
           'node_target_type=="executable"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
-          'sources': [
-            'src/large_pages/node_large_page.cc',
-            'src/large_pages/node_large_page.h'
-          ],
         }],
         [ 'use_openssl_def==1', {
           # TODO(bnoordhuis) Make all platforms export the same list of symbols.
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 004d57362eee71..41d1e8f7a11b8e 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -22,6 +22,11 @@
 
 #include "node_internals.h"
 #include "node_large_page.h"
+
+#include <cerrno>   // NOLINT(build/include)
+
+// Besides returning ENOTSUP at runtime we do nothing if this define is missing.
+#if defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
 #include "util.h"
 #include "uv.h"
 
@@ -36,7 +41,6 @@
 #endif
 #include <unistd.h>  // readlink
 
-#include <cerrno>   // NOLINT(build/include)
 #include <climits>  // PATH_MAX
 #include <clocale>
 #include <csignal>
@@ -79,7 +83,11 @@ extern char __executable_start;
 }  // extern "C"
 #endif  // defined(__linux__)
 
+#endif  // defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
 namespace node {
+#if defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
+
+namespace {
 
 struct text_region {
   char* from;
@@ -111,7 +119,7 @@ inline uintptr_t hugepage_align_down(uintptr_t addr) {
 // 00400000-00452000 r-xp 00000000 08:02 173521      /usr/bin/dbus-daemon
 // This is also handling the case where the first line is not the binary.
 
-static struct text_region FindNodeTextRegion() {
+struct text_region FindNodeTextRegion() {
   struct text_region nregion;
   nregion.found_text_region = false;
 #if defined(__linux__)
@@ -271,7 +279,7 @@ static struct text_region FindNodeTextRegion() {
 }
 
 #if defined(__linux__)
-static bool IsTransparentHugePagesEnabled() {
+bool IsTransparentHugePagesEnabled() {
   std::ifstream ifs;
 
   ifs.open("/sys/kernel/mm/transparent_hugepage/enabled");
@@ -302,6 +310,8 @@ static bool IsSuperPagesEnabled() {
 }
 #endif
 
+}  // End of anonymous namespace
+
 // Moving the text region to large pages. We need to be very careful.
 // 1: This function itself should not be moved.
 // We use a gcc attributes
@@ -416,14 +426,26 @@ MoveTextRegionToLargePages(const text_region& r) {
   if (-1 == munmap(nmem, size)) PrintSystemError(errno);
   return ret;
 }
+#endif  // defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
 
 // This is the primary API called from main.
 int MapStaticCodeToLargePages() {
+#if defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
+  bool have_thp = false;
+#if defined(__linux__)
+  have_thp = IsTransparentHugePagesEnabled();
+#elif defined(__FreeBSD__)
+  have_thp = IsSuperPagesEnabled();
+#elif defined(__APPLE__)
+  // pse-36 flag is present in recent mac x64 products.
+  have_thp = true;
+#endif
+  if (!have_thp)
+    return EACCES;
+
   struct text_region r = FindNodeTextRegion();
-  if (r.found_text_region == false) {
-    PrintWarning("failed to find text region");
-    return -1;
-  }
+  if (r.found_text_region == false)
+    return ENOENT;
 
 #if defined(__FreeBSD__)
   if (r.from < reinterpret_cast<void*>(&MoveTextRegionToLargePages))
@@ -431,17 +453,32 @@ int MapStaticCodeToLargePages() {
 #endif
 
   return MoveTextRegionToLargePages(r);
+#else
+  return ENOTSUP;
+#endif
 }
 
-bool IsLargePagesEnabled() {
-#if defined(__linux__)
-  return IsTransparentHugePagesEnabled();
-#elif defined(__FreeBSD__)
-  return IsSuperPagesEnabled();
-#elif defined(__APPLE__)
-  // pse-36 flag is present in recent mac x64 products.
-  return true;
-#endif
+const char* LargePagesError(int status) {
+  switch (status) {
+    case ENOTSUP:
+      return "Mapping to large pages is not supported.";
+
+    case EACCES:
+      return "Large pages are not enabled.";
+
+    case ENOENT:
+      return "failed to find text region";
+
+    case -1:
+      return "Mapping code to large pages failed. Reverting to default page "
+          "size.";
+
+    case 0:
+      return "OK";
+
+    default:
+      return "Unknown error";
+  }
 }
 
 }  // namespace node
diff --git a/src/large_pages/node_large_page.h b/src/large_pages/node_large_page.h
index bce505585cf0d0..622cf09ede4e1c 100644
--- a/src/large_pages/node_large_page.h
+++ b/src/large_pages/node_large_page.h
@@ -25,10 +25,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-
 namespace node {
-bool IsLargePagesEnabled();
 int MapStaticCodeToLargePages();
+const char* LargePagesError(int status);
 }  // namespace node
 
 #endif  // NODE_WANT_INTERNALS
diff --git a/src/node.cc b/src/node.cc
index 2b54e0dd6418aa..f9bf7bb223514a 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -74,9 +74,7 @@
 #include "../deps/v8/src/third_party/vtune/v8-vtune.h"
 #endif
 
-#ifdef NODE_ENABLE_LARGE_CODE_PAGES
 #include "large_pages/node_large_page.h"
-#endif
 
 #include <errno.h>
 #include <fcntl.h>  // _O_RDWR
@@ -3029,25 +3027,13 @@ int Start(int argc, char** argv) {
   // This needs to run *before* V8::Initialize().
   Init(&args, &exec_args);
 
-#if defined(NODE_ENABLE_LARGE_CODE_PAGES) && NODE_ENABLE_LARGE_CODE_PAGES
   if (per_process_opts->use_largepages == "on" ||
       per_process_opts->use_largepages == "silent") {
-    if (node::IsLargePagesEnabled()) {
-      if (node::MapStaticCodeToLargePages() != 0 &&
-          per_process_opts->use_largepages != "silent") {
-        fprintf(stderr,
-                "Mapping code to large pages failed. Reverting to default page "
-                "size.\n");
-      }
-    } else if (per_process_opts->use_largepages != "silent") {
-      fprintf(stderr, "Large pages are not enabled.\n");
+    int result = node::MapStaticCodeToLargePages();
+    if (per_process_opts->use_largepages == "on" && result != 0) {
+      fprintf(stderr, "%s\n", node::LargePagesError(result));
     }
   }
-#else
-  if (per_process_opts->use_largepages == "on") {
-    fprintf(stderr, "Mapping to large pages is not supported.\n");
-  }
-#endif  // NODE_ENABLE_LARGE_CODE_PAGES
 
 #if HAVE_OPENSSL
   {

From f3643bfbc84c20921a85acc61f45be068e4b7699 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 26 Feb 2020 16:21:41 -0800
Subject: [PATCH 17/18] src: start the .text section with an asm symbol

We create an object file in assembly which introduces the symbol
`__node_text_start` into the .text section and place the resulting
object file as the first file the linker encounters. We do this to
ensure that we can recognize the boundaries of the .text section when
attempting to establish the address range to map to large pages.

Additionally, we rename the section containing the remapping code from
`.lpstub` to `lpstub` so as to take advantage of the linker's feature
whereby it inserts the symbol `__start_lpstub` when the section's name
can be rendered as a valid C variable. We need this symbol in order to
avoid self-mapping the remapping code to large pages, because doing so
would cause the process to crash.

PR-URL: https://github.com/nodejs/node/pull/31981
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: David Carlier <devnexen@gmail.com>
Signed-off-by: Gabriel Schulhof <gabriel.schulhof@intel.com>
---
 node.gyp                           | 20 ++++++++++++++++++++
 src/large_pages/node_large_page.cc | 28 ++++++++++++++--------------
 src/large_pages/node_text_start.S  |  5 +++++
 3 files changed, 39 insertions(+), 14 deletions(-)
 create mode 100644 src/large_pages/node_text_start.S

diff --git a/node.gyp b/node.gyp
index 409ea60c5a2d5c..463e990a1e0947 100644
--- a/node.gyp
+++ b/node.gyp
@@ -230,6 +230,19 @@
   },
 
   'targets': [
+    {
+      'target_name': 'node_text_start',
+      'type': 'none',
+      'conditions': [
+        [ 'OS=="linux" and '
+          'target_arch=="x64"', {
+          'type': 'static_library',
+          'sources': [
+            'src/large_pages/node_text_start.S'
+          ]
+        }],
+      ]
+    },
     {
       'target_name': '<(node_core_target_name)',
       'type': 'executable',
@@ -310,6 +323,13 @@
           # the executable and rename it back to node.exe later
           'product_name': '<(node_core_target_name)-win',
         }],
+        [ 'OS=="linux" and '
+          'target_arch=="x64"', {
+          'dependencies': [ 'node_text_start' ],
+          'ldflags+': [
+            '<(PRODUCT_DIR)/obj.target/node_text_start/src/large_pages/node_text_start.o'
+          ]
+        }],
       ],
     }, # node_core_target_name
     {
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index 41d1e8f7a11b8e..190133ed4a2a3a 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -79,7 +79,11 @@
 
 #if defined(__linux__)
 extern "C" {
-extern char __executable_start;
+// This symbol must be declared weak because this file becomes part of all
+// Node.js targets (like node_mksnapshot, node_mkcodecache, and cctest) and
+// those files do not supply the symbol.
+extern char __attribute__((weak)) __node_text_start;
+extern char __start_lpstub;
 }  // extern "C"
 #endif  // defined(__linux__)
 
@@ -129,6 +133,8 @@ struct text_region FindNodeTextRegion() {
   std::string dev;
   char dash;
   uintptr_t start, end, offset, inode;
+  uintptr_t node_text_start = reinterpret_cast<uintptr_t>(&__node_text_start);
+  uintptr_t lpstub_start = reinterpret_cast<uintptr_t>(&__start_lpstub);
 
   ifs.open("/proc/self/maps");
   if (!ifs) {
@@ -152,21 +158,15 @@ struct text_region FindNodeTextRegion() {
     std::string pathname;
     iss >> pathname;
 
-    if (start != reinterpret_cast<uintptr_t>(&__executable_start))
+    if (permission != "r-xp")
       continue;
 
-    // The next line is our .text section.
-    if (!std::getline(ifs, map_line))
-      break;
-
-    iss = std::istringstream(map_line);
-    iss >> std::hex >> start;
-    iss >> dash;
-    iss >> std::hex >> end;
-    iss >> permission;
+    if (node_text_start < start || node_text_start >= end)
+      continue;
 
-    if (permission != "r-xp")
-      break;
+    start = node_text_start;
+    if (lpstub_start > start && lpstub_start <= end)
+      end = lpstub_start;
 
     char* from = reinterpret_cast<char*>(hugepage_align_up(start));
     char* to = reinterpret_cast<char*>(hugepage_align_down(end));
@@ -326,7 +326,7 @@ static bool IsSuperPagesEnabled() {
 // d. If successful copy the code there and unmap the original region
 int
 #if !defined(__APPLE__)
-__attribute__((__section__(".lpstub")))
+__attribute__((__section__("lpstub")))
 #else
 __attribute__((__section__("__TEXT,__lpstub")))
 #endif
diff --git a/src/large_pages/node_text_start.S b/src/large_pages/node_text_start.S
new file mode 100644
index 00000000000000..1609b254f0495a
--- /dev/null
+++ b/src/large_pages/node_text_start.S
@@ -0,0 +1,5 @@
+.text
+.align 0x2000
+.global __node_text_start
+.hidden __node_text_start
+__node_text_start:

From c71d059e9f5cb3233aea1c2f393ee6a8783ec83c Mon Sep 17 00:00:00 2001
From: Richard Lau <riclau@uk.ibm.com>
Date: Tue, 3 Mar 2020 15:02:02 -0500
Subject: [PATCH 18/18] build: fix building with ninja

The ninja build places objects in a different directory.

Co-authored-by: Gabriel Schulhof <gabriel.schulhof@intel.com>
Signed-off-by: Richard Lau <riclau@uk.ibm.com>

PR-URL: https://github.com/nodejs/node/pull/32071
Reviewed-By: Matheus Marchini <mat@mmarchini.me>
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
Reviewed-By: Shelley Vohr <codebytere@gmail.com>
Reviewed-By: Myles Borins <myles.borins@gmail.com>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
---
 node.gyp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/node.gyp b/node.gyp
index 463e990a1e0947..9fc001b98f4be8 100644
--- a/node.gyp
+++ b/node.gyp
@@ -203,6 +203,11 @@
       'deps/acorn/dist/walk.js',
     ],
     'conditions': [
+      ['GENERATOR == "ninja"', {
+        'node_text_start_object_path': 'src/large_pages/node_text_start.node_text_start.o'
+      }, {
+        'node_text_start_object_path': 'node_text_start/src/large_pages/node_text_start.o'
+      }],
       [ 'node_shared=="true"', {
         'node_target_type%': 'shared_library',
         'conditions': [
@@ -327,7 +332,7 @@
           'target_arch=="x64"', {
           'dependencies': [ 'node_text_start' ],
           'ldflags+': [
-            '<(PRODUCT_DIR)/obj.target/node_text_start/src/large_pages/node_text_start.o'
+            '<(obj_dir)/<(node_text_start_object_path)'
           ]
         }],
       ],