255 lines · cpp
1//===-- sanitizer_coverage_fuchsia.cpp ------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// Sanitizer Coverage Controller for Trace PC Guard, Fuchsia-specific version.10//11// This Fuchsia-specific implementation uses the same basic scheme and the12// same simple '.sancov' file format as the generic implementation. The13// difference is that we just produce a single blob of output for the whole14// program, not a separate one per DSO. We do not sort the PC table and do15// not prune the zeros, so the resulting file is always as large as it16// would be to report 100% coverage. Implicit tracing information about17// the address ranges of DSOs allows offline tools to split the one big18// blob into separate files that the 'sancov' tool can understand.19//20// Unlike the traditional implementation that uses an atexit hook to write21// out data files at the end, the results on Fuchsia do not go into a file22// per se. The 'coverage_dir' option is ignored. Instead, they are stored23// directly into a shared memory object (a Zircon VMO). At exit, that VMO24// is handed over to a system service that's responsible for getting the25// data out to somewhere that it can be fed into the sancov tool (where and26// how is not our problem).27 28#include "sanitizer_platform.h"29#if SANITIZER_FUCHSIA30#include <zircon/process.h>31#include <zircon/sanitizer.h>32#include <zircon/syscalls.h>33 34#include "sanitizer_atomic.h"35#include "sanitizer_common.h"36#include "sanitizer_interface_internal.h"37#include "sanitizer_internal_defs.h"38# include "sanitizer_symbolizer_markup_constants.h"39 40using namespace __sanitizer;41 42namespace __sancov {43namespace {44 45// TODO(mcgrathr): Move the constant into a header shared with other impls.46constexpr u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;47static_assert(SANITIZER_WORDSIZE == 64, "Fuchsia is always LP64");48 49constexpr const char kSancovSinkName[] = "sancov";50 51// Collects trace-pc guard coverage.52// This class relies on zero-initialization.53class TracePcGuardController final {54 public:55 constexpr TracePcGuardController() {}56 57 // For each PC location being tracked, there is a u32 reserved in global58 // data called the "guard". At startup, we assign each guard slot a59 // unique index into the big results array. Later during runtime, the60 // first call to TracePcGuard (below) will store the corresponding PC at61 // that index in the array. (Each later call with the same guard slot is62 // presumed to be from the same PC.) Then it clears the guard slot back63 // to zero, which tells the compiler not to bother calling in again. At64 // the end of the run, we have a big array where each element is either65 // zero or is a tracked PC location that was hit in the trace.66 67 // This is called from global constructors. Each translation unit has a68 // contiguous array of guard slots, and a constructor that calls here69 // with the bounds of its array. Those constructors are allowed to call70 // here more than once for the same array. Usually all of these71 // constructors run in the initial thread, but it's possible that a72 // dlopen call on a secondary thread will run constructors that get here.73 void InitTracePcGuard(u32 *start, u32 *end) {74 if (end > start && *start == 0 && common_flags()->coverage) {75 // Complete the setup before filling in any guards with indices.76 // This avoids the possibility of code called from Setup reentering77 // TracePcGuard.78 u32 idx = Setup(end - start);79 for (u32 *p = start; p < end; ++p) {80 *p = idx++;81 }82 }83 }84 85 void TracePcGuard(u32 *guard, uptr pc) {86 atomic_uint32_t *guard_ptr = reinterpret_cast<atomic_uint32_t *>(guard);87 u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);88 if (idx > 0)89 array_[idx] = pc;90 }91 92 void Dump() {93 Lock locked(&setup_lock_);94 if (array_) {95 CHECK_NE(vmo_, ZX_HANDLE_INVALID);96 97 // Publish the VMO to the system, where it can be collected and98 // analyzed after this process exits. This always consumes the VMO99 // handle. Any failure is just logged and not indicated to us.100 __sanitizer_publish_data(kSancovSinkName, vmo_);101 vmo_ = ZX_HANDLE_INVALID;102 103 // This will route to __sanitizer_log_write, which will ensure that104 // information about shared libraries is written out. This message105 // uses the `dumpfile` symbolizer markup element to highlight the106 // dump. See the explanation for this in:107 // https://fuchsia.googlesource.com/zircon/+/master/docs/symbolizer_markup.md108 Printf("SanitizerCoverage: " FORMAT_DUMPFILE " with up to %u PCs\n",109 kSancovSinkName, vmo_name_, next_index_ - 1);110 }111 }112 113 private:114 // We map in the largest possible view into the VMO: one word115 // for every possible 32-bit index value. This avoids the need116 // to change the mapping when increasing the size of the VMO.117 // We can always spare the 32G of address space.118 static constexpr size_t MappingSize = sizeof(uptr) << 32;119 120 Mutex setup_lock_;121 uptr *array_ = nullptr;122 u32 next_index_ = 0;123 zx_handle_t vmo_ = {};124 char vmo_name_[ZX_MAX_NAME_LEN] = {};125 126 size_t DataSize() const { return next_index_ * sizeof(uintptr_t); }127 128 u32 Setup(u32 num_guards) {129 Lock locked(&setup_lock_);130 DCHECK(common_flags()->coverage);131 132 if (next_index_ == 0) {133 CHECK_EQ(vmo_, ZX_HANDLE_INVALID);134 CHECK_EQ(array_, nullptr);135 136 // The first sample goes at [1] to reserve [0] for the magic number.137 next_index_ = 1 + num_guards;138 139 zx_status_t status = _zx_vmo_create(DataSize(), ZX_VMO_RESIZABLE, &vmo_);140 CHECK_EQ(status, ZX_OK);141 142 // Give the VMO a name including our process KOID so it's easy to spot.143 internal_snprintf(vmo_name_, sizeof(vmo_name_), "%s.%zu", kSancovSinkName,144 internal_getpid());145 _zx_object_set_property(vmo_, ZX_PROP_NAME, vmo_name_,146 internal_strlen(vmo_name_));147 uint64_t size = DataSize();148 status = _zx_object_set_property(vmo_, ZX_PROP_VMO_CONTENT_SIZE, &size,149 sizeof(size));150 CHECK_EQ(status, ZX_OK);151 152 // Map the largest possible view we might need into the VMO. Later153 // we might need to increase the VMO's size before we can use larger154 // indices, but we'll never move the mapping address so we don't have155 // any multi-thread synchronization issues with that.156 uintptr_t mapping;157 status =158 _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,159 0, vmo_, 0, MappingSize, &mapping);160 CHECK_EQ(status, ZX_OK);161 162 // Hereafter other threads are free to start storing into163 // elements [1, next_index_) of the big array.164 array_ = reinterpret_cast<uptr *>(mapping);165 166 // Store the magic number.167 // Hereafter, the VMO serves as the contents of the '.sancov' file.168 array_[0] = Magic64;169 170 return 1;171 } else {172 // The VMO is already mapped in, but it's not big enough to use the173 // new indices. So increase the size to cover the new maximum index.174 175 CHECK_NE(vmo_, ZX_HANDLE_INVALID);176 CHECK_NE(array_, nullptr);177 178 uint32_t first_index = next_index_;179 next_index_ += num_guards;180 181 zx_status_t status = _zx_vmo_set_size(vmo_, DataSize());182 CHECK_EQ(status, ZX_OK);183 uint64_t size = DataSize();184 status = _zx_object_set_property(vmo_, ZX_PROP_VMO_CONTENT_SIZE, &size,185 sizeof(size));186 CHECK_EQ(status, ZX_OK);187 188 return first_index;189 }190 }191};192 193static TracePcGuardController pc_guard_controller;194 195} // namespace196} // namespace __sancov197 198namespace __sanitizer {199void InitializeCoverage(bool enabled, const char *dir) {200 CHECK_EQ(enabled, common_flags()->coverage);201 CHECK_EQ(dir, common_flags()->coverage_dir);202 203 static bool coverage_enabled = false;204 if (!coverage_enabled) {205 coverage_enabled = enabled;206 Atexit(__sanitizer_cov_dump);207 AddDieCallback(__sanitizer_cov_dump);208 }209}210} // namespace __sanitizer211 212extern "C" {213SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(const uptr *pcs,214 uptr len) {215 UNIMPLEMENTED();216}217 218SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32 *guard) {219 if (!*guard)220 return;221 __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);222}223 224SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init,225 u32 *start, u32 *end) {226 if (start == end || *start)227 return;228 __sancov::pc_guard_controller.InitTracePcGuard(start, end);229}230 231SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {232 __sancov::pc_guard_controller.Dump();233}234SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {235 __sanitizer_dump_trace_pc_guard_coverage();236}237// Default empty implementations (weak). Users should redefine them.238SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {}239SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {}240SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) {}241SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) {}242SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) {}243SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp1, void) {}244SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp2, void) {}245SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp4, void) {}246SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp8, void) {}247SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) {}248SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) {}249SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) {}250SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) {}251SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {}252} // extern "C"253 254#endif // !SANITIZER_FUCHSIA255