[fuzzer] Don't hard-code page size in FuzzerUtil.h

[Ami-zhang]

Summary

Don't hard code the page in FuzzerUtil.h, this breaks on
e.g. LoongArch which defaults to a 16KiB page size.

[xen0n]

This change makes sense on LoongArch, and should cause no behavioral change on 4KiB-page platforms like X86, but more testing on other architectures (e.g. AArch64 systems with 16KiB or 64KiB pages) would be welcome.

I'd leave the approval for other sanitizer reviewers.

[MaskRay]

getpagesize is not recommended. Linux can use getauxval(AT_PAGESZ).
HandleInline8bitCountersInit is called once for an executable/DSO, so a function call isn't too expensive, but better to avoid calling it 2 times for RoundUpByPage/RoundDownByPage, and possibly multiple times in HandleInline8bitCountersInit.

---

@kcc made https://reviews.llvm.org/rG6fd4d8ab9c6e6ddb67df5d822f855de980d1eea6 in 2019, noted down that it is "Needed for future optimization."
It seems that enabled is always true and OneFullPage is unused. Is there a pending optimization which has not landed?

[tangyouling]

In D140607#4016151, @MaskRay wrote:

getpagesize is not recommended. Linux can use getauxval(AT_PAGESZ).
HandleInline8bitCountersInit is called once for an executable/DSO, so a function call isn't too expensive, but better to avoid calling it 2 times for RoundUpByPage/RoundDownByPage, and possibly multiple times in HandleInline8bitCountersInit.

Can it be defined as follows?

#if SANITIZER_USE_GETAUXVAL
#include <sys/auxv.h>
#endif

inline size_t PageSize()
{
#if SANITIZER_USE_GETAUXVAL
  return getauxval(AT_PAGESZ);
#else
  return 4096;
#endif
}

It still needs to be like GetPageSize() in sanitizer_linux.cpp?

#if !SANITIZER_ANDROID
uptr GetPageSize() {
#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__)) && \
    defined(EXEC_PAGESIZE)
  return EXEC_PAGESIZE;
#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
// Use sysctl as sysconf can trigger interceptors internally.
  int pz = 0;
  uptr pzl = sizeof(pz);
  int mib[2] = {CTL_HW, HW_PAGESIZE};
  int rv = internal_sysctl(mib, 2, &pz, &pzl, nullptr, 0);
  CHECK_EQ(rv, 0);
  return (uptr)pz;
#elif SANITIZER_USE_GETAUXVAL
  return getauxval(AT_PAGESZ);
#else
  return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
#endif
}
#endif // !SANITIZER_ANDROID

[tangyouling]

Modify the PageSize() implementation.

[vitalybuka]

compiler-rt/lib/fuzzer/FuzzerUtil.h

20

sanitizer_common is not used by fuzzer, so no SANITIZER_USE_GETAUXVAL

100

Code indeed does not look hot, however it would be nice to have "cached" approach
with getauxval and #include <sys/auxv.h> in cpp file

[tangyouling]

The patch will continue to be updated by @Ami-zhang

[Ami-zhang]

compiler-rt/lib/fuzzer/FuzzerUtil.h

20

Ok, done. Thanks.

100

Update it and use "cached" approach with getauxval to get pagesize.
Thanks for your suggestion.

[Ami-zhang]

Use "cached" approach with getauxval to get pagesize.

[vitalybuka]

simplify

[vitalybuka]

In the previous snapshot initialization was not thread safe.
and we don't want to inline initialization all over the program
and rename is unnececary

[jasonmolenda]

Hi, this has broken the lldb bots on Darwin systems; there is no <sys/auxv.h> there. Can you please revert or replace it with a has_include(sys/auxv.h) etc and fall back to the old hardcoded value?

[jasonmolenda]

I reverted this change in cb9f2de2e80292c0445c99be754fcc78b94b0f16 to unblock the CI test bots.

[Ami-zhang]

In D140607#4374746, @jasonmolenda wrote:

Hi, this has broken the lldb bots on Darwin systems; there is no <sys/auxv.h> there. Can you please revert or replace it with a has_include(sys/auxv.h) etc and fall back to the old hardcoded value?

Yes, this broke tests on Darwin systems. I'm sorry for that.
Instead, I prefer to use the sysconf(_SC_PAGESIZE) function which is more available on most systems including Darwin systems to obtain the page size.
I have submitted the revised changes in https://reviews.llvm.org/D151530.

[Ami-zhang]

Use sysconf(_SC_PAGESIZE) to obtain the page size instead.

[vitalybuka]

Switch to sysconf

compiler-rt/lib/fuzzer/FuzzerTracePC.cpp

void TracePC::HandleInline8bitCountersInit(uint8_t *Start, uint8_t *Stop) {
   if (NumModules &&
       Modules[NumModules - 1].Start() == Start)
     return;
   assert(NumModules <
          sizeof(Modules) / sizeof(Modules[0]));
   auto &M = Modules[NumModules++];
   uint8_t *AlignedStart = RoundUpByPage(Start);
   uint8_t *AlignedStop  = RoundDownByPage(Stop);
-  size_t NumFullPages = AlignedStop > AlignedStart ?
-                        (AlignedStop - AlignedStart) / PageSize() : 0;
+  size_t NumFullPages = AlignedStop > AlignedStart
+                            ? (AlignedStop - AlignedStart) / GetPageSizeCached()
+                            : 0;
   bool NeedFirst = Start < AlignedStart || !NumFullPages;
   bool NeedLast  = Stop > AlignedStop && AlignedStop >= AlignedStart;
   M.NumRegions = NumFullPages + NeedFirst + NeedLast;;
   assert(M.NumRegions > 0);
   M.Regions = new Module::Region[M.NumRegions];
   assert(M.Regions);
   size_t R = 0;
   if (NeedFirst)
     M.Regions[R++] = {Start, std::min(Stop, AlignedStart), true, false};
-  for (uint8_t *P = AlignedStart; P < AlignedStop; P += PageSize())
-    M.Regions[R++] = {P, P + PageSize(), true, true};
+  for (uint8_t *P = AlignedStart; P < AlignedStop; P += GetPageSizeCached())
+    M.Regions[R++] = {P, P + GetPageSizeCached(), true, true};
   if (NeedLast)
     M.Regions[R++] = {AlignedStop, Stop, true, false};
   assert(R == M.NumRegions);
   assert(M.Size() == (size_t)(Stop - Start));
   assert(M.Stop() == Stop);
   assert(M.Start() == Start);
   NumInline8bitCounters += M.Size();
 }

compiler-rt/lib/fuzzer/FuzzerUtil.h

 
 #ifndef LLVM_FUZZER_UTIL_H
 #define LLVM_FUZZER_UTIL_H
 
 #include "FuzzerBuiltins.h"
 #include "FuzzerBuiltinsMsvc.h"
 #include "FuzzerCommand.h"
 #include "FuzzerDefs.h"
+#include <sys/auxv.h>
 
 namespace fuzzer {
 
 void PrintHexArray(const Unit &U, const char *PrintAfter = "");
 
 void PrintHexArray(const uint8_t *Data, size_t Size,
                    const char *PrintAfter = "");
 
 void PrintASCII(const uint8_t *Data, size_t Size, const char *PrintAfter = "");
 

 std::string SearchRegexCmd(const std::string &Regex);
 
 uint64_t SimpleFastHash(const void *Data, size_t Size, uint64_t Initial = 0);
 
 inline size_t Log(size_t X) {
   return static_cast<size_t>((sizeof(unsigned long long) * 8) - Clzll(X) - 1);
 }
 
-inline size_t PageSize() { return 4096; }
+inline size_t PageSizeCached;
+inline size_t GetPageSizeCached() {
+  if (!PageSizeCached)
+    PageSizeCached = getauxval(AT_PAGESZ);
+  return PageSizeCached;
+}
+
 inline uint8_t *RoundUpByPage(uint8_t *P) {
   uintptr_t X = reinterpret_cast<uintptr_t>(P);
-  size_t Mask = PageSize() - 1;
+  size_t Mask = GetPageSizeCached() - 1;
   X = (X + Mask) & ~Mask;
   return reinterpret_cast<uint8_t *>(X);
 }
 inline uint8_t *RoundDownByPage(uint8_t *P) {
   uintptr_t X = reinterpret_cast<uintptr_t>(P);
-  size_t Mask = PageSize() - 1;
+  size_t Mask = GetPageSizeCached() - 1;
   X = X & ~Mask;
   return reinterpret_cast<uint8_t *>(X);
 }
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 template <typename T> T HostToLE(T X) { return X; }
 #else
 template <typename T> T HostToLE(T X) { return Bswap(X); }
 #endif
 
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_UTIL_H