168d75effSDimitry Andric //===-- sanitizer_fuchsia.cpp ---------------------------------------------===// 268d75effSDimitry Andric // 368d75effSDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 468d75effSDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 568d75effSDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 668d75effSDimitry Andric // 768d75effSDimitry Andric //===----------------------------------------------------------------------===// 868d75effSDimitry Andric // 968d75effSDimitry Andric // This file is shared between AddressSanitizer and other sanitizer 1068d75effSDimitry Andric // run-time libraries and implements Fuchsia-specific functions from 1168d75effSDimitry Andric // sanitizer_common.h. 1268d75effSDimitry Andric //===----------------------------------------------------------------------===// 1368d75effSDimitry Andric 1468d75effSDimitry Andric #include "sanitizer_fuchsia.h" 1568d75effSDimitry Andric #if SANITIZER_FUCHSIA 1668d75effSDimitry Andric 1768d75effSDimitry Andric #include <limits.h> 1868d75effSDimitry Andric #include <pthread.h> 1968d75effSDimitry Andric #include <stdlib.h> 2068d75effSDimitry Andric #include <unistd.h> 2168d75effSDimitry Andric #include <zircon/errors.h> 2268d75effSDimitry Andric #include <zircon/process.h> 2368d75effSDimitry Andric #include <zircon/syscalls.h> 24*e8d8bef9SDimitry Andric #include <zircon/utc.h> 25*e8d8bef9SDimitry Andric 26*e8d8bef9SDimitry Andric #include "sanitizer_common.h" 27*e8d8bef9SDimitry Andric #include "sanitizer_libc.h" 28*e8d8bef9SDimitry Andric #include "sanitizer_mutex.h" 2968d75effSDimitry Andric 3068d75effSDimitry Andric namespace __sanitizer { 3168d75effSDimitry Andric 3268d75effSDimitry Andric void NORETURN internal__exit(int exitcode) { _zx_process_exit(exitcode); } 3368d75effSDimitry Andric 3468d75effSDimitry Andric uptr internal_sched_yield() { 3568d75effSDimitry Andric zx_status_t status = _zx_nanosleep(0); 3668d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 3768d75effSDimitry Andric return 0; // Why doesn't this return void? 3868d75effSDimitry Andric } 3968d75effSDimitry Andric 4068d75effSDimitry Andric static void internal_nanosleep(zx_time_t ns) { 4168d75effSDimitry Andric zx_status_t status = _zx_nanosleep(_zx_deadline_after(ns)); 4268d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 4368d75effSDimitry Andric } 4468d75effSDimitry Andric 4568d75effSDimitry Andric unsigned int internal_sleep(unsigned int seconds) { 4668d75effSDimitry Andric internal_nanosleep(ZX_SEC(seconds)); 4768d75effSDimitry Andric return 0; 4868d75effSDimitry Andric } 4968d75effSDimitry Andric 5068d75effSDimitry Andric u64 NanoTime() { 51*e8d8bef9SDimitry Andric zx_handle_t utc_clock = _zx_utc_reference_get(); 52*e8d8bef9SDimitry Andric CHECK_NE(utc_clock, ZX_HANDLE_INVALID); 5368d75effSDimitry Andric zx_time_t time; 54*e8d8bef9SDimitry Andric zx_status_t status = _zx_clock_read(utc_clock, &time); 5568d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 5668d75effSDimitry Andric return time; 5768d75effSDimitry Andric } 5868d75effSDimitry Andric 5968d75effSDimitry Andric u64 MonotonicNanoTime() { return _zx_clock_get_monotonic(); } 6068d75effSDimitry Andric 6168d75effSDimitry Andric uptr internal_getpid() { 6268d75effSDimitry Andric zx_info_handle_basic_t info; 6368d75effSDimitry Andric zx_status_t status = 6468d75effSDimitry Andric _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &info, 6568d75effSDimitry Andric sizeof(info), NULL, NULL); 6668d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 6768d75effSDimitry Andric uptr pid = static_cast<uptr>(info.koid); 6868d75effSDimitry Andric CHECK_EQ(pid, info.koid); 6968d75effSDimitry Andric return pid; 7068d75effSDimitry Andric } 7168d75effSDimitry Andric 725ffd83dbSDimitry Andric int internal_dlinfo(void *handle, int request, void *p) { 735ffd83dbSDimitry Andric UNIMPLEMENTED(); 745ffd83dbSDimitry Andric } 755ffd83dbSDimitry Andric 7668d75effSDimitry Andric uptr GetThreadSelf() { return reinterpret_cast<uptr>(thrd_current()); } 7768d75effSDimitry Andric 7868d75effSDimitry Andric tid_t GetTid() { return GetThreadSelf(); } 7968d75effSDimitry Andric 8068d75effSDimitry Andric void Abort() { abort(); } 8168d75effSDimitry Andric 8268d75effSDimitry Andric int Atexit(void (*function)(void)) { return atexit(function); } 8368d75effSDimitry Andric 8468d75effSDimitry Andric void SleepForSeconds(int seconds) { internal_sleep(seconds); } 8568d75effSDimitry Andric 8668d75effSDimitry Andric void SleepForMillis(int millis) { internal_nanosleep(ZX_MSEC(millis)); } 8768d75effSDimitry Andric 8868d75effSDimitry Andric void GetThreadStackTopAndBottom(bool, uptr *stack_top, uptr *stack_bottom) { 8968d75effSDimitry Andric pthread_attr_t attr; 9068d75effSDimitry Andric CHECK_EQ(pthread_getattr_np(pthread_self(), &attr), 0); 9168d75effSDimitry Andric void *base; 9268d75effSDimitry Andric size_t size; 9368d75effSDimitry Andric CHECK_EQ(pthread_attr_getstack(&attr, &base, &size), 0); 9468d75effSDimitry Andric CHECK_EQ(pthread_attr_destroy(&attr), 0); 9568d75effSDimitry Andric 9668d75effSDimitry Andric *stack_bottom = reinterpret_cast<uptr>(base); 9768d75effSDimitry Andric *stack_top = *stack_bottom + size; 9868d75effSDimitry Andric } 9968d75effSDimitry Andric 10068d75effSDimitry Andric void InitializePlatformEarly() {} 10168d75effSDimitry Andric void MaybeReexec() {} 10268d75effSDimitry Andric void CheckASLR() {} 10368d75effSDimitry Andric void CheckMPROTECT() {} 10468d75effSDimitry Andric void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {} 10568d75effSDimitry Andric void DisableCoreDumperIfNecessary() {} 10668d75effSDimitry Andric void InstallDeadlySignalHandlers(SignalHandlerType handler) {} 10768d75effSDimitry Andric void SetAlternateSignalStack() {} 10868d75effSDimitry Andric void UnsetAlternateSignalStack() {} 10968d75effSDimitry Andric void InitTlsSize() {} 11068d75effSDimitry Andric 11168d75effSDimitry Andric bool SignalContext::IsStackOverflow() const { return false; } 11268d75effSDimitry Andric void SignalContext::DumpAllRegisters(void *context) { UNIMPLEMENTED(); } 11368d75effSDimitry Andric const char *SignalContext::Describe() const { UNIMPLEMENTED(); } 11468d75effSDimitry Andric 11568d75effSDimitry Andric enum MutexState : int { MtxUnlocked = 0, MtxLocked = 1, MtxSleeping = 2 }; 11668d75effSDimitry Andric 11768d75effSDimitry Andric BlockingMutex::BlockingMutex() { 11868d75effSDimitry Andric // NOTE! It's important that this use internal_memset, because plain 11968d75effSDimitry Andric // memset might be intercepted (e.g., actually be __asan_memset). 12068d75effSDimitry Andric // Defining this so the compiler initializes each field, e.g.: 12168d75effSDimitry Andric // BlockingMutex::BlockingMutex() : BlockingMutex(LINKER_INITIALIZED) {} 12268d75effSDimitry Andric // might result in the compiler generating a call to memset, which would 12368d75effSDimitry Andric // have the same problem. 12468d75effSDimitry Andric internal_memset(this, 0, sizeof(*this)); 12568d75effSDimitry Andric } 12668d75effSDimitry Andric 12768d75effSDimitry Andric void BlockingMutex::Lock() { 12868d75effSDimitry Andric CHECK_EQ(owner_, 0); 12968d75effSDimitry Andric atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 13068d75effSDimitry Andric if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked) 13168d75effSDimitry Andric return; 13268d75effSDimitry Andric while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) { 13368d75effSDimitry Andric zx_status_t status = 13468d75effSDimitry Andric _zx_futex_wait(reinterpret_cast<zx_futex_t *>(m), MtxSleeping, 13568d75effSDimitry Andric ZX_HANDLE_INVALID, ZX_TIME_INFINITE); 13668d75effSDimitry Andric if (status != ZX_ERR_BAD_STATE) // Normal race. 13768d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 13868d75effSDimitry Andric } 13968d75effSDimitry Andric } 14068d75effSDimitry Andric 14168d75effSDimitry Andric void BlockingMutex::Unlock() { 14268d75effSDimitry Andric atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 14368d75effSDimitry Andric u32 v = atomic_exchange(m, MtxUnlocked, memory_order_release); 14468d75effSDimitry Andric CHECK_NE(v, MtxUnlocked); 14568d75effSDimitry Andric if (v == MtxSleeping) { 14668d75effSDimitry Andric zx_status_t status = _zx_futex_wake(reinterpret_cast<zx_futex_t *>(m), 1); 14768d75effSDimitry Andric CHECK_EQ(status, ZX_OK); 14868d75effSDimitry Andric } 14968d75effSDimitry Andric } 15068d75effSDimitry Andric 15168d75effSDimitry Andric void BlockingMutex::CheckLocked() { 15268d75effSDimitry Andric atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 15368d75effSDimitry Andric CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed)); 15468d75effSDimitry Andric } 15568d75effSDimitry Andric 15668d75effSDimitry Andric uptr GetPageSize() { return PAGE_SIZE; } 15768d75effSDimitry Andric 15868d75effSDimitry Andric uptr GetMmapGranularity() { return PAGE_SIZE; } 15968d75effSDimitry Andric 16068d75effSDimitry Andric sanitizer_shadow_bounds_t ShadowBounds; 16168d75effSDimitry Andric 16268d75effSDimitry Andric uptr GetMaxUserVirtualAddress() { 16368d75effSDimitry Andric ShadowBounds = __sanitizer_shadow_bounds(); 16468d75effSDimitry Andric return ShadowBounds.memory_limit - 1; 16568d75effSDimitry Andric } 16668d75effSDimitry Andric 16768d75effSDimitry Andric uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); } 16868d75effSDimitry Andric 16968d75effSDimitry Andric static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type, 17068d75effSDimitry Andric bool raw_report, bool die_for_nomem) { 17168d75effSDimitry Andric size = RoundUpTo(size, PAGE_SIZE); 17268d75effSDimitry Andric 17368d75effSDimitry Andric zx_handle_t vmo; 17468d75effSDimitry Andric zx_status_t status = _zx_vmo_create(size, 0, &vmo); 17568d75effSDimitry Andric if (status != ZX_OK) { 17668d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY || die_for_nomem) 17768d75effSDimitry Andric ReportMmapFailureAndDie(size, mem_type, "zx_vmo_create", status, 17868d75effSDimitry Andric raw_report); 17968d75effSDimitry Andric return nullptr; 18068d75effSDimitry Andric } 18168d75effSDimitry Andric _zx_object_set_property(vmo, ZX_PROP_NAME, mem_type, 18268d75effSDimitry Andric internal_strlen(mem_type)); 18368d75effSDimitry Andric 18468d75effSDimitry Andric // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that? 18568d75effSDimitry Andric uintptr_t addr; 18668d75effSDimitry Andric status = 18768d75effSDimitry Andric _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, 18868d75effSDimitry Andric vmo, 0, size, &addr); 18968d75effSDimitry Andric _zx_handle_close(vmo); 19068d75effSDimitry Andric 19168d75effSDimitry Andric if (status != ZX_OK) { 19268d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY || die_for_nomem) 19368d75effSDimitry Andric ReportMmapFailureAndDie(size, mem_type, "zx_vmar_map", status, 19468d75effSDimitry Andric raw_report); 19568d75effSDimitry Andric return nullptr; 19668d75effSDimitry Andric } 19768d75effSDimitry Andric 19868d75effSDimitry Andric IncreaseTotalMmap(size); 19968d75effSDimitry Andric 20068d75effSDimitry Andric return reinterpret_cast<void *>(addr); 20168d75effSDimitry Andric } 20268d75effSDimitry Andric 20368d75effSDimitry Andric void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) { 20468d75effSDimitry Andric return DoAnonymousMmapOrDie(size, mem_type, raw_report, true); 20568d75effSDimitry Andric } 20668d75effSDimitry Andric 20768d75effSDimitry Andric void *MmapNoReserveOrDie(uptr size, const char *mem_type) { 20868d75effSDimitry Andric return MmapOrDie(size, mem_type); 20968d75effSDimitry Andric } 21068d75effSDimitry Andric 21168d75effSDimitry Andric void *MmapOrDieOnFatalError(uptr size, const char *mem_type) { 21268d75effSDimitry Andric return DoAnonymousMmapOrDie(size, mem_type, false, false); 21368d75effSDimitry Andric } 21468d75effSDimitry Andric 21568d75effSDimitry Andric uptr ReservedAddressRange::Init(uptr init_size, const char *name, 21668d75effSDimitry Andric uptr fixed_addr) { 21768d75effSDimitry Andric init_size = RoundUpTo(init_size, PAGE_SIZE); 21868d75effSDimitry Andric DCHECK_EQ(os_handle_, ZX_HANDLE_INVALID); 21968d75effSDimitry Andric uintptr_t base; 22068d75effSDimitry Andric zx_handle_t vmar; 22168d75effSDimitry Andric zx_status_t status = 22268d75effSDimitry Andric _zx_vmar_allocate( 22368d75effSDimitry Andric _zx_vmar_root_self(), 22468d75effSDimitry Andric ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 22568d75effSDimitry Andric 0, init_size, &vmar, &base); 22668d75effSDimitry Andric if (status != ZX_OK) 22768d75effSDimitry Andric ReportMmapFailureAndDie(init_size, name, "zx_vmar_allocate", status); 22868d75effSDimitry Andric base_ = reinterpret_cast<void *>(base); 22968d75effSDimitry Andric size_ = init_size; 23068d75effSDimitry Andric name_ = name; 23168d75effSDimitry Andric os_handle_ = vmar; 23268d75effSDimitry Andric 23368d75effSDimitry Andric return reinterpret_cast<uptr>(base_); 23468d75effSDimitry Andric } 23568d75effSDimitry Andric 23668d75effSDimitry Andric static uptr DoMmapFixedOrDie(zx_handle_t vmar, uptr fixed_addr, uptr map_size, 23768d75effSDimitry Andric void *base, const char *name, bool die_for_nomem) { 23868d75effSDimitry Andric uptr offset = fixed_addr - reinterpret_cast<uptr>(base); 23968d75effSDimitry Andric map_size = RoundUpTo(map_size, PAGE_SIZE); 24068d75effSDimitry Andric zx_handle_t vmo; 24168d75effSDimitry Andric zx_status_t status = _zx_vmo_create(map_size, 0, &vmo); 24268d75effSDimitry Andric if (status != ZX_OK) { 24368d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY || die_for_nomem) 24468d75effSDimitry Andric ReportMmapFailureAndDie(map_size, name, "zx_vmo_create", status); 24568d75effSDimitry Andric return 0; 24668d75effSDimitry Andric } 24768d75effSDimitry Andric _zx_object_set_property(vmo, ZX_PROP_NAME, name, internal_strlen(name)); 24868d75effSDimitry Andric DCHECK_GE(base + size_, map_size + offset); 24968d75effSDimitry Andric uintptr_t addr; 25068d75effSDimitry Andric 25168d75effSDimitry Andric status = 25268d75effSDimitry Andric _zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 25368d75effSDimitry Andric offset, vmo, 0, map_size, &addr); 25468d75effSDimitry Andric _zx_handle_close(vmo); 25568d75effSDimitry Andric if (status != ZX_OK) { 25668d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY || die_for_nomem) { 25768d75effSDimitry Andric ReportMmapFailureAndDie(map_size, name, "zx_vmar_map", status); 25868d75effSDimitry Andric } 25968d75effSDimitry Andric return 0; 26068d75effSDimitry Andric } 26168d75effSDimitry Andric IncreaseTotalMmap(map_size); 26268d75effSDimitry Andric return addr; 26368d75effSDimitry Andric } 26468d75effSDimitry Andric 26568d75effSDimitry Andric uptr ReservedAddressRange::Map(uptr fixed_addr, uptr map_size, 26668d75effSDimitry Andric const char *name) { 26768d75effSDimitry Andric return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, 26868d75effSDimitry Andric name_, false); 26968d75effSDimitry Andric } 27068d75effSDimitry Andric 27168d75effSDimitry Andric uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr map_size, 27268d75effSDimitry Andric const char *name) { 27368d75effSDimitry Andric return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, 27468d75effSDimitry Andric name_, true); 27568d75effSDimitry Andric } 27668d75effSDimitry Andric 27768d75effSDimitry Andric void UnmapOrDieVmar(void *addr, uptr size, zx_handle_t target_vmar) { 27868d75effSDimitry Andric if (!addr || !size) return; 27968d75effSDimitry Andric size = RoundUpTo(size, PAGE_SIZE); 28068d75effSDimitry Andric 28168d75effSDimitry Andric zx_status_t status = 28268d75effSDimitry Andric _zx_vmar_unmap(target_vmar, reinterpret_cast<uintptr_t>(addr), size); 28368d75effSDimitry Andric if (status != ZX_OK) { 28468d75effSDimitry Andric Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n", 28568d75effSDimitry Andric SanitizerToolName, size, size, addr); 28668d75effSDimitry Andric CHECK("unable to unmap" && 0); 28768d75effSDimitry Andric } 28868d75effSDimitry Andric 28968d75effSDimitry Andric DecreaseTotalMmap(size); 29068d75effSDimitry Andric } 29168d75effSDimitry Andric 29268d75effSDimitry Andric void ReservedAddressRange::Unmap(uptr addr, uptr size) { 29368d75effSDimitry Andric CHECK_LE(size, size_); 29468d75effSDimitry Andric const zx_handle_t vmar = static_cast<zx_handle_t>(os_handle_); 29568d75effSDimitry Andric if (addr == reinterpret_cast<uptr>(base_)) { 29668d75effSDimitry Andric if (size == size_) { 29768d75effSDimitry Andric // Destroying the vmar effectively unmaps the whole mapping. 29868d75effSDimitry Andric _zx_vmar_destroy(vmar); 29968d75effSDimitry Andric _zx_handle_close(vmar); 30068d75effSDimitry Andric os_handle_ = static_cast<uptr>(ZX_HANDLE_INVALID); 30168d75effSDimitry Andric DecreaseTotalMmap(size); 30268d75effSDimitry Andric return; 30368d75effSDimitry Andric } 30468d75effSDimitry Andric } else { 30568d75effSDimitry Andric CHECK_EQ(addr + size, reinterpret_cast<uptr>(base_) + size_); 30668d75effSDimitry Andric } 30768d75effSDimitry Andric // Partial unmapping does not affect the fact that the initial range is still 30868d75effSDimitry Andric // reserved, and the resulting unmapped memory can't be reused. 30968d75effSDimitry Andric UnmapOrDieVmar(reinterpret_cast<void *>(addr), size, vmar); 31068d75effSDimitry Andric } 31168d75effSDimitry Andric 31268d75effSDimitry Andric // This should never be called. 31368d75effSDimitry Andric void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { 31468d75effSDimitry Andric UNIMPLEMENTED(); 31568d75effSDimitry Andric } 31668d75effSDimitry Andric 31768d75effSDimitry Andric void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment, 31868d75effSDimitry Andric const char *mem_type) { 31968d75effSDimitry Andric CHECK_GE(size, PAGE_SIZE); 32068d75effSDimitry Andric CHECK(IsPowerOfTwo(size)); 32168d75effSDimitry Andric CHECK(IsPowerOfTwo(alignment)); 32268d75effSDimitry Andric 32368d75effSDimitry Andric zx_handle_t vmo; 32468d75effSDimitry Andric zx_status_t status = _zx_vmo_create(size, 0, &vmo); 32568d75effSDimitry Andric if (status != ZX_OK) { 32668d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY) 32768d75effSDimitry Andric ReportMmapFailureAndDie(size, mem_type, "zx_vmo_create", status, false); 32868d75effSDimitry Andric return nullptr; 32968d75effSDimitry Andric } 33068d75effSDimitry Andric _zx_object_set_property(vmo, ZX_PROP_NAME, mem_type, 33168d75effSDimitry Andric internal_strlen(mem_type)); 33268d75effSDimitry Andric 33368d75effSDimitry Andric // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that? 33468d75effSDimitry Andric 33568d75effSDimitry Andric // Map a larger size to get a chunk of address space big enough that 33668d75effSDimitry Andric // it surely contains an aligned region of the requested size. Then 33768d75effSDimitry Andric // overwrite the aligned middle portion with a mapping from the 33868d75effSDimitry Andric // beginning of the VMO, and unmap the excess before and after. 33968d75effSDimitry Andric size_t map_size = size + alignment; 34068d75effSDimitry Andric uintptr_t addr; 34168d75effSDimitry Andric status = 34268d75effSDimitry Andric _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, 34368d75effSDimitry Andric vmo, 0, map_size, &addr); 34468d75effSDimitry Andric if (status == ZX_OK) { 34568d75effSDimitry Andric uintptr_t map_addr = addr; 34668d75effSDimitry Andric uintptr_t map_end = map_addr + map_size; 34768d75effSDimitry Andric addr = RoundUpTo(map_addr, alignment); 34868d75effSDimitry Andric uintptr_t end = addr + size; 34968d75effSDimitry Andric if (addr != map_addr) { 35068d75effSDimitry Andric zx_info_vmar_t info; 35168d75effSDimitry Andric status = _zx_object_get_info(_zx_vmar_root_self(), ZX_INFO_VMAR, &info, 35268d75effSDimitry Andric sizeof(info), NULL, NULL); 35368d75effSDimitry Andric if (status == ZX_OK) { 35468d75effSDimitry Andric uintptr_t new_addr; 35568d75effSDimitry Andric status = _zx_vmar_map( 35668d75effSDimitry Andric _zx_vmar_root_self(), 35768d75effSDimitry Andric ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE, 35868d75effSDimitry Andric addr - info.base, vmo, 0, size, &new_addr); 35968d75effSDimitry Andric if (status == ZX_OK) CHECK_EQ(new_addr, addr); 36068d75effSDimitry Andric } 36168d75effSDimitry Andric } 36268d75effSDimitry Andric if (status == ZX_OK && addr != map_addr) 36368d75effSDimitry Andric status = _zx_vmar_unmap(_zx_vmar_root_self(), map_addr, addr - map_addr); 36468d75effSDimitry Andric if (status == ZX_OK && end != map_end) 36568d75effSDimitry Andric status = _zx_vmar_unmap(_zx_vmar_root_self(), end, map_end - end); 36668d75effSDimitry Andric } 36768d75effSDimitry Andric _zx_handle_close(vmo); 36868d75effSDimitry Andric 36968d75effSDimitry Andric if (status != ZX_OK) { 37068d75effSDimitry Andric if (status != ZX_ERR_NO_MEMORY) 37168d75effSDimitry Andric ReportMmapFailureAndDie(size, mem_type, "zx_vmar_map", status, false); 37268d75effSDimitry Andric return nullptr; 37368d75effSDimitry Andric } 37468d75effSDimitry Andric 37568d75effSDimitry Andric IncreaseTotalMmap(size); 37668d75effSDimitry Andric 37768d75effSDimitry Andric return reinterpret_cast<void *>(addr); 37868d75effSDimitry Andric } 37968d75effSDimitry Andric 38068d75effSDimitry Andric void UnmapOrDie(void *addr, uptr size) { 38168d75effSDimitry Andric UnmapOrDieVmar(addr, size, _zx_vmar_root_self()); 38268d75effSDimitry Andric } 38368d75effSDimitry Andric 38468d75effSDimitry Andric // This is used on the shadow mapping, which cannot be changed. 38568d75effSDimitry Andric // Zircon doesn't have anything like MADV_DONTNEED. 38668d75effSDimitry Andric void ReleaseMemoryPagesToOS(uptr beg, uptr end) {} 38768d75effSDimitry Andric 38868d75effSDimitry Andric void DumpProcessMap() { 38968d75effSDimitry Andric // TODO(mcgrathr): write it 39068d75effSDimitry Andric return; 39168d75effSDimitry Andric } 39268d75effSDimitry Andric 39368d75effSDimitry Andric bool IsAccessibleMemoryRange(uptr beg, uptr size) { 39468d75effSDimitry Andric // TODO(mcgrathr): Figure out a better way. 39568d75effSDimitry Andric zx_handle_t vmo; 39668d75effSDimitry Andric zx_status_t status = _zx_vmo_create(size, 0, &vmo); 39768d75effSDimitry Andric if (status == ZX_OK) { 39868d75effSDimitry Andric status = _zx_vmo_write(vmo, reinterpret_cast<const void *>(beg), 0, size); 39968d75effSDimitry Andric _zx_handle_close(vmo); 40068d75effSDimitry Andric } 40168d75effSDimitry Andric return status == ZX_OK; 40268d75effSDimitry Andric } 40368d75effSDimitry Andric 40468d75effSDimitry Andric // FIXME implement on this platform. 40568d75effSDimitry Andric void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) {} 40668d75effSDimitry Andric 40768d75effSDimitry Andric bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size, 40868d75effSDimitry Andric uptr *read_len, uptr max_len, error_t *errno_p) { 40968d75effSDimitry Andric zx_handle_t vmo; 41068d75effSDimitry Andric zx_status_t status = __sanitizer_get_configuration(file_name, &vmo); 41168d75effSDimitry Andric if (status == ZX_OK) { 41268d75effSDimitry Andric uint64_t vmo_size; 41368d75effSDimitry Andric status = _zx_vmo_get_size(vmo, &vmo_size); 41468d75effSDimitry Andric if (status == ZX_OK) { 41568d75effSDimitry Andric if (vmo_size < max_len) max_len = vmo_size; 41668d75effSDimitry Andric size_t map_size = RoundUpTo(max_len, PAGE_SIZE); 41768d75effSDimitry Andric uintptr_t addr; 41868d75effSDimitry Andric status = _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, 41968d75effSDimitry Andric map_size, &addr); 42068d75effSDimitry Andric if (status == ZX_OK) { 42168d75effSDimitry Andric *buff = reinterpret_cast<char *>(addr); 42268d75effSDimitry Andric *buff_size = map_size; 42368d75effSDimitry Andric *read_len = max_len; 42468d75effSDimitry Andric } 42568d75effSDimitry Andric } 42668d75effSDimitry Andric _zx_handle_close(vmo); 42768d75effSDimitry Andric } 42868d75effSDimitry Andric if (status != ZX_OK && errno_p) *errno_p = status; 42968d75effSDimitry Andric return status == ZX_OK; 43068d75effSDimitry Andric } 43168d75effSDimitry Andric 43268d75effSDimitry Andric void RawWrite(const char *buffer) { 43368d75effSDimitry Andric constexpr size_t size = 128; 43468d75effSDimitry Andric static _Thread_local char line[size]; 43568d75effSDimitry Andric static _Thread_local size_t lastLineEnd = 0; 43668d75effSDimitry Andric static _Thread_local size_t cur = 0; 43768d75effSDimitry Andric 43868d75effSDimitry Andric while (*buffer) { 43968d75effSDimitry Andric if (cur >= size) { 44068d75effSDimitry Andric if (lastLineEnd == 0) 44168d75effSDimitry Andric lastLineEnd = size; 44268d75effSDimitry Andric __sanitizer_log_write(line, lastLineEnd); 44368d75effSDimitry Andric internal_memmove(line, line + lastLineEnd, cur - lastLineEnd); 44468d75effSDimitry Andric cur = cur - lastLineEnd; 44568d75effSDimitry Andric lastLineEnd = 0; 44668d75effSDimitry Andric } 44768d75effSDimitry Andric if (*buffer == '\n') 44868d75effSDimitry Andric lastLineEnd = cur + 1; 44968d75effSDimitry Andric line[cur++] = *buffer++; 45068d75effSDimitry Andric } 45168d75effSDimitry Andric // Flush all complete lines before returning. 45268d75effSDimitry Andric if (lastLineEnd != 0) { 45368d75effSDimitry Andric __sanitizer_log_write(line, lastLineEnd); 45468d75effSDimitry Andric internal_memmove(line, line + lastLineEnd, cur - lastLineEnd); 45568d75effSDimitry Andric cur = cur - lastLineEnd; 45668d75effSDimitry Andric lastLineEnd = 0; 45768d75effSDimitry Andric } 45868d75effSDimitry Andric } 45968d75effSDimitry Andric 46068d75effSDimitry Andric void CatastrophicErrorWrite(const char *buffer, uptr length) { 46168d75effSDimitry Andric __sanitizer_log_write(buffer, length); 46268d75effSDimitry Andric } 46368d75effSDimitry Andric 46468d75effSDimitry Andric char **StoredArgv; 46568d75effSDimitry Andric char **StoredEnviron; 46668d75effSDimitry Andric 46768d75effSDimitry Andric char **GetArgv() { return StoredArgv; } 46868d75effSDimitry Andric char **GetEnviron() { return StoredEnviron; } 46968d75effSDimitry Andric 47068d75effSDimitry Andric const char *GetEnv(const char *name) { 47168d75effSDimitry Andric if (StoredEnviron) { 47268d75effSDimitry Andric uptr NameLen = internal_strlen(name); 47368d75effSDimitry Andric for (char **Env = StoredEnviron; *Env != 0; Env++) { 47468d75effSDimitry Andric if (internal_strncmp(*Env, name, NameLen) == 0 && (*Env)[NameLen] == '=') 47568d75effSDimitry Andric return (*Env) + NameLen + 1; 47668d75effSDimitry Andric } 47768d75effSDimitry Andric } 47868d75effSDimitry Andric return nullptr; 47968d75effSDimitry Andric } 48068d75effSDimitry Andric 48168d75effSDimitry Andric uptr ReadBinaryName(/*out*/ char *buf, uptr buf_len) { 48268d75effSDimitry Andric const char *argv0 = "<UNKNOWN>"; 48368d75effSDimitry Andric if (StoredArgv && StoredArgv[0]) { 48468d75effSDimitry Andric argv0 = StoredArgv[0]; 48568d75effSDimitry Andric } 48668d75effSDimitry Andric internal_strncpy(buf, argv0, buf_len); 48768d75effSDimitry Andric return internal_strlen(buf); 48868d75effSDimitry Andric } 48968d75effSDimitry Andric 49068d75effSDimitry Andric uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) { 49168d75effSDimitry Andric return ReadBinaryName(buf, buf_len); 49268d75effSDimitry Andric } 49368d75effSDimitry Andric 49468d75effSDimitry Andric uptr MainThreadStackBase, MainThreadStackSize; 49568d75effSDimitry Andric 49668d75effSDimitry Andric bool GetRandom(void *buffer, uptr length, bool blocking) { 49768d75effSDimitry Andric CHECK_LE(length, ZX_CPRNG_DRAW_MAX_LEN); 49868d75effSDimitry Andric _zx_cprng_draw(buffer, length); 49968d75effSDimitry Andric return true; 50068d75effSDimitry Andric } 50168d75effSDimitry Andric 50268d75effSDimitry Andric u32 GetNumberOfCPUs() { 50368d75effSDimitry Andric return zx_system_get_num_cpus(); 50468d75effSDimitry Andric } 50568d75effSDimitry Andric 50668d75effSDimitry Andric uptr GetRSS() { UNIMPLEMENTED(); } 50768d75effSDimitry Andric 508*e8d8bef9SDimitry Andric void InitializePlatformCommonFlags(CommonFlags *cf) {} 509*e8d8bef9SDimitry Andric 51068d75effSDimitry Andric } // namespace __sanitizer 51168d75effSDimitry Andric 51268d75effSDimitry Andric using namespace __sanitizer; 51368d75effSDimitry Andric 51468d75effSDimitry Andric extern "C" { 51568d75effSDimitry Andric void __sanitizer_startup_hook(int argc, char **argv, char **envp, 51668d75effSDimitry Andric void *stack_base, size_t stack_size) { 51768d75effSDimitry Andric __sanitizer::StoredArgv = argv; 51868d75effSDimitry Andric __sanitizer::StoredEnviron = envp; 51968d75effSDimitry Andric __sanitizer::MainThreadStackBase = reinterpret_cast<uintptr_t>(stack_base); 52068d75effSDimitry Andric __sanitizer::MainThreadStackSize = stack_size; 52168d75effSDimitry Andric } 52268d75effSDimitry Andric 52368d75effSDimitry Andric void __sanitizer_set_report_path(const char *path) { 52468d75effSDimitry Andric // Handle the initialization code in each sanitizer, but no other calls. 52568d75effSDimitry Andric // This setting is never consulted on Fuchsia. 52668d75effSDimitry Andric DCHECK_EQ(path, common_flags()->log_path); 52768d75effSDimitry Andric } 52868d75effSDimitry Andric 52968d75effSDimitry Andric void __sanitizer_set_report_fd(void *fd) { 53068d75effSDimitry Andric UNREACHABLE("not available on Fuchsia"); 53168d75effSDimitry Andric } 532*e8d8bef9SDimitry Andric 533*e8d8bef9SDimitry Andric const char *__sanitizer_get_report_path() { 534*e8d8bef9SDimitry Andric UNREACHABLE("not available on Fuchsia"); 535*e8d8bef9SDimitry Andric } 53668d75effSDimitry Andric } // extern "C" 53768d75effSDimitry Andric 53868d75effSDimitry Andric #endif // SANITIZER_FUCHSIA 539