[sanitizer][fuzzer] Transition back to ZX_TIME_INFINITE

[phosek]

Summary

Now that all Zircon calls have been transitioned to take time as signed
value, we can transition back to ZX_TIME_INFINITE, undoing the change
made in r337802.

[mcgrathr]

lgtm

lib/fuzzer/FuzzerUtilFuchsia.cpp

 // Forward declaration of assembly trampoline needed to resume crashed threads.
 // This appears to have external linkage to  C++, which is why it's not in the
 // anonymous namespace.  The assembly definition inside MakeTrampoline()
 // actually defines the symbol with internal linkage only.
 void CrashTrampolineAsm() __asm__("CrashTrampolineAsm");
 
 namespace {
 
-// TODO(phosek): remove this and replace it with ZX_TIME_INFINITE
-#define ZX_TIME_INFINITE_OLD INT64_MAX
-
 // A magic value for the Zircon exception port, chosen to spell 'FUZZING'
 // when interpreted as a byte sequence on little-endian platforms.
 const uint64_t kFuzzingCrash = 0x474e495a5a5546;
 
 // Helper function to handle Zircon syscall failures.
 void ExitOnErr(zx_status_t Status, const char *Syscall) {
   if (Status != ZX_OK) {
     Printf("libFuzzer: %s failed: %s\n", Syscall,
void CrashHandler(zx_handle_t *Event) {
   ExitOnErr(_zx_task_bind_exception_port(Self, Port.Handle, kFuzzingCrash,
                                          ZX_EXCEPTION_PORT_DEBUGGER),
             "_zx_task_bind_exception_port");
 
   ExitOnErr(_zx_object_signal(*Event, 0, ZX_USER_SIGNAL_0),
             "_zx_object_signal");
 
   zx_port_packet_t Packet;
-  ExitOnErr(_zx_port_wait(Port.Handle, ZX_TIME_INFINITE_OLD, &Packet),
+  ExitOnErr(_zx_port_wait(Port.Handle, ZX_TIME_INFINITE, &Packet),
             "_zx_port_wait");
 
   // At this point, we want to get the state of the crashing thread, but
   // libFuzzer and the sanitizers assume this will happen from that same thread
   // via a POSIX signal handler. "Resurrecting" the thread in the middle of the
   // appropriate callback is as simple as forcibly setting the instruction
   // pointer/program counter, provided we NEVER EVER return from that function
   // (since otherwise our stack will not be valid).
if (!Options.HandleSegv && !Options.HandleBus && !Options.HandleIll &&
       !Options.HandleFpe && !Options.HandleAbrt)
     return;
 
   // Set up the crash handler and wait until it is ready before proceeding.
   zx_handle_t Event;
   ExitOnErr(_zx_event_create(0, &Event), "_zx_event_create");
 
   std::thread T(CrashHandler, &Event);
-  zx_status_t Status = _zx_object_wait_one(Event, ZX_USER_SIGNAL_0,
-                                           ZX_TIME_INFINITE_OLD, nullptr);
+  zx_status_t Status =
+      _zx_object_wait_one(Event, ZX_USER_SIGNAL_0, ZX_TIME_INFINITE, nullptr);
   _zx_handle_close(Event);
   ExitOnErr(Status, "_zx_object_wait_one");
 
   T.detach();
 }
 
 void SleepSeconds(int Seconds) {
   _zx_nanosleep(_zx_deadline_after(ZX_SEC(Seconds)));
if (rc != ZX_OK) {
     Printf("libFuzzer: failed to launch '%s': %s, %s\n", Argv[0], ErrorMsg,
            _zx_status_get_string(rc));
     return rc;
   }
   auto CloseHandle = at_scope_exit([&]() { _zx_handle_close(ProcessHandle); });
 
   // Now join the process and return the exit status.
   if ((rc = _zx_object_wait_one(ProcessHandle, ZX_PROCESS_TERMINATED,
-                                ZX_TIME_INFINITE_OLD, nullptr)) != ZX_OK) {
+                                ZX_TIME_INFINITE, nullptr)) != ZX_OK) {
     Printf("libFuzzer: failed to join '%s': %s\n", Argv[0],
            _zx_status_get_string(rc));
     return rc;
   }
 
   zx_info_process_t Info;
   if ((rc = _zx_object_get_info(ProcessHandle, ZX_INFO_PROCESS, &Info,
                                 sizeof(Info), nullptr, nullptr)) != ZX_OK) {

lib/sanitizer_common/sanitizer_fuchsia.cc

 #include <stdlib.h>
 #include <unistd.h>
 #include <zircon/errors.h>
 #include <zircon/process.h>
 #include <zircon/syscalls.h>
 
 namespace __sanitizer {
 
-// TODO(phosek): remove this and replace it with ZX_TIME_INFINITE
-#define ZX_TIME_INFINITE_OLD INT64_MAX
-
 void NORETURN internal__exit(int exitcode) { _zx_process_exit(exitcode); }
 
 uptr internal_sched_yield() {
   zx_status_t status = _zx_nanosleep(0);
   CHECK_EQ(status, ZX_OK);
   return 0;  // Why doesn't this return void?
 }
 

 
 void BlockingMutex::Lock() {
   CHECK_EQ(owner_, 0);
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
   if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked)
     return;
   while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) {
     zx_status_t status = _zx_futex_wait(reinterpret_cast<zx_futex_t *>(m),
-                                        MtxSleeping, ZX_TIME_INFINITE_OLD);
+                                        MtxSleeping, ZX_TIME_INFINITE);
     if (status != ZX_ERR_BAD_STATE)  // Normal race.
       CHECK_EQ(status, ZX_OK);
   }
 }
 
 void BlockingMutex::Unlock() {
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
   u32 v = atomic_exchange(m, MtxUnlocked, memory_order_release);