[sanitizer_coverage][Fuchsia] Set ZX_PROP_VMO_CONTENT_SIZE

[mcgrathr]

Summary

The VMO size is always page-rounded, but Zircon now provides
a way to publish the precise intended size.

[phosek]

LGTM

compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp

 // per se.  The 'coverage_dir' option is ignored.  Instead, they are stored
 // directly into a shared memory object (a Zircon VMO).  At exit, that VMO
 // is handed over to a system service that's responsible for getting the
 // data out to somewhere that it can be fed into the sancov tool (where and
 // how is not our problem).
 
 #include "sanitizer_platform.h"
 #if SANITIZER_FUCHSIA
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/syscalls.h>
+
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_symbolizer_fuchsia.h"
 
-#include <zircon/process.h>
-#include <zircon/sanitizer.h>
-#include <zircon/syscalls.h>
-
 using namespace __sanitizer;
 
 namespace __sancov {
 namespace {
 
 // TODO(mcgrathr): Move the constant into a header shared with other impls.
 constexpr u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
 static_assert(SANITIZER_WORDSIZE == 64, "Fuchsia is always LP64");
if (end > start && *start == 0 && common_flags()->coverage) {
         *p = idx++;
       }
     }
   }
 
   void TracePcGuard(u32 *guard, uptr pc) {
     atomic_uint32_t *guard_ptr = reinterpret_cast<atomic_uint32_t *>(guard);
     u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
-    if (idx > 0) array_[idx] = pc;
+    if (idx > 0)
+      array_[idx] = pc;
   }
 
   void Dump() {
     BlockingMutexLock locked(&setup_lock_);
     if (array_) {
       CHECK_NE(vmo_, ZX_HANDLE_INVALID);
 
       // Publish the VMO to the system, where it can be collected and
if (next_index_ == 0) {
       zx_status_t status = _zx_vmo_create(DataSize(), ZX_VMO_RESIZABLE, &vmo_);
       CHECK_EQ(status, ZX_OK);
 
       // Give the VMO a name including our process KOID so it's easy to spot.
       internal_snprintf(vmo_name_, sizeof(vmo_name_), "%s.%zu", kSancovSinkName,
                         internal_getpid());
       _zx_object_set_property(vmo_, ZX_PROP_NAME, vmo_name_,
                               internal_strlen(vmo_name_));
+      uint64_t size = DataSize();
+      status = _zx_object_set_property(vmo_, ZX_PROP_VMO_CONTENT_SIZE, &size,
+                                       sizeof(size));
+      CHECK_EQ(status, ZX_OK);
 
       // Map the largest possible view we might need into the VMO.  Later
       // we might need to increase the VMO's size before we can use larger
       // indices, but we'll never move the mapping address so we don't have
       // any multi-thread synchronization issues with that.
       uintptr_t mapping;
       status =
           _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
if (next_index_ == 0) {
       CHECK_NE(vmo_, ZX_HANDLE_INVALID);
       CHECK_NE(array_, nullptr);
 
       uint32_t first_index = next_index_;
       next_index_ += num_guards;
 
       zx_status_t status = _zx_vmo_set_size(vmo_, DataSize());
       CHECK_EQ(status, ZX_OK);
+      uint64_t size = DataSize();
+      status = _zx_object_set_property(vmo_, ZX_PROP_VMO_CONTENT_SIZE, &size,
+                                       sizeof(size));
+      CHECK_EQ(status, ZX_OK);
 
       return first_index;
     }
   }
 };
 
 static TracePcGuardController pc_guard_controller;
 

 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(const uptr *pcs,
                                                              uptr len) {
   UNIMPLEMENTED();
 }
 
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32 *guard) {
-  if (!*guard) return;
+  if (!*guard)
+    return;
   __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
 }
 
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init,
                              u32 *start, u32 *end) {
-  if (start == end || *start) return;
+  if (start == end || *start)
+    return;
   __sancov::pc_guard_controller.InitTracePcGuard(start, end);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
   __sancov::pc_guard_controller.Dump();
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
   __sanitizer_dump_trace_pc_guard_coverage();