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;
}
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();
}
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();
}
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;
}
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;
}