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.
if (!restored_task) // Immediately execute first deferred task.
{
restored_task = true;
TaskManager::setCurrentTask(deferred_task);
}
else // Add other deferred tasks to scheduler ready queue.
{
deferred_task->cpu->scheduler->addTask(deferred_task);
}
}
else if (UNHANDLED_RC == rc)
{
// Unsuccessful, unhandled response. Kill task.
printk("Unhandled msg rc %d for key %p on task %d @ %p\n",
msg_rc, key, deferred_task->tid, deferred_task->context.nip);
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;
}
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;
}