[BOLT][HUGIFY] Adds fix for -hugify option

[yavtuk]

Summary

This patch adds the checking THP support based on kernel version and kernel configuration.

[yavtuk]

included context

[maksfb]

Could you clarify why this is a "temporary solution"? Are you working on a different patch? THP support might still be useful, but only under an option.

[yavtuk]

In D141659#4063976, @maksfb wrote:

Could you clarify why this is a "temporary solution"? Are you working on a different patch? THP support might still be useful, but only under an option.

@maksfb I think the full solution is to check READ_ONLY_THP_FOR_FS option in /boot/config-xxx file.
Depends on the option state and kernel version we can call munlock & madvise or hugifyForOldKernel function.
I wouldn’t want to add extra options, if you agree with this implementation I can prepare the patch, what do you think?

[maksfb]

In D141659#4064335, @yavtuk wrote:

In D141659#4063976, @maksfb wrote:

Could you clarify why this is a "temporary solution"? Are you working on a different patch? THP support might still be useful, but only under an option.

@maksfb I think the full solution is to check READ_ONLY_THP_FOR_FS option in /boot/config-xxx file.
Depends on the option state and kernel version we can call munlock & madvise or hugifyForOldKernel function.
I wouldn’t want to add extra options, if you agree with this implementation I can prepare the patch, what do you think?

Currently, I don’t see a guaranteed way to acquire THPs. As much as I hate adding a new option, I don’t see a way around it. I considered checking for envvar during runtime, but that solution has its own drawbacks. Although it’s a viable alternative.

[yavtuk]

@maksfb how about such kind of checking?

[maksfb]

In D141659#4064483, @yavtuk wrote:

@maksfb how about such kind of checking?

The config file on my system has a different name. Even if we get the file name correctly, it still wouldn't guarantee THP availability for the process. E.g., at the moment I have CONFIG_READ_ONLY_THP_FOR_FS set, but I cannot get huge pages from the system.

bolt/runtime/hugify.cpp

if (i < sizeof(Delims) / sizeof(Delims[0])) {
         ++Buf;
       }
     }
   }
 }
 
 /// Check whether the kernel supports THP via corresponding sysfs entry.
 /// thp works only starting from 5.10
-static bool hasPagecacheTHPSupport() {
+static bool isTHPEnabled() {
   char Buf[64];
 
   int FD = __open("/sys/kernel/mm/transparent_hugepage/enabled",
                   0 /* O_RDONLY */, 0);
   if (FD < 0)
     return false;
 
-  memset(Buf, 0, sizeof(Buf));
+  Buf[0] = '\0';
   const size_t Res = __read(FD, Buf, sizeof(Buf));
   if (Res < 0)
     return false;
 
   if (!strStr(Buf, "[always]") && !strStr(Buf, "[madvise]"))
     return false;
 
+  return true;
+}
+
+static bool isKernelSupportTHP() {
   struct KernelVersionTy {
     uint32_t major;
     uint32_t minor;
     uint32_t release;
   };
 
   KernelVersionTy KernelVersion;
 
   getKernelVersion((uint32_t *)&KernelVersion);
-  if (KernelVersion.major >= 5 && KernelVersion.minor >= 10)
+  if (KernelVersion.major < 5 || KernelVersion.minor < 10)
+    return false;
+
+  int FD = __open("/boot/config", 0 /* O_RDONLY */, 0);
+  if (FD < 0)
+    return false;
+
+  char Buf[128];
+  char ch;
+  uint64_t i = 0;
+  const uint64_t num = sizeof("CONFIG_");
+  void *pRes;
+  Buf[0] = '\0';
+  while(__read(FD, Buf, num) > 0) {
+    i = num;
+    while (__read(FD, &ch, 1) > 0 && ch != '\n')
+      Buf[i++] = ch;
+
+    pRes = strStr(Buf, "CONFIG_READ_ONLY_THP_FOR_FS");
+    if (pRes) {
+      // OFF: # CONFIG_READ_ONLY_THP_FOR_FS is not
+      //  ON: CONFIG_READ_ONLY_THP_FOR_FS=y
+      DEBUG(report(Buf));
+      const char *p = (char *)pRes + sizeof("CONFIG_READ_ONLY_THP_FOR_FS");
+      if (*p == 'y')
         return true;
+      return false;
+    }
+    Buf[0] = '\0';
+  }
 
   return false;
 }
 
 static void hugifyForOldKernel(uint8_t *From, uint8_t *To) {
   const size_t Size = To - From;
 
   uint8_t *Mem = reinterpret_cast<uint8_t *>(
extern "C" void __bolt_hugify_self_impl() {
   uint8_t *To = HotEnd + (HugePageBytes - 1);
   To -= (intptr_t)To & (HugePageBytes - 1);
 
   DEBUG(reportNumber("[hugify] hot start: ", (uint64_t)HotStart, 16);)
   DEBUG(reportNumber("[hugify] hot end: ", (uint64_t)HotEnd, 16);)
   DEBUG(reportNumber("[hugify] aligned huge page from: ", (uint64_t)From, 16);)
   DEBUG(reportNumber("[hugify] aligned huge page to: ", (uint64_t)To, 16);)
 
-  if (!hasPagecacheTHPSupport()) {
+  if (!isTHPEnabled()) {
+    DEBUG(report(
+          "[hugify] THP is disabled, please check /sys/kernel/mm/transparent_hugepage/enabled\n");)
+    return;
+  }
+
+  if (!isKernelSupportTHP()) {
     DEBUG(report(
-              "[hugify] workaround with memory alignment for kernel < 5.10\n");)
     hugifyForOldKernel(From, To);
-    return;
   }
 
   if (__madvise(From, (To - From), 14 /* MADV_HUGEPAGE */) == -1) {
     char Msg[] = "[hugify] failed to allocate large page\n";
     // TODO: allow user to control the failure behavior.
     reportError(Msg, sizeof(Msg));
   }
 }