[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

19

sanitizer_common is not used by fuzzer, so no SANITIZER_USE_GETAUXVAL

99

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

19

Ok, done. Thanks.

99

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/FuzzerUtil.h

 #ifndef LLVM_FUZZER_UTIL_H
 #define LLVM_FUZZER_UTIL_H
 
 #include "FuzzerBuiltins.h"
 #include "FuzzerBuiltinsMsvc.h"
 #include "FuzzerCommand.h"
 #include "FuzzerDefs.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; }
+size_t PageSize();
+
 inline uint8_t *RoundUpByPage(uint8_t *P) {
   uintptr_t X = reinterpret_cast<uintptr_t>(P);
   size_t Mask = PageSize() - 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;

compiler-rt/lib/fuzzer/FuzzerUtil.cpp

 #include <cstring>
 #include <errno.h>
 #include <mutex>
 #include <signal.h>
 #include <sstream>
 #include <stdio.h>
 #include <sys/types.h>
 #include <thread>
+#include <unistd.h>
 
 namespace fuzzer {
 
 void PrintHexArray(const uint8_t *Data, size_t Size,
                    const char *PrintAfter) {
   for (size_t i = 0; i < Size; i++)
     Printf("0x%x,", (unsigned)Data[i]);
   Printf("%s", PrintAfter);

 uint64_t SimpleFastHash(const void *Data, size_t Size, uint64_t Initial) {
   uint64_t Res = Initial;
   const uint8_t *Bytes = static_cast<const uint8_t *>(Data);
   for (size_t i = 0; i < Size; i++)
     Res = Res * 11 + Bytes[i];
   return Res;
 }
 
+size_t PageSize() {
+  static size_t PageSizeCached = sysconf(_SC_PAGESIZE);
+  return PageSizeCached;
+}
+
 }  // namespace fuzzer