[Support] Add error handling to sys::Process::getPageSize().

[lhames]

Summary

This patch changes the return type of sys::Process::getPageSize to
Expected<unsigned> to account for the fact that the underlying syscalls used to
obtain the page size may fail (see below).

For clients who use the page size as an optimization only this patch adds a new
method, getPageSizeEstimate, which calls through to getPageSize but discards
any error returned and substitues a "reasonable" page size estimate estimate
instead. All existing LLVM clients are updated to call getPageSizeEstimate
rather than getPageSize.

On Unix, sys::Process::getPageSize is implemented in terms of getpagesize or
sysconf, depending on which macros are set. The sysconf call is documented to
return -1 on failure. On Darwin getpagesize is implemented in terms of sysconf
and may also fail (though the manpage documentation does not mention this).
These failures have been observed in practice when highly restrictive sandbox
permissions have been applied. Without this patch, the result is that
getPageSize returns -1, which wreaks havoc on any subsequent code that was
assuming a sane page size value.

rdar://problem/41654857

[dblaikie]

Seems reasonable to me (but feel free to wait for someone with more context/domain awareness)

lib/ExecutionEngine/Orc/OrcABISupport.cpp

932

Should this be 'const' too?

(similar for the other ones that have been made static)

lib/Support/Unix/Process.inc

78

I suppose in theory we could turn this from compile-time to runtime failure & then systems that don't provide these ways to access the page size would be OK except for running stuff that /needs/ it like the JIT.

But I doubt that's important/worth doing.

[lhames]

lib/ExecutionEngine/Orc/OrcABISupport.cpp

932

Good catch. Thanks!

lib/Support/Unix/Process.inc

78

It's definitely worth thinking about. I'm going to leave it for now, but I think you might be right that this is better off as a #warn and a runtime failure.

[lhames]

• Address Dave's feedback.

[lhames]

Any further thoughts Dave? If not I'll commit before this gets stale. :)

• Lang.

[dblaikie]

Nah, that's all I've got.

[svenvh]

fwiw, I have updated two more uses of getPageSize() to fix LLVM_USE_PERF builds in r360322.

[lhames]

Sorry I missed them, and thanks very much for the fix Sven!

include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

private:
   }
 
   Error grow() {
     assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
 
     std::error_code EC;
     auto TrampolineBlock =
         sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-            sys::Process::getPageSize(), nullptr,
+            sys::Process::getPageSizeEstimate(), nullptr,
             sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     if (EC)
       return errorCodeToError(EC);
 
     unsigned NumTrampolines =
-        (sys::Process::getPageSize() - ORCABI::PointerSize) /
+        (sys::Process::getPageSizeEstimate() - ORCABI::PointerSize) /
         ORCABI::TrampolineSize;
 
     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
     ORCABI::writeTrampolines(TrampolineMem, ResolverBlock.base(),
                              NumTrampolines);
 
     for (unsigned I = 0; I < NumTrampolines; ++I)
       this->AvailableTrampolines.push_back(

include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h

return errorCodeToError(sys::Memory::protectMappedMemory(
         ResolverBlock.getMemoryBlock(),
         sys::Memory::MF_READ | sys::Memory::MF_EXEC));
   }
 
   Expected<std::tuple<JITTargetAddress, uint32_t>> handleEmitTrampolineBlock() {
     std::error_code EC;
     auto TrampolineBlock =
         sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-            sys::Process::getPageSize(), nullptr,
+            sys::Process::getPageSizeEstimate(), nullptr,
             sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
     if (EC)
       return errorCodeToError(EC);
 
     uint32_t NumTrampolines =
-        (sys::Process::getPageSize() - TargetT::PointerSize) /
+        (sys::Process::getPageSizeEstimate() - TargetT::PointerSize) /
         TargetT::TrampolineSize;
 
     uint8_t *TrampolineMem = static_cast<uint8_t *>(TrampolineBlock.base());
     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
                               NumTrampolines);
 
     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
LLVM_DEBUG(dbgs() << "  Symbol '" << Name
                       << "' =  " << format("0x%016x", Addr) << "\n");
     return Addr;
   }
 
   Expected<std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>>
   handleGetRemoteInfo() {
     std::string ProcessTriple = sys::getProcessTriple();
     uint32_t PointerSize = TargetT::PointerSize;
-    uint32_t PageSize = sys::Process::getPageSize();
+    uint32_t PageSize = sys::Process::getPageSizeEstimate();
     uint32_t TrampolineSize = TargetT::TrampolineSize;
     uint32_t IndirectStubSize = TargetT::IndirectStubsInfo::StubSize;
     LLVM_DEBUG(dbgs() << "  Remote info:\n"
                       << "    triple             = '" << ProcessTriple << "'\n"
                       << "    pointer size       = " << PointerSize << "\n"
                       << "    page size          = " << PageSize << "\n"
                       << "    trampoline size    = " << TrampolineSize << "\n"
                       << "    indirect stub size = " << IndirectStubSize

include/llvm/Support/Process.h

 
 #ifndef LLVM_SUPPORT_PROCESS_H
 #define LLVM_SUPPORT_PROCESS_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Error.h"
 #include <system_error>
 
 namespace llvm {
 template <typename T> class ArrayRef;
 class StringRef;
 
 namespace sys {
 
 
 /// A collection of legacy interfaces for querying information about the
 /// current executing process.
 class Process {
 public:
-  static unsigned getPageSize();
+  /// Get the process's page size.
+  /// This may fail if the underlying syscall returns an error. In most cases,
+  /// page size information is used for optimization, and this error can be
+  /// safely discarded by calling consumeError, and an estimated page size
+  /// substituted instead.
+  static Expected<unsigned> getPageSize();
+
+  /// Get the process's estimated page size.
+  /// This function always succeeds, but if the underlying syscall to determine
+  /// the page size fails then this will silently return an estimated page size.
+  /// The estimated page size is guaranteed to be a power of 2.
+  static unsigned getPageSizeEstimate() {
+    if (auto PageSize = getPageSize())
+      return *PageSize;
+    else {
+      consumeError(PageSize.takeError());
+      return 4096;
+    }
+  }
 
   /// Return process memory usage.
   /// This static function will return the total amount of memory allocated
   /// by the process. This only counts the memory allocated via the malloc,
   /// calloc and realloc functions and includes any "free" holes in the
   /// allocated space.
   static size_t GetMallocUsage();
 

lib/ExecutionEngine/Orc/OrcABISupport.cpp

Error OrcAArch64::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
   // ptr2:
   //                 .quad 0x0
   //
   // ...
 
   const unsigned StubSize = IndirectStubsInfo::StubSize;
 
   // Emit at least MinStubs, rounded up to fill the pages allocated.
-  unsigned PageSize = sys::Process::getPageSize();
+  static unsigned PageSize = sys::Process::getPageSizeEstimate();
   unsigned NumPages = ((MinStubs * StubSize) + (PageSize - 1)) / PageSize;
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
   auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
       2 * NumPages * PageSize, nullptr,
       sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
Error OrcX86_64_Base::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
   // ptr2:
   //                 .quad 0x0
   //
   // ...
 
   const unsigned StubSize = IndirectStubsInfo::StubSize;
 
   // Emit at least MinStubs, rounded up to fill the pages allocated.
-  unsigned PageSize = sys::Process::getPageSize();
+  static unsigned PageSize = sys::Process::getPageSizeEstimate();
   unsigned NumPages = ((MinStubs * StubSize) + (PageSize - 1)) / PageSize;
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
   auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
       2 * NumPages * PageSize, nullptr,
       sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
Error OrcI386::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
   // ptr2:
   //                 .quad 0x0
   //
   // ...
 
   const unsigned StubSize = IndirectStubsInfo::StubSize;
 
   // Emit at least MinStubs, rounded up to fill the pages allocated.
-  unsigned PageSize = sys::Process::getPageSize();
+  static unsigned PageSize = sys::Process::getPageSizeEstimate();
   unsigned NumPages = ((MinStubs * StubSize) + (PageSize - 1)) / PageSize;
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
   auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
       2 * NumPages * PageSize, nullptr,
       sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
Error OrcMips32_Base::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
   // ptr2:
   //                 .word 0x0
   //
   // ...
 
   const unsigned StubSize = IndirectStubsInfo::StubSize;
 
   // Emit at least MinStubs, rounded up to fill the pages allocated.
-  unsigned PageSize = sys::Process::getPageSize();
+  static unsigned PageSize = sys::Process::getPageSizeEstimate();
   unsigned NumPages = ((MinStubs * StubSize) + (PageSize - 1)) / PageSize;
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
   auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
       2 * NumPages * PageSize, nullptr,
       sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
Error OrcMips64::emitIndirectStubsBlock(IndirectStubsInfo &StubsInfo,
   //                 .dword 0x0
   // ptr2:
   //                 .dword 0x0
   //
   // ...
   const unsigned StubSize = IndirectStubsInfo::StubSize;
 
   // Emit at least MinStubs, rounded up to fill the pages allocated.
-  unsigned PageSize = sys::Process::getPageSize();
+  static unsigned PageSize = sys::Process::getPageSizeEstimate();
   unsigned NumPages = ((MinStubs * StubSize) + (PageSize - 1)) / PageSize;
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
   std::error_code EC;
   auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
       2 * NumPages * PageSize, nullptr,
       sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));

lib/ExecutionEngine/SectionMemoryManager.cpp

bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg) {
   // explicit cache flush, otherwise JIT code manipulations (like resolved
   // relocations) will get to the data cache but not to the instruction cache.
   invalidateInstructionCache();
 
   return false;
 }
 
 static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
-  static const size_t PageSize = sys::Process::getPageSize();
+  static const size_t PageSize = sys::Process::getPageSizeEstimate();
 
   size_t StartOverlap =
       (PageSize - ((uintptr_t)M.base() % PageSize)) % PageSize;
 
   size_t TrimmedSize = M.size();
   TrimmedSize -= StartOverlap;
   TrimmedSize -= TrimmedSize % PageSize;
 

 class DefaultMMapper final : public SectionMemoryManager::MemoryMapper {
 public:
   sys::MemoryBlock
   allocateMappedMemory(SectionMemoryManager::AllocationPurpose Purpose,
                        size_t NumBytes, const sys::MemoryBlock *const NearBlock,
                        unsigned Flags, std::error_code &EC) override {
     // allocateMappedMemory calls mmap(2). We round up a request size
     // to page size to get extra space for free.
-    static const size_t PageSize = sys::Process::getPageSize();
+    static const size_t PageSize = sys::Process::getPageSizeEstimate();
     size_t ReqBytes = (NumBytes + PageSize - 1) & ~(PageSize - 1);
     return sys::Memory::allocateMappedMemory(ReqBytes, NearBlock, Flags, EC);
   }
 
   std::error_code protectMappedMemory(const sys::MemoryBlock &Block,
                                       unsigned Flags) override {
     return sys::Memory::protectMappedMemory(Block, Flags);
   }

lib/Support/MemoryBuffer.cpp

WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
   return getReadWriteFile(Filename, -1, MapSize, Offset);
 }
 
 template <typename MB>
 static ErrorOr<std::unique_ptr<MB>>
 getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
                 bool IsVolatile) {
-  static int PageSize = sys::Process::getPageSize();
+  static int PageSize = sys::Process::getPageSizeEstimate();
 
   // Default is to map the full file.
   if (MapSize == uint64_t(-1)) {
     // If we don't know the file size, use fstat to find out.  fstat on an open
     // file descriptor is cheaper than stat on a random path.
     if (FileSize == uint64_t(-1)) {
       sys::fs::file_status Status;
       std::error_code EC = sys::fs::status(FD, Status);

lib/Support/Unix/Memory.inc

 
 #if defined(__NetBSD__) && defined(PROT_MPROTECT)
   Protect |= PROT_MPROTECT(PROT_READ | PROT_WRITE | PROT_EXEC);
 #endif
 
   // Use any near hint and the page size to set a page-aligned starting address
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
                                       NearBlock->size() : 0;
-  static const size_t PageSize = Process::getPageSize();
+  static const size_t PageSize = Process::getPageSizeEstimate();
   if (Start && Start % PageSize)
     Start += PageSize - Start % PageSize;
 
   void *Addr = ::mmap(reinterpret_cast<void *>(Start), NumBytes, Protect,
                       MMFlags, fd, 0);
   if (Addr == MAP_FAILED) {
     if (NearBlock) //Try again without a near hint
       return allocateMappedMemory(NumBytes, nullptr, PFlags, EC);
Memory::releaseMappedMemory(MemoryBlock &M) {
   M.Address = nullptr;
   M.Size = 0;
 
   return std::error_code();
 }
 
 std::error_code
 Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
-  static const size_t PageSize = Process::getPageSize();
+  static const size_t PageSize = Process::getPageSizeEstimate();
   if (M.Address == nullptr || M.Size == 0)
     return std::error_code();
 
   if (!Flags)
     return std::error_code(EINVAL, std::generic_category());
 
   int Protect = getPosixProtectionFlags(Flags);
   uintptr_t Start = alignAddr((uint8_t *)M.Address - PageSize + 1, PageSize);

lib/Support/Unix/Path.inc

 }
 
 const char *mapped_file_region::const_data() const {
   assert(Mapping && "Mapping failed but used anyway!");
   return reinterpret_cast<const char*>(Mapping);
 }
 
 int mapped_file_region::alignment() {
-  return Process::getPageSize();
+  return Process::getPageSizeEstimate();
 }
 
 std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
                                                      StringRef path,
                                                      bool follow_symlinks) {
   SmallString<128> path_null(path);
   DIR *directory = ::opendir(path_null.c_str());
   if (!directory)

lib/Support/Unix/Process.inc

 #else
 #warning Cannot get usage times on this platform
   return { std::chrono::microseconds::zero(), std::chrono::microseconds::zero() };
 #endif
 }
 
 // On Cygwin, getpagesize() returns 64k(AllocationGranularity) and
 // offset in mmap(3) should be aligned to the AllocationGranularity.
-unsigned Process::getPageSize() {
+Expected<unsigned> Process::getPageSize() {
 #if defined(HAVE_GETPAGESIZE)
   static const int page_size = ::getpagesize();
 #elif defined(HAVE_SYSCONF)
   static long page_size = ::sysconf(_SC_PAGE_SIZE);
 #else
 #error Cannot get the page size on this machine
 #endif
+  if (page_size == -1)
+    return errorCodeToError(std::error_code(errno, std::generic_category()));
+
   return static_cast<unsigned>(page_size);
 }
 
 size_t Process::GetMallocUsage() {
 #if defined(HAVE_MALLINFO)
   struct mallinfo mi;
   mi = ::mallinfo();
   return mi.uordblks;

lib/Support/Windows/Process.inc

static unsigned computePageSize() {
   // from GetSystemInfo() in 32-bit applications running under WOW64.
   SYSTEM_INFO info;
   GetNativeSystemInfo(&info);
   // FIXME: FileOffset in MapViewOfFile() should be aligned to not dwPageSize,
   // but dwAllocationGranularity.
   return static_cast<unsigned>(info.dwPageSize);
 }
 
-unsigned Process::getPageSize() {
+Expected<unsigned> Process::getPageSize() {
   static unsigned Ret = computePageSize();
   return Ret;
 }
 
 size_t
 Process::GetMallocUsage()
 {
   _HEAPINFO hinfo;

unittests/Support/MemoryTest.cpp

#else
   return false;
 #endif
 }
 
 class MappedMemoryTest : public ::testing::TestWithParam<unsigned> {
 public:
   MappedMemoryTest() {
     Flags = GetParam();
-    PageSize = sys::Process::getPageSize();
+    PageSize = sys::Process::getPageSizeEstimate();
   }
 
 protected:
   // Adds RW flags to permit testing of the resulting memory
   unsigned getTestableEquivalent(unsigned RequestedFlags) {
     switch (RequestedFlags) {
     case Memory::MF_READ:
     case Memory::MF_WRITE: