Ejemplo n.º 1
0
  bool GetRealTime(struct timespec &now)
  {
    if (0 == clock_gettime(CLOCK_REALTIME, &now))
      return true;

    LogAssertFalse("clock_gettime failed");
    gLog.Optional(Log::Critical, "clock_gettime failed.%s", ErrnoToString());
    now.tv_sec = 0;
    now.tv_nsec = 0;
    return false;
  }
Ejemplo n.º 2
0
TimeSpec TimeSpec::RealNow()
{
  struct TimeSpec now;

  if (0 == clock_gettime(CLOCK_REALTIME, &now))
    return now;

  gLog.Optional(Log::Critical, "clock_gettime(CLOCK_REALTIME) failed.%s", ErrnoToString());
  LogAssertFalse("clock_gettime(CLOCK_REALTIME) failed");
  return TimeSpec();
}
Ejemplo n.º 3
0
TimeSpec TimeSpec::MonoNow()
{
  struct TimeSpec now;

  if (0 == clock_gettime(CLOCK_MONOTONIC, &now))
    return now;

  gLog.Optional(Log::Critical, "clock_gettime(CLOCK_MONOTONIC) failed.%s", ErrnoToString());
  LogAssertFalse("clock_gettime(CLOCK_MONOTONIC) failed");
  return TimeSpec();
}
Ejemplo n.º 4
0
int MessageHandler::recvMessage(msg_t* i_msg)
{
    // Verify userspace didn't give a non-kernel message type.
    if (i_msg->type < MSG_FIRST_SYS_TYPE)
    {
        printkd("MessageHandler::recvMessage> type=%d\n", i_msg->type);
        return -EINVAL;
    }

    // Lock subsystem spinlock.
    if (iv_lock) iv_lock->lock();

    // List of tasks to end due to errors.
    //     Ending the task must happen outside of the spinlock due to
    //     requirements of TaskManager::endTask.
    Util::Locked::Queue<task_t> endTaskList;

    // Get <key, rc> from response.
    MessageHandler_Pending::key_type key =
        reinterpret_cast<MessageHandler_Pending::key_type>(i_msg->data[0]);
    int msg_rc = static_cast<int>(i_msg->data[1]);

    // Handle all pending responses.
    bool restored_task = false;
    MessageHandler_Pending* mhp = NULL;
    while (NULL != (mhp = iv_pending.find(key)))
    {
        task_t* deferred_task = mhp->task;

        // Call 'handle response'.
        HandleResult rc = this->handleResponse(
                static_cast<msg_sys_types_t>(i_msg->type),
                key, mhp->task, msg_rc);

        // Remove pending information from outstanding queue.
        iv_pending.erase(mhp);
        delete mhp;

        // If there is no associated task then there is nothing to do, find
        // next pending response.
        if (!deferred_task) continue;

        // Handle action requested from 'handle response'.
        if ((SUCCESS == rc) || (!msg_rc && UNHANDLED_RC == rc))
        {
            // Successful response, resume task.

            // Immediately execute first deferred task unless it is pinned,
            // in which case it must go back onto the queue of the CPU it's
            // pinned to (and may take slightly longer to dispatch)
            if (!restored_task && !deferred_task->affinity_pinned)
            {
                restored_task = true;
                TaskManager::setCurrentTask(deferred_task);
            }
            else // Add other deferred tasks to scheduler ready queue.
            {
                deferred_task->cpu->scheduler->addTask(deferred_task);
                doorbell_broadcast();
            }
        }
        else if (UNHANDLED_RC == rc)
        {
            // Unsuccessful, unhandled response.  Kill task.
            // Print the errorno string if we have mapped it in errno.h
            printk("Unhandled msg rc %d (%s) for key %p on task %d @ %p\n",
                    msg_rc, ErrnoToString(msg_rc), key, deferred_task->tid,
                    deferred_task->context.nip);
            // Kernel will deadlock if the message handler has the VMM spinlock
            // locked and then attempts to print the backtrace
            if(VmmManager::getLock() != iv_lock)
            {
                KernelMisc::printkBacktrace(deferred_task);
            }
            MAGIC_INSTRUCTION(MAGIC_BREAK_ON_ERROR);
            endTaskList.insert(deferred_task);
        }
        else if (CONTINUE_DEFER == rc)
        {
            // Requested to continue deferring task.  Do nothing.
        }
        else
        {
            // Logic bug (new HandleResult?).  Shouldn't be here.
            kassert(false);
        }
    }

    // Finished handling the response, unlock subsystem.
    if (iv_lock) iv_lock->unlock();

    while(task_t* end_task = endTaskList.remove())
    {
        TaskManager::endTask(end_task, i_msg->extra_data, TASK_STATUS_CRASHED);
    }

    // Release memory for message (created from sendMsg).
    delete(i_msg);

    return 0;
}
Ejemplo n.º 5
0
  static bool doLoadScript(const char *path, const SockAddr &connectAddr)
  {
    ifstream file;
    string line;
    int lines = 0;
    vector<char> buffer;
    const char *seps = " \t";

    file.open(path);
    if (!file.is_open())
    {
      fprintf(stderr, "Failed to open file <%s> : %s\n", path, ErrnoToString());
      return false;
    }

    buffer.reserve(MaxCommandSize);
    while (getline(file, line), file.good())
    {
      size_t pos = 0;
      lines++;
      if (line.empty())
        continue;
      if (line[0] == '#')
        continue;

      // Parse the command line. This doe not currently handle quoted parameters. If
      // we ever have a command that takes, for example, a file name, then this will
      // need to be fixed.
      buffer.resize(0);
      pos = line.find_first_not_of(seps, 0);
      while (pos != string::npos)
      {
        size_t sepPos = line.find_first_of(seps, pos);
        LogVerify(sepPos != pos);
        size_t end = (sepPos == string::npos) ? line.length() : sepPos;
        size_t bufpos = buffer.size();
        buffer.resize(bufpos + end - pos);
        memcpy(&buffer[bufpos], &line[pos], end - pos);
        buffer.push_back('\0');
        if (sepPos == string::npos)
          break;
        pos = line.find_first_not_of(seps, end);
      }

      if (buffer.size() != 0)
      {
        fprintf(stdout, " Command <%s>\n", line.c_str());

        // buffer is double null terminated.
        buffer.push_back('\0');
        if (!SendData(&buffer.front(), buffer.size(), connectAddr, "   "))
          return false;
      }
    }

    if (!file.eof())
    {
      fprintf(stderr, "Failed to read from file <%s>. %d lines processed: %s\n", path, lines, ErrnoToString());
      return false;
    }

    file.close();
    return true;
  }