DECLHIDDEN(int) rtThreadNativeSetPriority(PRTTHREADINT pThread, RTTHREADTYPE enmType)
{
int32 iPriority;
status_t status;
/*
* Convert the priority type to native priorities.
* (This is quite naive but should be ok.)
*/
switch (enmType)
{
case RTTHREADTYPE_INFREQUENT_POLLER: iPriority = B_LOWEST_ACTIVE_PRIORITY; break;
case RTTHREADTYPE_EMULATION: iPriority = B_LOW_PRIORITY; break;
case RTTHREADTYPE_DEFAULT: iPriority = B_NORMAL_PRIORITY; break;
case RTTHREADTYPE_MSG_PUMP: iPriority = B_DISPLAY_PRIORITY; break;
case RTTHREADTYPE_IO: iPriority = B_URGENT_DISPLAY_PRIORITY; break;
case RTTHREADTYPE_TIMER: iPriority = B_REAL_TIME_DISPLAY_PRIORITY; break;
default:
AssertMsgFailed(("enmType=%d\n", enmType));
return VERR_INVALID_PARAMETER;
}
status = set_thread_priority((thread_id)pThread->Core.Key, iPriority);
return RTErrConvertFromHaikuKernReturn(status);
}
/**
* Worker locking the memory in either kernel or user maps.
*
* @returns IPRT status code.
* @param ppMem Where to store the allocated memory object.
* @param pvStart The starting address.
* @param cb The size of the block.
* @param fAccess The mapping protection to apply.
* @param R0Process The process to map the memory to (use NIL_RTR0PROCESS
* for the kernel)
* @param fFlags Memory flags (B_READ_DEVICE indicates the memory is
* intended to be written from a "device").
*/
static int rtR0MemObjNativeLockInMap(PPRTR0MEMOBJINTERNAL ppMem, void *pvStart, size_t cb, uint32_t fAccess,
RTR0PROCESS R0Process, int fFlags)
{
NOREF(fAccess);
int rc;
team_id TeamId = B_SYSTEM_TEAM;
LogFlowFunc(("ppMem=%p pvStart=%p cb=%u fAccess=%x R0Process=%d fFlags=%x\n", ppMem, pvStart, cb, fAccess, R0Process,
fFlags));
/* Create the object. */
PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(*pMemHaiku), RTR0MEMOBJTYPE_LOCK, pvStart, cb);
if (RT_UNLIKELY(!pMemHaiku))
return VERR_NO_MEMORY;
if (R0Process != NIL_RTR0PROCESS)
TeamId = (team_id)R0Process;
rc = lock_memory_etc(TeamId, pvStart, cb, fFlags);
if (rc == B_OK)
{
pMemHaiku->AreaId = -1;
pMemHaiku->Core.u.Lock.R0Process = R0Process;
*ppMem = &pMemHaiku->Core;
return VINF_SUCCESS;
}
rtR0MemObjDelete(&pMemHaiku->Core);
return RTErrConvertFromHaikuKernReturn(rc);
}
/**
* Native kernel thread wrapper function.
*
* This will forward to rtThreadMain and do termination upon return.
*
* @param pvArg Pointer to the argument package.
* @param Ignored Wait result, which we ignore.
*/
static status_t rtThreadNativeMain(void *pvArg)
{
const thread_id Self = find_thread(NULL);
PRTTHREADINT pThread = (PRTTHREADINT)pvArg;
int rc = rtThreadMain(pThread, (RTNATIVETHREAD)Self, &pThread->szName[0]);
if (rc < 0)
return RTErrConvertFromHaikuKernReturn(rc);
return rc;
}
DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThreadInt, PRTNATIVETHREAD pNativeThread)
{
thread_id NativeThread;
RT_ASSERT_PREEMPTIBLE();
NativeThread = spawn_kernel_thread(rtThreadNativeMain, pThreadInt->szName, B_NORMAL_PRIORITY, pThreadInt);
if (NativeThread >= B_OK)
{
resume_thread(NativeThread);
*pNativeThread = (RTNATIVETHREAD)NativeThread;
return VINF_SUCCESS;
}
return RTErrConvertFromHaikuKernReturn(NativeThread);
}
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiHkuWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
status_t status;
int rc;
int32 flags = 0;
bigtime_t timeout; /* in microseconds */
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
timeout = B_INFINITE_TIMEOUT;
else
{
if (fFlags & RTSEMWAIT_FLAGS_NANOSECS)
timeout = uTimeout / 1000;
else if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
timeout = uTimeout * 1000;
else
return VERR_INVALID_PARAMETER;
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
flags |= B_RELATIVE_TIMEOUT;
else if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE)
flags |= B_ABSOLUTE_TIMEOUT;
else
return VERR_INVALID_PARAMETER;
}
if (fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE)
flags |= B_CAN_INTERRUPT;
// likely not:
//else
// flags |= B_KILL_CAN_INTERRUPT;
rtR0SemEventMultiHkuRetain(pThis);
status = acquire_sem_etc(pThis->SemId, 1, flags, timeout);
switch (status)
{
case B_OK:
rc = VINF_SUCCESS;
break;
case B_BAD_SEM_ID:
rc = VERR_SEM_DESTROYED;
break;
case B_INTERRUPTED:
rc = VERR_INTERRUPTED;
break;
case B_WOULD_BLOCK:
/* fallthrough? */
case B_TIMED_OUT:
rc = VERR_TIMEOUT;
break;
default:
rc = RTErrConvertFromHaikuKernReturn(status);
break;
}
rtR0SemEventMultiHkuRelease(pThis);
return rc;
}
static int rtR0MemObjNativeAllocArea(PPRTR0MEMOBJINTERNAL ppMem, size_t cb,
bool fExecutable, RTR0MEMOBJTYPE type, RTHCPHYS PhysHighest, size_t uAlignment)
{
NOREF(fExecutable);
int rc;
void *pvMap = NULL;
const char *pszName = NULL;
uint32 addressSpec = B_ANY_KERNEL_ADDRESS;
uint32 fLock = ~0U;
LogFlowFunc(("ppMem=%p cb=%u, fExecutable=%s, type=%08x, PhysHighest=%RX64 uAlignment=%u\n", ppMem,(unsigned)cb,
fExecutable ? "true" : "false", type, PhysHighest,(unsigned)uAlignment));
switch (type)
{
case RTR0MEMOBJTYPE_PAGE:
pszName = "IPRT R0MemObj Alloc";
fLock = B_FULL_LOCK;
break;
case RTR0MEMOBJTYPE_LOW:
pszName = "IPRT R0MemObj AllocLow";
fLock = B_32_BIT_FULL_LOCK;
break;
case RTR0MEMOBJTYPE_CONT:
pszName = "IPRT R0MemObj AllocCont";
fLock = B_32_BIT_CONTIGUOUS;
break;
#if 0
case RTR0MEMOBJTYPE_MAPPING:
pszName = "IPRT R0MemObj Mapping";
fLock = B_FULL_LOCK;
break;
#endif
case RTR0MEMOBJTYPE_PHYS:
/** @todo alignment */
if (uAlignment != PAGE_SIZE)
return VERR_NOT_SUPPORTED;
/** @todo r=ramshankar: no 'break' here?? */
case RTR0MEMOBJTYPE_PHYS_NC:
pszName = "IPRT R0MemObj AllocPhys";
fLock = (PhysHighest < _4G ? B_LOMEM : B_32_BIT_CONTIGUOUS);
break;
#if 0
case RTR0MEMOBJTYPE_LOCK:
break;
#endif
default:
return VERR_INTERNAL_ERROR;
}
/* Create the object. */
PRTR0MEMOBJHAIKU pMemHaiku;
pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(RTR0MEMOBJHAIKU), type, NULL, cb);
if (RT_UNLIKELY(!pMemHaiku))
return VERR_NO_MEMORY;
rc = pMemHaiku->AreaId = create_area(pszName, &pvMap, addressSpec, cb, fLock, B_READ_AREA | B_WRITE_AREA);
if (pMemHaiku->AreaId >= 0)
{
physical_entry physMap[2];
pMemHaiku->Core.pv = pvMap; /* store start address */
switch (type)
{
case RTR0MEMOBJTYPE_CONT:
rc = get_memory_map(pvMap, cb, physMap, 2);
if (rc == B_OK)
pMemHaiku->Core.u.Cont.Phys = physMap[0].address;
break;
case RTR0MEMOBJTYPE_PHYS:
case RTR0MEMOBJTYPE_PHYS_NC:
rc = get_memory_map(pvMap, cb, physMap, 2);
if (rc == B_OK)
{
pMemHaiku->Core.u.Phys.PhysBase = physMap[0].address;
pMemHaiku->Core.u.Phys.fAllocated = true;
}
break;
default:
break;
}
if (rc >= B_OK)
{
*ppMem = &pMemHaiku->Core;
return VINF_SUCCESS;
}
delete_area(pMemHaiku->AreaId);
}
rtR0MemObjDelete(&pMemHaiku->Core);
return RTErrConvertFromHaikuKernReturn(rc);
}
