sdk/runtime/bin/eventhandler_fuchsia.cc

// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#if !defined(DART_IO_DISABLED)

#include "platform/globals.h"
#if defined(TARGET_OS_FUCHSIA)

#include "bin/eventhandler.h"
#include "bin/eventhandler_fuchsia.h"

#include <magenta/syscalls.h>
#include <runtime/status.h>

#include "bin/thread.h"
#include "bin/utils.h"

namespace dart {
namespace bin {

EventHandlerImplementation::EventHandlerImplementation() {
  mx_status_t status = mx_message_pipe_create(interrupt_handles_, 0);
  if (status != NO_ERROR) {
    FATAL1("mx_message_pipe_create failed: %s\n", mx_strstatus(status));
  }
}


EventHandlerImplementation::~EventHandlerImplementation() {
  mx_status_t status = mx_handle_close(interrupt_handles_[0]);
  if (status != NO_ERROR) {
    FATAL1("mx_handle_close failed: %s\n", mx_strstatus(status));
  }
  status = mx_handle_close(interrupt_handles_[1]);
  if (status != NO_ERROR) {
    FATAL1("mx_handle_close failed: %s\n", mx_strstatus(status));
  }
}


void EventHandlerImplementation::WakeupHandler(intptr_t id,
                                               Dart_Port dart_port,
                                               int64_t data) {
  InterruptMessage msg;
  msg.id = id;
  msg.dart_port = dart_port;
  msg.data = data;

  mx_status_t status =
    mx_message_write(interrupt_handles_[1], &msg, sizeof(msg), NULL, 0, 0);
  if (status != NO_ERROR) {
    FATAL1("mx_message_write failed: %s\n", mx_strstatus(status));
  }
}


void EventHandlerImplementation::HandleInterruptFd() {
  InterruptMessage msg;
  uint32_t bytes = kInterruptMessageSize;
  mx_status_t status;
  while (true) {
    status = mx_message_read(
        interrupt_handles_[0], &msg, &bytes, NULL, NULL, 0);
    if (status != NO_ERROR) {
      break;
    }
    ASSERT(bytes == kInterruptMessageSize);
    if (msg.id == kTimerId) {
      timeout_queue_.UpdateTimeout(msg.dart_port, msg.data);
    } else if (msg.id == kShutdownId) {
      shutdown_ = true;
    } else {
      UNIMPLEMENTED();
    }
  }
  // status == ERR_BAD_STATE when we try to read and there are no messages
  // available, so it is an error if we get here and status != ERR_BAD_STATE.
  if (status != ERR_BAD_STATE) {
    FATAL1("mx_message_read failed: %s\n", mx_strstatus(status));
  }
}


void EventHandlerImplementation::HandleEvents() {
  // TODO(zra): Handle events from other handles. At the moment we are only
  // interrupted when there is a message on interrupt_handles_[0].
  HandleInterruptFd();
}


int64_t EventHandlerImplementation::GetTimeout() const {
  if (!timeout_queue_.HasTimeout()) {
    return kInfinityTimeout;
  }
  int64_t millis = timeout_queue_.CurrentTimeout() -
      TimerUtils::GetCurrentMonotonicMillis();
  return (millis < 0) ? 0 : millis;
}


void EventHandlerImplementation::HandleTimeout() {
  if (timeout_queue_.HasTimeout()) {
    int64_t millis = timeout_queue_.CurrentTimeout() -
        TimerUtils::GetCurrentMonotonicMillis();
    if (millis <= 0) {
      DartUtils::PostNull(timeout_queue_.CurrentPort());
      timeout_queue_.RemoveCurrent();
    }
  }
}


void EventHandlerImplementation::Poll(uword args) {
  EventHandler* handler = reinterpret_cast<EventHandler*>(args);
  EventHandlerImplementation* handler_impl = &handler->delegate_;
  ASSERT(handler_impl != NULL);

  while (!handler_impl->shutdown_) {
    int64_t millis = handler_impl->GetTimeout();
    ASSERT((millis == kInfinityTimeout) || (millis >= 0));

    mx_time_t timeout =
        millis * kMicrosecondsPerMillisecond * kNanosecondsPerMicrosecond;
    mx_signals_state_t signals_state;
    mx_status_t status = mx_handle_wait_one(
        handler_impl->interrupt_handles_[0],
        MX_SIGNAL_READABLE | MX_SIGNAL_PEER_CLOSED,
        timeout,
        &signals_state);
    if ((status != NO_ERROR) && (status != ERR_TIMED_OUT)) {
      FATAL1("mx_handle_wait_one failed: %s\n", mx_strstatus(status));
    } else {
      handler_impl->HandleTimeout();
      if ((signals_state.satisfied & MX_SIGNAL_READABLE) != 0) {
        handler_impl->HandleEvents();
      }
      if ((signals_state.satisfied & MX_SIGNAL_PEER_CLOSED) != 0) {
        FATAL("EventHandlerImplementation::Poll: Unexpected peer closed\n");
      }
    }
  }
  handler->NotifyShutdownDone();
}


void EventHandlerImplementation::Start(EventHandler* handler) {
  int result = Thread::Start(&EventHandlerImplementation::Poll,
                             reinterpret_cast<uword>(handler));
  if (result != 0) {
    FATAL1("Failed to start event handler thread %d", result);
  }
}


void EventHandlerImplementation::Shutdown() {
  SendData(kShutdownId, 0, 0);
}


void EventHandlerImplementation::SendData(intptr_t id,
                                          Dart_Port dart_port,
                                          int64_t data) {
  WakeupHandler(id, dart_port, data);
}

}  // namespace bin
}  // namespace dart

#endif  // defined(TARGET_OS_FUCHSIA)

#endif  // !defined(DART_IO_DISABLED)