[sanitizer][fuzzer] Temporarily transition to ZX_TIME_INFINITE_OLD

[phosek]

Summary

This is a preparation for breaking change when all Zircon calls that
take time as an argument will start using signed valued. We will
transition back to ZX_TIME_INFITINE after all the changes to these
symbols are done and become part of the Fuchsia SDK.

[mcgrathr]

lgtm

lib/sanitizer_common/sanitizer_coverage_fuchsia.cc

if (next_index_ == 0) {
       _zx_object_set_property(vmo_, ZX_PROP_NAME, vmo_name_,
                               internal_strlen(vmo_name_));
 
       // 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(), 0, vmo_, 0, MappingSize,
-                       ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE, &mapping);
+      status = _zx_vmar_map_old(_zx_vmar_root_self(), 0, vmo_, 0, MappingSize,
+                                ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE,
+                                &mapping);
       CHECK_EQ(status, ZX_OK);
 
       // Hereafter other threads are free to start storing into
       // elements [1, next_index_) of the big array.
       array_ = reinterpret_cast<uptr *>(mapping);
 
       // Store the magic number.
       // Hereafter, the VMO serves as the contents of the '.sancov' file.

lib/sanitizer_common/sanitizer_fuchsia.cc

if (status != ZX_ERR_NO_MEMORY || die_for_nomem)
                               raw_report);
     return nullptr;
   }
   _zx_object_set_property(vmo, ZX_PROP_NAME, mem_type,
                           internal_strlen(mem_type));
 
   // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that?
   uintptr_t addr;
-  status = _zx_vmar_map(_zx_vmar_root_self(), 0, vmo, 0, size,
-                        ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE, &addr);
+  status =
+      _zx_vmar_map_old(_zx_vmar_root_self(), 0, vmo, 0, size,
   _zx_handle_close(vmo);
 
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY || die_for_nomem)
       ReportMmapFailureAndDie(size, mem_type, "zx_vmar_map", status,
                               raw_report);
     return nullptr;
   }

 
 uptr ReservedAddressRange::Init(uptr init_size, const char *name,
                                 uptr fixed_addr) {
   init_size = RoundUpTo(init_size, PAGE_SIZE);
   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(), 0, init_size,
+      _zx_vmar_allocate_old(_zx_vmar_root_self(), 0, init_size,
                             ZX_VM_FLAG_CAN_MAP_READ | ZX_VM_FLAG_CAN_MAP_WRITE |
                                 ZX_VM_FLAG_CAN_MAP_SPECIFIC,
                             &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_);
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));
   DCHECK_GE(base + size_, map_size + offset);
   uintptr_t addr;
 
-  status = _zx_vmar_map(
+  status = _zx_vmar_map_old(
       vmar, offset, vmo, 0, map_size,
       ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE | ZX_VM_FLAG_SPECIFIC,
       &addr);
   _zx_handle_close(vmo);
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY || die_for_nomem) {
       ReportMmapFailureAndDie(map_size, name, "zx_vmar_map", status);
     }
void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
   // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that?
 
   // Map a larger size to get a chunk of address space big enough that
   // it surely contains an aligned region of the requested size.  Then
   // overwrite the aligned middle portion with a mapping from the
   // beginning of the VMO, and unmap the excess before and after.
   size_t map_size = size + alignment;
   uintptr_t addr;
-  status = _zx_vmar_map(_zx_vmar_root_self(), 0, vmo, 0, map_size,
-                        ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE, &addr);
+  status =
+      _zx_vmar_map_old(_zx_vmar_root_self(), 0, vmo, 0, map_size,
   if (status == ZX_OK) {
     uintptr_t map_addr = addr;
     uintptr_t map_end = map_addr + map_size;
     addr = RoundUpTo(map_addr, alignment);
     uintptr_t end = addr + size;
     if (addr != map_addr) {
       zx_info_vmar_t info;
       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(), addr - info.base, vmo, 0, size,
+        status = _zx_vmar_map_old(_zx_vmar_root_self(), addr - info.base, vmo,
+                                  0, size,
                                   ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE |
                                       ZX_VM_FLAG_SPECIFIC_OVERWRITE,
                                   &new_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);
   }
bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
   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);
       uintptr_t addr;
-      status = _zx_vmar_map(_zx_vmar_root_self(), 0, vmo, 0, map_size,
+      status = _zx_vmar_map_old(_zx_vmar_root_self(), 0, vmo, 0, map_size,
                                 ZX_VM_FLAG_PERM_READ, &addr);
       if (status == ZX_OK) {
         *buff = reinterpret_cast<char *>(addr);
         *buff_size = map_size;
         *read_len = max_len;
       }
     }
     _zx_handle_close(vmo);
   }