exception_t
decodeSetTCB(cap_t cap, unsigned int length, word_t* buffer, extra_caps_t extraCaps)
{
cap_t tcbCap;
cte_t *tcbSlot;
deriveCap_ret_t dc_ret;
if ( extraCaps.excaprefs[0] == NULL) {
userError("VCPU SetTCB: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
tcbSlot = extraCaps.excaprefs[0];
tcbCap = extraCaps.excaprefs[0]->cap;
dc_ret = deriveCap(tcbSlot, tcbCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
tcbCap = dc_ret.cap;
if (cap_get_capType(tcbCap) != cap_thread_cap) {
userError("TCB cap is not a TCB cap.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeSetTCB(VCPU_PTR(cap_vcpu_cap_get_capVCPUPtr(cap)), TCB_PTR(cap_thread_cap_get_capTCBPtr(tcbCap)));
}
exception_t
decodeReadRegisters(cap_t cap, unsigned int length, bool_t call,
word_t *buffer)
{
word_t transferArch, flags, n;
if (length < 2) {
userError("TCB ReadRegisters: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
flags = getSyscallArg(0, buffer);
n = getSyscallArg(1, buffer);
if (n < 1 || n > n_frameRegisters + n_gpRegisters) {
userError("TCB ReadRegisters: Attempted to read an invalid number of registers (%d).",
(int)n);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = 1;
current_syscall_error.rangeErrorMax = n_frameRegisters +
n_gpRegisters;
return EXCEPTION_SYSCALL_ERROR;
}
transferArch = Arch_decodeTransfer(flags >> 8);
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_ReadRegisters(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)),
flags & BIT(ReadRegisters_suspend),
n, transferArch, call);
}
exception_t
decodeWriteRegisters(cap_t cap, unsigned int length, word_t *buffer)
{
word_t flags, w;
word_t transferArch;
tcb_t* thread;
if (length < 2) {
userError("TCB WriteRegisters: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
flags = getSyscallArg(0, buffer);
w = getSyscallArg(1, buffer);
if (length - 2 < w) {
userError("TCB WriteRegisters: Message too short for requested write size (%d/%d).",
(int)(length - 2), (int)w);
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
transferArch = Arch_decodeTransfer(flags >> 8);
thread = TCB_PTR(cap_thread_cap_get_capTCBPtr(cap));
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_WriteRegisters(thread,
flags & BIT(WriteRegisters_resume),
w, transferArch, buffer);
}
exception_t
decodeSetIOPortMask(cap_t cap, unsigned int length, word_t *buffer)
{
uint32_t low, high;
int mask;
vcpu_t *vcpu;
if (length < 3) {
userError("VCPU SetIOPortMask: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
low = getSyscallArg(0, buffer);
high = getSyscallArg(1, buffer);
mask = getSyscallArg(2, buffer) == 0 ? 0 : 1;
vcpu = VCPU_PTR(cap_vcpu_cap_get_capVCPUPtr(cap));
if (low < vcpu->io_min || high > vcpu->io_max) {
userError("VCPU SetIOPortMask: Invalid range.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (vcpu->io_min == -1 || vcpu->io_max == -1) {
userError("VCPU SetIOPortMask: No IO port set.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeSetIOPortMask(vcpu, low, high, mask);
}
exception_t decodeSetEPTRoot(cap_t cap, extra_caps_t extraCaps)
{
tcb_t *tcb;
cte_t *rootSlot;
exception_t e;
if (extraCaps.excaprefs[0] == NULL) {
userError("TCB SetEPTRoot: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_get_capType(extraCaps.excaprefs[0]->cap) != cap_ept_page_directory_pointer_table_cap) {
userError("TCB SetEPTRoot: EPT PDPT is invalid.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(cap));
rootSlot = TCB_PTR_CTE_PTR(tcb, tcbArchEPTRoot);
e = cteDelete(rootSlot, true);
if (e != EXCEPTION_NONE) {
return e;
}
cteInsert(extraCaps.excaprefs[0]->cap, extraCaps.excaprefs[0], rootSlot);
setThreadState(ksCurThread, ThreadState_Restart);
return EXCEPTION_NONE;
}
exception_t
decodeSetPriority(cap_t cap, unsigned int length, word_t *buffer)
{
prio_t newPrio;
if (length < 1) {
userError("TCB SetPriority: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
newPrio = getSyscallArg(0, buffer);
/* assuming here seL4_MaxPrio is of form 2^n - 1 */
newPrio = newPrio & MASK(8);
if (newPrio > ksCurThread->tcbPriority) {
userError("TCB SetPriority: Requested priority %d too high (max %d).",
(int)newPrio, (int)ksCurThread->tcbPriority);
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_ThreadControl(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)), NULL,
0, newPrio,
cap_null_cap_new(), NULL,
cap_null_cap_new(), NULL,
0, cap_null_cap_new(),
NULL, thread_control_update_priority);
}
exception_t decodeBindAEP(cap_t cap, extra_caps_t extraCaps)
{
async_endpoint_t *aepptr;
tcb_t *tcb;
if (extraCaps.excaprefs[0] == NULL) {
userError("TCB BindAEP: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_get_capType(extraCaps.excaprefs[0]->cap) != cap_async_endpoint_cap) {
userError("TCB BindAEP: Async endpoint is invalid.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(cap));
if (tcb->boundAsyncEndpoint) {
userError("TCB BindAEP: TCB already has AEP.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
aepptr = AEP_PTR(cap_async_endpoint_cap_get_capAEPPtr(extraCaps.excaprefs[0]->cap));
if ((tcb_t*)async_endpoint_ptr_get_aepQueue_head(aepptr)) {
userError("TCB BindAEP: AEP cannot be bound.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_AEPControl(tcb, aepptr);
}
exception_t
decodeIRQControlInvocation(word_t invLabel, word_t length,
cte_t *srcSlot, extra_caps_t excaps,
word_t *buffer)
{
if (invLabel == IRQIssueIRQHandler) {
word_t index, depth, irq_w;
irq_t irq;
cte_t *destSlot;
cap_t cnodeCap;
lookupSlot_ret_t lu_ret;
exception_t status;
if (length < 3 || excaps.excaprefs[0] == NULL) {
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
irq_w = getSyscallArg(0, buffer);
irq = (irq_t) irq_w;
index = getSyscallArg(1, buffer);
depth = getSyscallArg(2, buffer);
cnodeCap = excaps.excaprefs[0]->cap;
status = Arch_checkIRQ(irq);
if (status != EXCEPTION_NONE) {
return status;
}
if (isIRQActive(irq)) {
current_syscall_error.type = seL4_RevokeFirst;
userError("Rejecting request for IRQ %u. Already active.", (int)irq);
return EXCEPTION_SYSCALL_ERROR;
}
lu_ret = lookupTargetSlot(cnodeCap, index, depth);
if (lu_ret.status != EXCEPTION_NONE) {
userError("Target slot for new IRQ Handler cap invalid: cap %lu, IRQ %u.",
getExtraCPtr(buffer, 0), (int)irq);
return lu_ret.status;
}
destSlot = lu_ret.slot;
status = ensureEmptySlot(destSlot);
if (status != EXCEPTION_NONE) {
userError("Target slot for new IRQ Handler cap not empty: cap %lu, IRQ %u.",
getExtraCPtr(buffer, 0), (int)irq);
return status;
}
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return invokeIRQControl(irq, destSlot, srcSlot);
} else {
return Arch_decodeIRQControlInvocation(invLabel, length, srcSlot, excaps, buffer);
}
}
deriveCap_ret_t
Arch_deriveCap(cte_t *slot, cap_t cap)
{
deriveCap_ret_t ret;
switch (cap_get_capType(cap)) {
case cap_page_table_cap:
if (cap_page_table_cap_get_capPTIsMapped(cap)) {
ret.cap = cap;
ret.status = EXCEPTION_NONE;
} else {
userError("Deriving an unmapped PT cap");
current_syscall_error.type = seL4_IllegalOperation;
ret.cap = cap_null_cap_new();
ret.status = EXCEPTION_SYSCALL_ERROR;
}
return ret;
case cap_page_directory_cap:
if (cap_page_directory_cap_get_capPDIsMapped(cap)) {
ret.cap = cap;
ret.status = EXCEPTION_NONE;
} else {
userError("Deriving a PD cap without an assigned ASID");
current_syscall_error.type = seL4_IllegalOperation;
ret.cap = cap_null_cap_new();
ret.status = EXCEPTION_SYSCALL_ERROR;
}
return ret;
/* This is a deviation from haskell, which has only
* one frame cap type on ARM */
case cap_small_frame_cap:
ret.cap = cap_small_frame_cap_set_capFMappedASID(cap, asidInvalid);
ret.status = EXCEPTION_NONE;
return ret;
case cap_frame_cap:
ret.cap = cap_frame_cap_set_capFMappedASID(cap, asidInvalid);
ret.status = EXCEPTION_NONE;
return ret;
case cap_asid_control_cap:
case cap_asid_pool_cap:
ret.cap = cap;
ret.status = EXCEPTION_NONE;
return ret;
default:
/* This assert has no equivalent in haskell,
* as the options are restricted by type */
fail("Invalid arch cap");
}
}
exception_t
decodeIRQHandlerInvocation(word_t invLabel, irq_t irq,
extra_caps_t excaps)
{
switch (invLabel) {
case IRQAckIRQ:
setThreadState(ksCurThread, ThreadState_Restart);
invokeIRQHandler_AckIRQ(irq);
return EXCEPTION_NONE;
case IRQSetIRQHandler: {
cap_t ntfnCap;
cte_t *slot;
if (excaps.excaprefs[0] == NULL) {
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
ntfnCap = excaps.excaprefs[0]->cap;
slot = excaps.excaprefs[0];
if (cap_get_capType(ntfnCap) != cap_notification_cap ||
!cap_notification_cap_get_capNtfnCanSend(ntfnCap)) {
if (cap_get_capType(ntfnCap) != cap_notification_cap) {
userError("IRQSetHandler: provided cap is not an notification capability.");
} else {
userError("IRQSetHandler: caller does not have send rights on the endpoint.");
}
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
invokeIRQHandler_SetIRQHandler(irq, ntfnCap, slot);
return EXCEPTION_NONE;
}
case IRQClearIRQHandler:
setThreadState(ksCurThread, ThreadState_Restart);
invokeIRQHandler_ClearIRQHandler(irq);
return EXCEPTION_NONE;
default:
userError("IRQHandler: Illegal operation.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
}
exception_t decodeIA32VCPUInvocation(
word_t label,
unsigned int length,
cptr_t cptr,
cte_t* slot,
cap_t cap,
extra_caps_t extraCaps,
word_t* buffer
)
{
switch (label) {
case IA32VCPUSetTCB:
return decodeSetTCB(cap, length, buffer, extraCaps);
case IA32VCPUReadVMCS:
return decodeReadVMCS(cap, length, buffer);
case IA32VCPUWriteVMCS:
return decodeWriteVMCS(cap, length, buffer);
case IA32VCPUSetIOPort:
return decodeSetIOPort(cap, length, buffer, extraCaps);
case IA32VCPUSetIOPortMask:
return decodeSetIOPortMask(cap, length, buffer);
default:
userError("VCPU: Illegal operation.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
}
/**
* Update which icons should be shown.
* @param error An optional error string. If empty the property is revalidated
* by calling prop->setValue and
* the error is pulled from here
*/
void PropertyWidget::updateIconVisibility(const QString &error) {
QString userError(error);
if (userError.isEmpty()) {
// Show "*" icon if the value is invalid for this property.
QString value = this->getValue().trimmed();
// Use the default if empty
if (value.isEmpty())
value = QString::fromStdString(m_prop->getDefault());
try {
userError = QString::fromStdString(m_prop->setValue(value.toStdString()));
} catch (std::exception &err_details) {
userError = QString::fromLatin1(err_details.what());
}
}
this->setError(userError.trimmed());
m_icons[INVALID]->setVisible(!m_error.isEmpty());
m_icons[INVALID]->setToolTip(m_error);
// Show "!" icon if a workspace would be overwritten.
if (m_isOutputWsProp) {
const bool wsExists =
Mantid::API::AnalysisDataService::Instance().doesExist(
getValue().toStdString());
m_icons[REPLACE]->setVisible(wsExists);
}
}
static void
handleReply(void)
{
cte_t *callerSlot;
cap_t callerCap;
callerSlot = TCB_PTR_CTE_PTR(ksCurThread, tcbCaller);
callerCap = callerSlot->cap;
switch (cap_get_capType(callerCap)) {
case cap_reply_cap: {
tcb_t *caller;
if (cap_reply_cap_get_capReplyMaster(callerCap)) {
break;
}
caller = TCB_PTR(cap_reply_cap_get_capTCBPtr(callerCap));
/* Haskell error:
* "handleReply: caller must not be the current thread" */
assert(caller != ksCurThread);
doReplyTransfer(ksCurThread, caller, callerSlot);
return;
}
case cap_null_cap:
userError("Attempted reply operation when no reply cap present.");
return;
default:
break;
}
fail("handleReply: invalid caller cap");
}
void benchmark_track_utilisation_dump(void)
{
uint64_t *buffer = ((uint64_t *) & (((seL4_IPCBuffer *)lookupIPCBuffer(true, NODE_STATE(ksCurThread)))->msg[0]));
tcb_t *tcb = NULL;
word_t tcb_cptr = getRegister(NODE_STATE(ksCurThread), capRegister);
lookupCap_ret_t lu_ret;
word_t cap_type;
lu_ret = lookupCap(NODE_STATE(ksCurThread), tcb_cptr);
/* ensure we got a TCB cap */
cap_type = cap_get_capType(lu_ret.cap);
if (cap_type != cap_thread_cap) {
userError("SysBenchmarkFinalizeLog: cap is not a TCB, halting");
return;
}
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(lu_ret.cap));
buffer[BENCHMARK_TCB_UTILISATION] = tcb->benchmark.utilisation; /* Requested thread utilisation */
buffer[BENCHMARK_IDLE_LOCALCPU_UTILISATION] = NODE_STATE(
ksIdleThread)->benchmark.utilisation; /* Idle thread utilisation of current CPU */
#ifdef ENABLE_SMP_SUPPORT
buffer[BENCHMARK_IDLE_TCBCPU_UTILISATION] = NODE_STATE_ON_CORE(ksIdleThread,
tcb->tcbAffinity)->benchmark.utilisation; /* Idle thread utilisation of CPU the TCB is running on */
#else
buffer[BENCHMARK_IDLE_TCBCPU_UTILISATION] = buffer[BENCHMARK_IDLE_LOCALCPU_UTILISATION];
#endif
#ifdef CONFIG_ARM_ENABLE_PMU_OVERFLOW_INTERRUPT
buffer[BENCHMARK_TOTAL_UTILISATION] =
(ccnt_num_overflows * 0xFFFFFFFFU) + benchmark_end_time - benchmark_start_time;
#else
buffer[BENCHMARK_TOTAL_UTILISATION] = benchmark_end_time - benchmark_start_time; /* Overall time */
#endif /* CONFIG_ARM_ENABLE_PMU_OVERFLOW_INTERRUPT */
}
/*****************************************************************************
*
* Module: progSaveData()
*
* Description: Save data after S-Record parser into progData buffer, call
* progPlaceData()
*
* Returns: None
*
* Arguments: pData - pointer to data
* Length - data length
* Address - start address to put data
* MemoryType - memory space to put data
*
* Range Issues: None
*
* Special Issues: None
*
* Test Method: boottest.mcp
*
*****************************************************************************/
void progSaveData ( UWord16 * pData, UWord16 Length, UWord16 Address, mem_eMemoryType MemoryType)
{
if (progMoreData)
{
userError(INDICATE_ERROR_OVERRUN);
}
bootmemCopyXtoX(progData,pData,SPRS_BUFFER_LEN);
progDataPointer = progData;
progLength = Length;
progAddress = Address;
progMemoryType = MemoryType;
if (MemoryType == PData)
{
progProgCounter += Length; /* 0xffff overflow does not detected */
}
else
{
progDataCounter += Length;
}
progMoreData = TRUE;
progPlaceData(TRUE);
}
/* for x86, the IRQIssueIRQHandler is only allowed to
* issue a hander for IRQ 0-15, the isa IRQs.
* Use getIRQHandlerIOAPIC and getIRQHandlerMSI for
* the IRQs >= 16. Additionally these IRQs only exist
* if using the legacy PIC interrupt
*/
exception_t
Arch_checkIRQ(word_t irq_w)
{
if (config_set(CONFIG_IRQ_PIC) && irq_w >= irq_isa_min && irq_w <= irq_isa_max) {
return EXCEPTION_NONE;
}
if (config_set(CONFIG_IRQ_IOAPIC)) {
userError("IRQControl: Illegal operation");
current_syscall_error.type = seL4_IllegalOperation;
} else {
userError("IRQControl: IRQ %ld should be in range %ld - %ld", irq_w, (long)irq_isa_min, (long)irq_isa_max);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = irq_isa_min;
current_syscall_error.rangeErrorMax = irq_isa_max;
}
return EXCEPTION_SYSCALL_ERROR;
}
void EnggDiffMultiRunFittingQtWidget::reportPlotInvalidFocusedRun(
const RunLabel &runLabel) {
userError("Invalid focused run identifier",
"Tried to plot invalid focused run, run number " +
std::to_string(runLabel.runNumber) + " and bank ID " +
std::to_string(runLabel.bank) +
". Please contact the development team with this message");
}
/* The following functions sit in the syscall error monad, but include the
* exception cases for the preemptible bottom end, as they call the invoke
* functions directly. This is a significant deviation from the Haskell
* spec. */
exception_t
decodeTCBInvocation(word_t label, unsigned int length, cap_t cap,
cte_t* slot, extra_caps_t extraCaps, bool_t call,
word_t *buffer)
{
switch (label) {
case TCBReadRegisters:
/* Second level of decoding */
return decodeReadRegisters(cap, length, call, buffer);
case TCBWriteRegisters:
return decodeWriteRegisters(cap, length, buffer);
case TCBCopyRegisters:
return decodeCopyRegisters(cap, length, extraCaps, buffer);
case TCBSuspend:
/* Jump straight to the invoke */
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_Suspend(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)));
case TCBResume:
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_Resume(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)));
case TCBConfigure:
return decodeTCBConfigure(cap, length, slot, extraCaps, buffer);
case TCBSetPriority:
return decodeSetPriority(cap, length, buffer);
case TCBSetIPCBuffer:
return decodeSetIPCBuffer(cap, length, slot, extraCaps, buffer);
case TCBSetSpace:
return decodeSetSpace(cap, length, slot, extraCaps, buffer);
case TCBBindAEP:
return decodeBindAEP(cap, extraCaps);
case TCBUnbindAEP:
return decodeUnbindAEP(cap);
/* This is temporary until arch specific TCB operations are implemented */
#ifdef CONFIG_VTX
case TCBSetEPTRoot:
return decodeSetEPTRoot(cap, extraCaps);
#endif
default:
/* Haskell: "throw IllegalOperation" */
userError("TCB: Illegal operation.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
}
exception_t
decodeDomainInvocation(word_t label, unsigned int length, extra_caps_t extraCaps, word_t *buffer)
{
word_t domain;
cap_t tcap;
if (unlikely(label != DomainSetSet)) {
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (unlikely(length == 0)) {
userError("Domain Configure: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
} else {
domain = getSyscallArg(0, buffer);
if (domain >= CONFIG_NUM_DOMAINS) {
userError("Domain Configure: invalid domain (%u >= %u).",
domain, CONFIG_NUM_DOMAINS);
current_syscall_error.type = seL4_InvalidArgument;
current_syscall_error.invalidArgumentNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
}
if (unlikely(extraCaps.excaprefs[0] == NULL)) {
userError("Domain Configure: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
tcap = extraCaps.excaprefs[0]->cap;
if (unlikely(cap_get_capType(tcap) != cap_thread_cap)) {
userError("Domain Configure: thread cap required.");
current_syscall_error.type = seL4_InvalidArgument;
current_syscall_error.invalidArgumentNumber = 1;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
setDomain(TCB_PTR(cap_thread_cap_get_capTCBPtr(tcap)), domain);
return EXCEPTION_NONE;
}
void benchmark_track_dump(
benchmark_track_kernel_entry_t* buffer,
word_t start_index,
word_t num_entries
)
{
if (!buffer) {
userError("Invalid IPC buffer pointer = %p\n", buffer);
return;
}
if (start_index > ksLogIndex) {
userError("Invalid start index = %lu\n", start_index);
return;
}
if ((start_index + num_entries) > ksLogIndex) {
userError("Requested entries exceed the range of tracked syscall invocations [%lu:%lu] \
\n", start_index, num_entries);
return;
}
exception_t
decodeCopyRegisters(cap_t cap, unsigned int length,
extra_caps_t extraCaps, word_t *buffer)
{
word_t transferArch;
tcb_t *srcTCB;
cap_t source_cap;
word_t flags;
if (length < 1 || extraCaps.excaprefs[0] == NULL) {
userError("TCB CopyRegisters: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
flags = getSyscallArg(0, buffer);
transferArch = Arch_decodeTransfer(flags >> 8);
source_cap = extraCaps.excaprefs[0]->cap;
if (cap_get_capType(source_cap) == cap_thread_cap) {
srcTCB = TCB_PTR(cap_thread_cap_get_capTCBPtr(source_cap));
} else {
userError("TCB CopyRegisters: Invalid source TCB.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 1;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_CopyRegisters(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)), srcTCB,
flags & BIT(CopyRegisters_suspendSource),
flags & BIT(CopyRegisters_resumeTarget),
flags & BIT(CopyRegisters_transferFrame),
flags & BIT(CopyRegisters_transferInteger),
transferArch);
}
exception_t ioapic_decode_map_pin_to_vector(word_t ioapic, word_t pin, word_t level,
word_t polarity, word_t vector)
{
if (num_ioapics == 0) {
userError("System has no IOAPICs");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (ioapic >= num_ioapics) {
userError("Invalid IOAPIC %ld, only have %ld", (long)ioapic, (long)num_ioapics);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = 0;
current_syscall_error.rangeErrorMax = num_ioapics - 1;
return EXCEPTION_SYSCALL_ERROR;
}
if (pin >= IOAPIC_IRQ_LINES) {
userError("Invalid IOAPIC pin %ld, there are %d pins", (long)pin, IOAPIC_IRQ_LINES);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = 0;
current_syscall_error.rangeErrorMax = IOAPIC_IRQ_LINES - 1;
return EXCEPTION_SYSCALL_ERROR;
}
if (level != 0 && level != 1) {
userError("Level should be 0 or 1, not %d", (int)level);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = 0;
current_syscall_error.rangeErrorMax = 1;
return EXCEPTION_SYSCALL_ERROR;
}
if (polarity != 0 && polarity != 1) {
userError("Polarity should be 0 or 1, not %d", (int)polarity);
current_syscall_error.type = seL4_RangeError;
current_syscall_error.rangeErrorMin = 0;
current_syscall_error.rangeErrorMax = 1;
return EXCEPTION_SYSCALL_ERROR;
}
return EXCEPTION_NONE;
}
exception_t decodeUnbindAEP(cap_t cap)
{
tcb_t *tcb;
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(cap));
if (!tcb->boundAsyncEndpoint) {
userError("TCB UnbindAEP: TCB already has no bound AEP.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_AEPControl(tcb, NULL);
}
exception_t
decodeSetIPCBuffer(cap_t cap, unsigned int length, cte_t* slot,
extra_caps_t extraCaps, word_t *buffer)
{
cptr_t cptr_bufferPtr;
cap_t bufferCap;
cte_t *bufferSlot;
if (length < 1 || extraCaps.excaprefs[0] == NULL) {
userError("TCB SetIPCBuffer: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
cptr_bufferPtr = getSyscallArg(0, buffer);
bufferSlot = extraCaps.excaprefs[0];
bufferCap = extraCaps.excaprefs[0]->cap;
if (cptr_bufferPtr == 0) {
bufferSlot = NULL;
} else {
exception_t e;
deriveCap_ret_t dc_ret;
dc_ret = deriveCap(bufferSlot, bufferCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
bufferCap = dc_ret.cap;
e = checkValidIPCBuffer(cptr_bufferPtr, bufferCap);
if (e != EXCEPTION_NONE) {
return e;
}
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_ThreadControl(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)), slot,
0,
0, /* used to be prioInvalid, but it doesn't matter */
cap_null_cap_new(), NULL,
cap_null_cap_new(), NULL,
cptr_bufferPtr, bufferCap,
bufferSlot, thread_control_update_ipc_buffer);
}
void handleTCPClient( int clientSocket ) {
char buffer[_TCPDEV_BUFFERSIZE];
ssize_t numBytesReceived = recv(clientSocket, buffer, _TCPDEV_BUFFERSIZE, 0);
if (numBytesReceived < 0) sysError("recv()");
while (numBytesReceived > 0) {
ssize_t numBytesSent = send(clientSocket, buffer, numBytesReceived, 0);
if (numBytesSent < 0) {
sysError("send()");
} else if (numBytesSent != numBytesReceived) {
userError("send()", "unexpected number of bytes");
}
numBytesReceived = recv(clientSocket, buffer, _TCPDEV_BUFFERSIZE, 0);
if (numBytesReceived < 0) sysError("recv()");
}
close(clientSocket);
}
void benchmark_track_reset_utilisation(void)
{
tcb_t *tcb = NULL;
word_t tcb_cptr = getRegister(NODE_STATE(ksCurThread), capRegister);
lookupCap_ret_t lu_ret;
word_t cap_type;
lu_ret = lookupCap(NODE_STATE(ksCurThread), tcb_cptr);
/* ensure we got a TCB cap */
cap_type = cap_get_capType(lu_ret.cap);
if (cap_type != cap_thread_cap) {
userError("SysBenchmarkResetThreadUtilisation: cap is not a TCB, halting");
return;
}
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(lu_ret.cap));
tcb->benchmark.utilisation = 0;
tcb->benchmark.schedule_start_time = 0;
}
////////////////////////////////////////////////////////////////////////
//
// comMainLoop()
//
// Communication loop. Wait for CAN frames and parses the messagge.
// The loop ends when comContinue is false.
//
////////////////////////////////////////////////////////////////////////
void comMainLoop(void)
{
byte ReadCANState;
byte i;
comContinue = TRUE;
comTimerEn = TRUE;
while (comContinue)
{
/* wait CAN data or while timer expired, if set */
while (CAN1_getStateRX() == 0)
{
// Timer check
if (comTimerEn)
{
if (getRegBit(TMRC1_SCR,TCF)) /* Is the interrupt request flag set? */
{
clrRegBit(TMRC1_SCR,TCF); /* If yes then reset this flag */
if (--TmpXdataVar == 0)
{
setRegBitGroup(TMRC0_CTRL,CM,0); /* Stop counter */
return;
}
}
}
}
if (CAN1_getStateRX() != 0)
{
/* Received CAN frame */
ReadCANState=CAN1_readFrame (&comBuffer.CAN_messID,
&comBuffer.CAN_length,
comBuffer.CAN_data);
if ((ReadCANState != ERR_OK) && (ReadCANState != ERR_RXEMPTY))
{
userError(INDICATE_ERROR_RECEIVE);
}
sprsReady(&comBuffer); /* call CAN protocol parser */
}
} /* while */
}
static void
handleReply(void)
{
cte_t *callerSlot;
cap_t callerCap;
callerSlot = TCB_PTR_CTE_PTR(ksCurThread, tcbCaller);
callerCap = callerSlot->cap;
#if defined(DEBUG) || defined(CONFIG_BENCHMARK_TRACK_KERNEL_ENTRIES)
ksKernelEntry.cap_type = cap_get_capType(callerCap);
#endif
switch (cap_get_capType(callerCap)) {
case cap_reply_cap: {
tcb_t *caller;
if (cap_reply_cap_get_capReplyMaster(callerCap)) {
break;
}
caller = TCB_PTR(cap_reply_cap_get_capTCBPtr(callerCap));
/* Haskell error:
* "handleReply: caller must not be the current thread" */
assert(caller != ksCurThread);
doReplyTransfer(ksCurThread, caller, callerSlot);
return;
}
case cap_null_cap:
userError("Attempted reply operation when no reply cap present.");
return;
default:
break;
}
fail("handleReply: invalid caller cap");
}
exception_t
decodeSetSpace(cap_t cap, unsigned int length, cte_t* slot,
extra_caps_t extraCaps, word_t *buffer)
{
cptr_t faultEP;
word_t cRootData, vRootData;
cte_t *cRootSlot, *vRootSlot;
cap_t cRootCap, vRootCap;
deriveCap_ret_t dc_ret;
if (length < 3 || extraCaps.excaprefs[0] == NULL
|| extraCaps.excaprefs[1] == NULL) {
userError("TCB SetSpace: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
faultEP = getSyscallArg(0, buffer);
cRootData = getSyscallArg(1, buffer);
vRootData = getSyscallArg(2, buffer);
cRootSlot = extraCaps.excaprefs[0];
cRootCap = extraCaps.excaprefs[0]->cap;
vRootSlot = extraCaps.excaprefs[1];
vRootCap = extraCaps.excaprefs[1]->cap;
if (slotCapLongRunningDelete(
TCB_PTR_CTE_PTR(cap_thread_cap_get_capTCBPtr(cap), tcbCTable)) ||
slotCapLongRunningDelete(
TCB_PTR_CTE_PTR(cap_thread_cap_get_capTCBPtr(cap), tcbVTable))) {
userError("TCB SetSpace: CSpace or VSpace currently being deleted.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (cRootData != 0) {
cRootCap = updateCapData(false, cRootData, cRootCap);
}
dc_ret = deriveCap(cRootSlot, cRootCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
cRootCap = dc_ret.cap;
if (cap_get_capType(cRootCap) != cap_cnode_cap &&
(!config_set(CONFIG_ALLOW_NULL_CSPACE) ||
cap_get_capType(cRootCap) != cap_null_cap)) {
userError("TCB SetSpace: Invalid CNode cap.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (vRootData != 0) {
vRootCap = updateCapData(false, vRootData, vRootCap);
}
dc_ret = deriveCap(vRootSlot, vRootCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
vRootCap = dc_ret.cap;
if (!isValidVTableRoot(vRootCap)) {
userError("TCB SetSpace: Invalid VSpace cap.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_ThreadControl(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)), slot,
faultEP,
0, /* used to be prioInvalid, but it doesn't matter */
cRootCap, cRootSlot,
vRootCap, vRootSlot,
0, cap_null_cap_new(), NULL, thread_control_update_space);
}
exception_t
decodeTCBConfigure(cap_t cap, unsigned int length, cte_t* slot,
extra_caps_t rootCaps, word_t *buffer)
{
cte_t *bufferSlot, *cRootSlot, *vRootSlot;
cap_t bufferCap, cRootCap, vRootCap;
deriveCap_ret_t dc_ret;
cptr_t faultEP;
unsigned int prio;
word_t cRootData, vRootData, bufferAddr;
if (length < 5 || rootCaps.excaprefs[0] == NULL
|| rootCaps.excaprefs[1] == NULL
|| rootCaps.excaprefs[2] == NULL) {
userError("TCB Configure: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
faultEP = getSyscallArg(0, buffer);
prio = getSyscallArg(1, buffer);
cRootData = getSyscallArg(2, buffer);
vRootData = getSyscallArg(3, buffer);
bufferAddr = getSyscallArg(4, buffer);
cRootSlot = rootCaps.excaprefs[0];
cRootCap = rootCaps.excaprefs[0]->cap;
vRootSlot = rootCaps.excaprefs[1];
vRootCap = rootCaps.excaprefs[1]->cap;
bufferSlot = rootCaps.excaprefs[2];
bufferCap = rootCaps.excaprefs[2]->cap;
prio = prio & MASK(8);
if (prio > ksCurThread->tcbPriority) {
userError("TCB Configure: Requested priority %d too high (max %d).",
(int)prio, (int)(ksCurThread->tcbPriority));
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (bufferAddr == 0) {
bufferSlot = NULL;
} else {
exception_t e;
dc_ret = deriveCap(bufferSlot, bufferCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
bufferCap = dc_ret.cap;
e = checkValidIPCBuffer(bufferAddr, bufferCap);
if (e != EXCEPTION_NONE) {
return e;
}
}
if (slotCapLongRunningDelete(
TCB_PTR_CTE_PTR(cap_thread_cap_get_capTCBPtr(cap), tcbCTable)) ||
slotCapLongRunningDelete(
TCB_PTR_CTE_PTR(cap_thread_cap_get_capTCBPtr(cap), tcbVTable))) {
userError("TCB Configure: CSpace or VSpace currently being deleted.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (cRootData != 0) {
cRootCap = updateCapData(false, cRootData, cRootCap);
}
dc_ret = deriveCap(cRootSlot, cRootCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
cRootCap = dc_ret.cap;
if (cap_get_capType(cRootCap) != cap_cnode_cap &&
(!config_set(CONFIG_ALLOW_NULL_CSPACE) ||
cap_get_capType(cRootCap) != cap_null_cap)) {
userError("TCB Configure: CSpace cap is invalid.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (vRootData != 0) {
vRootCap = updateCapData(false, vRootData, vRootCap);
}
dc_ret = deriveCap(vRootSlot, vRootCap);
if (dc_ret.status != EXCEPTION_NONE) {
return dc_ret.status;
}
vRootCap = dc_ret.cap;
if (!isValidVTableRoot(vRootCap)) {
userError("TCB Configure: VSpace cap is invalid.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_ThreadControl(
TCB_PTR(cap_thread_cap_get_capTCBPtr(cap)), slot,
faultEP, prio,
cRootCap, cRootSlot,
vRootCap, vRootSlot,
bufferAddr, bufferCap,
bufferSlot, thread_control_update_all);
}
