[sanitizer_common] Use zx_system_get_page_size() on Fuchsia

[mcgrathr]

Summary

Fuchsia is migrating to a variable page size.

[phosek]

LGTM

[charco]

The CL seems fine, but should we use sanitizer_common's GetPageSizeCached()[0] where we call GetPageSize() ? Fuchsia documentation indicates that it's OK for user apps to cache that value.

[0]: https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/sanitizer_common/sanitizer_common.h#L72-L78
[1]: https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs/0016_boot_time_page_sizes

[mcgrathr]

In D95919#2538591, @charco wrote:

The CL seems fine, but should we use sanitizer_common's GetPageSizeCached()[0] where we call GetPageSize() ? Fuchsia documentation indicates that it's OK for user apps to cache that value.

It's fine to cache the value, but the question is whether it's worthwhile. The zx_system_get_page_size() call is literally a shared library function call that returns the value of a global variable. So it's already just as cheap as a local cache would be except for the PLT overhead of calling a shared library function rather than a local function (that might be LTO'd away to direct access to the global). I don't have data, but my intuition is that all in all the PLT overhead in those calls does less harm than the extra code and data space for a local cache.

[charco]

Ah! It is already in the VDSO! I thought it was a regular system call, my bad. Fuchsia should probably document that.

[mcgrathr]

In D95919#2539790, @charco wrote:

Ah! It is already in the VDSO! I thought it was a regular system call, my bad. Fuchsia should probably document that.

It is not really part of the semantics how the vDSO is implemented. But it is the case that all the zx_system_get_* calls are quite cheap and we could at least document that expectation.

compiler-rt/lib/asan/asan_fuchsia.cpp

 // (below) will call AsanThread::TSDDtor directly.
 void AsanTSDInit(void (*destructor)(void *tsd)) {
   DCHECK(destructor == &PlatformTSDDtor);
 }
 
 void PlatformTSDDtor(void *tsd) { UNREACHABLE(__func__); }
 
 static inline size_t AsanThreadMmapSize() {
-  return RoundUpTo(sizeof(AsanThread), PAGE_SIZE);
+  return RoundUpTo(sizeof(AsanThread), _zx_system_get_page_size());
 }
 
 struct AsanThread::InitOptions {
   uptr stack_bottom, stack_size;
 };
 
 // Shared setup between thread creation and startup for the initial thread.
 static AsanThread *CreateAsanThread(StackTrace *stack, u32 parent_tid,

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cpp

 //===-- sanitizer_fuchsia.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and other sanitizer
 // run-time libraries and implements Fuchsia-specific functions from
 // sanitizer_common.h.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_fuchsia.h"
 #if SANITIZER_FUCHSIA
 
-#include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <zircon/errors.h>
 #include <zircon/process.h>
 #include <zircon/syscalls.h>
 #include <zircon/utc.h>
 
zx_status_t status =
       _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &info,
                           sizeof(info), NULL, NULL);
   CHECK_EQ(status, ZX_OK);
   uptr pid = static_cast<uptr>(info.koid);
   CHECK_EQ(pid, info.koid);
   return pid;
 }
 
-int internal_dlinfo(void *handle, int request, void *p) {
-  UNIMPLEMENTED();
-}
+int internal_dlinfo(void *handle, int request, void *p) { UNIMPLEMENTED(); }
 
 uptr GetThreadSelf() { return reinterpret_cast<uptr>(thrd_current()); }
 
 tid_t GetTid() { return GetThreadSelf(); }
 
 void Abort() { abort(); }
 
 int Atexit(void (*function)(void)) { return atexit(function); }
void BlockingMutex::Unlock() {
   }
 }
 
 void BlockingMutex::CheckLocked() {
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
   CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed));
 }
 
-uptr GetPageSize() { return PAGE_SIZE; }
+uptr GetPageSize() { return _zx_system_get_page_size(); }
 
-uptr GetMmapGranularity() { return PAGE_SIZE; }
+uptr GetMmapGranularity() { return _zx_system_get_page_size(); }
 
 sanitizer_shadow_bounds_t ShadowBounds;
 
 uptr GetMaxUserVirtualAddress() {
   ShadowBounds = __sanitizer_shadow_bounds();
   return ShadowBounds.memory_limit - 1;
 }
 
 uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }
 
 static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type,
                                   bool raw_report, bool die_for_nomem) {
-  size = RoundUpTo(size, PAGE_SIZE);
+  size = RoundUpTo(size, GetPageSize());
 
   zx_handle_t vmo;
   zx_status_t status = _zx_vmo_create(size, 0, &vmo);
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY || die_for_nomem)
       ReportMmapFailureAndDie(size, mem_type, "zx_vmo_create", status,
                               raw_report);
     return nullptr;

 }
 
 void *MmapOrDieOnFatalError(uptr size, const char *mem_type) {
   return DoAnonymousMmapOrDie(size, mem_type, false, false);
 }
 
 uptr ReservedAddressRange::Init(uptr init_size, const char *name,
                                 uptr fixed_addr) {
-  init_size = RoundUpTo(init_size, PAGE_SIZE);
+  init_size = RoundUpTo(init_size, GetPageSize());
   DCHECK_EQ(os_handle_, ZX_HANDLE_INVALID);
   uintptr_t base;
   zx_handle_t vmar;
-  zx_status_t status =
-      _zx_vmar_allocate(
-          _zx_vmar_root_self(),
-          ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC,
-          0, init_size, &vmar, &base);
+  zx_status_t status = _zx_vmar_allocate(
+      ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
+      init_size, &vmar, &base);
   if (status != ZX_OK)
     ReportMmapFailureAndDie(init_size, name, "zx_vmar_allocate", status);
   base_ = reinterpret_cast<void *>(base);
   size_ = init_size;
   name_ = name;
   os_handle_ = vmar;
 
   return reinterpret_cast<uptr>(base_);
 }
 
 static uptr DoMmapFixedOrDie(zx_handle_t vmar, uptr fixed_addr, uptr map_size,
                              void *base, const char *name, bool die_for_nomem) {
   uptr offset = fixed_addr - reinterpret_cast<uptr>(base);
-  map_size = RoundUpTo(map_size, PAGE_SIZE);
+  map_size = RoundUpTo(map_size, GetPageSize());
   zx_handle_t vmo;
   zx_status_t status = _zx_vmo_create(map_size, 0, &vmo);
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY || die_for_nomem)
       ReportMmapFailureAndDie(map_size, name, "zx_vmo_create", status);
     return 0;
   }
   _zx_object_set_property(vmo, ZX_PROP_NAME, name, internal_strlen(name));
if (status != ZX_OK) {
     return 0;
   }
   IncreaseTotalMmap(map_size);
   return addr;
 }
 
 uptr ReservedAddressRange::Map(uptr fixed_addr, uptr map_size,
                                const char *name) {
-  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_,
-                          name_, false);
+  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, name_,
+                          false);
 }
 
 uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr map_size,
                                     const char *name) {
-  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_,
-                          name_, true);
+  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, name_, true);
 }
 
 void UnmapOrDieVmar(void *addr, uptr size, zx_handle_t target_vmar) {
-  if (!addr || !size) return;
-  size = RoundUpTo(size, PAGE_SIZE);
+  if (!addr || !size)
+    return;
+  size = RoundUpTo(size, GetPageSize());
 
   zx_status_t status =
       _zx_vmar_unmap(target_vmar, reinterpret_cast<uintptr_t>(addr), size);
   if (status != ZX_OK) {
     Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n",
            SanitizerToolName, size, size, addr);
     CHECK("unable to unmap" && 0);
   }

 
 // This should never be called.
 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) {
   UNIMPLEMENTED();
 }
 
 void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
                                    const char *mem_type) {
-  CHECK_GE(size, PAGE_SIZE);
+  CHECK_GE(size, GetPageSize());
   CHECK(IsPowerOfTwo(size));
   CHECK(IsPowerOfTwo(alignment));
 
   zx_handle_t vmo;
   zx_status_t status = _zx_vmo_create(size, 0, &vmo);
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY)
       ReportMmapFailureAndDie(size, mem_type, "zx_vmo_create", status, false);
if (addr != map_addr) {
       status = _zx_object_get_info(_zx_vmar_root_self(), ZX_INFO_VMAR, &info,
                                    sizeof(info), NULL, NULL);
       if (status == ZX_OK) {
         uintptr_t new_addr;
         status = _zx_vmar_map(
             _zx_vmar_root_self(),
             ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE,
             addr - info.base, vmo, 0, size, &new_addr);
-        if (status == ZX_OK) CHECK_EQ(new_addr, addr);
+        if (status == ZX_OK)
+          CHECK_EQ(new_addr, addr);
       }
     }
     if (status == ZX_OK && addr != map_addr)
       status = _zx_vmar_unmap(_zx_vmar_root_self(), map_addr, addr - map_addr);
     if (status == ZX_OK && end != map_end)
       status = _zx_vmar_unmap(_zx_vmar_root_self(), end, map_end - end);
   }
   _zx_handle_close(vmo);
void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
   return reinterpret_cast<void *>(addr);
 }
 
 void UnmapOrDie(void *addr, uptr size) {
   UnmapOrDieVmar(addr, size, _zx_vmar_root_self());
 }
 
 void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
-  uptr beg_aligned = RoundUpTo(beg, PAGE_SIZE);
-  uptr end_aligned = RoundDownTo(end, PAGE_SIZE);
+  uptr beg_aligned = RoundUpTo(beg, GetPageSize());
+  uptr end_aligned = RoundDownTo(end, GetPageSize());
   if (beg_aligned < end_aligned) {
     zx_handle_t root_vmar = _zx_vmar_root_self();
     CHECK_NE(root_vmar, ZX_HANDLE_INVALID);
     zx_status_t status =
         _zx_vmar_op_range(root_vmar, ZX_VMAR_OP_DECOMMIT, beg_aligned,
                           end_aligned - beg_aligned, nullptr, 0);
     CHECK_EQ(status, ZX_OK);
   }

 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len, error_t *errno_p) {
   zx_handle_t vmo;
   zx_status_t status = __sanitizer_get_configuration(file_name, &vmo);
   if (status == ZX_OK) {
     uint64_t vmo_size;
     status = _zx_vmo_get_size(vmo, &vmo_size);
     if (status == ZX_OK) {
-      if (vmo_size < max_len) max_len = vmo_size;
-      size_t map_size = RoundUpTo(max_len, PAGE_SIZE);
+      if (vmo_size < max_len)
+        max_len = vmo_size;
+      size_t map_size = RoundUpTo(max_len, GetPageSize());
       uintptr_t addr;
       status = _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0,
                             map_size, &addr);
       if (status == ZX_OK) {
         *buff = reinterpret_cast<char *>(addr);
         *buff_size = map_size;
         *read_len = max_len;
       }
     }
     _zx_handle_close(vmo);
   }
-  if (status != ZX_OK && errno_p) *errno_p = status;
+  if (status != ZX_OK && errno_p)
+    *errno_p = status;
   return status == ZX_OK;
 }
 
 void RawWrite(const char *buffer) {
   constexpr size_t size = 128;
   static _Thread_local char line[size];
   static _Thread_local size_t lastLineEnd = 0;
   static _Thread_local size_t cur = 0;

 uptr MainThreadStackBase, MainThreadStackSize;
 
 bool GetRandom(void *buffer, uptr length, bool blocking) {
   CHECK_LE(length, ZX_CPRNG_DRAW_MAX_LEN);
   _zx_cprng_draw(buffer, length);
   return true;
 }
 
-u32 GetNumberOfCPUs() {
-  return zx_system_get_num_cpus();
-}
+u32 GetNumberOfCPUs() { return zx_system_get_num_cpus(); }
 
 uptr GetRSS() { UNIMPLEMENTED(); }
 
 void InitializePlatformCommonFlags(CommonFlags *cf) {}
 
 }  // namespace __sanitizer
 
 using namespace __sanitizer;