static int rtMpDarwinInitMaxCpus(void)
{
IPRT_DARWIN_SAVE_EFL_AC();
int32_t cCpus = -1;
size_t oldLen = sizeof(cCpus);
int rc = sysctlbyname("hw.ncpu", &cCpus, &oldLen, NULL, NULL);
if (rc)
{
printf("IPRT: sysctlbyname(hw.ncpu) failed with rc=%d!\n", rc);
cCpus = 64; /* whatever */
}
ASMAtomicWriteS32(&g_cMaxCpus, cCpus);
IPRT_DARWIN_RESTORE_EFL_AC();
return cCpus;
}
RTDECL(int) RTMpOnSpecific(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
{
RT_ASSERT_INTS_ON();
IPRT_DARWIN_SAVE_EFL_AC();
RTMPARGS Args;
Args.pfnWorker = pfnWorker;
Args.pvUser1 = pvUser1;
Args.pvUser2 = pvUser2;
Args.idCpu = idCpu;
Args.cHits = 0;
mp_rendezvous_no_intrs(rtmpOnSpecificDarwinWrapper, &Args);
IPRT_DARWIN_RESTORE_EFL_AC();
return Args.cHits == 1
? VINF_SUCCESS
: VERR_CPU_NOT_FOUND;
}
RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutexSem)
{
/*
* Validate.
*/
RTSEMMUTEXINTERNAL *pThis = hMutexSem;
AssertPtrReturn(pThis, false);
AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, false);
IPRT_DARWIN_SAVE_EFL_AC();
/*
* Take the lock and do the check.
*/
lck_spin_lock(pThis->pSpinlock);
bool fRc = pThis->hNativeOwner != NIL_RTNATIVETHREAD;
lck_spin_unlock(pThis->pSpinlock);
IPRT_DARWIN_RESTORE_EFL_AC();
return fRc;
}
RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
{
/*
* Validate input.
*/
PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)hMutexSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
RT_ASSERT_PREEMPTIBLE();
IPRT_DARWIN_SAVE_EFL_AC();
/*
* Take the lock and do the job.
*/
RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
int rc = VINF_SUCCESS;
lck_spin_lock(pThis->pSpinlock);
if (pThis->hNativeOwner == hNativeSelf)
{
Assert(pThis->cRecursions > 0);
if (--pThis->cRecursions == 0)
{
pThis->hNativeOwner = NIL_RTNATIVETHREAD;
if (pThis->cWaiters > 0)
thread_wakeup_prim((event_t)pThis, TRUE /* one_thread */, THREAD_AWAKENED);
}
}
else
rc = VERR_NOT_OWNER;
lck_spin_unlock(pThis->pSpinlock);
AssertRC(rc);
IPRT_DARWIN_RESTORE_EFL_ONLY_AC();
return VINF_SUCCESS;
}
RTR0DECL(void *) RTMemContAlloc(PRTCCPHYS pPhys, size_t cb)
{
/*
* validate input.
*/
AssertPtr(pPhys);
Assert(cb > 0);
RT_ASSERT_PREEMPTIBLE();
IPRT_DARWIN_SAVE_EFL_AC();
/*
* Allocate the memory and ensure that the API is still providing
* memory that's always below 4GB.
*/
cb = RT_ALIGN_Z(cb, PAGE_SIZE);
IOPhysicalAddress PhysAddr;
void *pv = IOMallocContiguous(cb, PAGE_SIZE, &PhysAddr);
if (pv)
{
if (PhysAddr + (cb - 1) <= (IOPhysicalAddress)0xffffffff)
{
if (!((uintptr_t)pv & PAGE_OFFSET_MASK))
{
*pPhys = PhysAddr;
IPRT_DARWIN_RESTORE_EFL_AC();
return pv;
}
AssertMsgFailed(("IOMallocContiguous didn't return a page aligned address - %p!\n", pv));
}
else
AssertMsgFailed(("IOMallocContiguous returned high address! PhysAddr=%RX64 cb=%#zx\n", (uint64_t)PhysAddr, cb));
IOFreeContiguous(pv, cb);
}
IPRT_DARWIN_RESTORE_EFL_AC();
return NULL;
}
RTDECL(int) RTFileOpen(PRTFILE phFile, const char *pszFilename, uint64_t fOpen)
{
RTFILEINT *pThis = (RTFILEINT *)RTMemAllocZ(sizeof(*pThis));
if (!pThis)
return VERR_NO_MEMORY;
IPRT_DARWIN_SAVE_EFL_AC();
errno_t rc;
pThis->u32Magic = RTFILE_MAGIC;
pThis->fOpen = fOpen;
pThis->hVfsCtx = vfs_context_current();
if (pThis->hVfsCtx != NULL)
{
int fCMode = (fOpen & RTFILE_O_CREATE_MODE_MASK)
? (fOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT
: RT_FILE_PERMISSION;
int fVnFlags = 0; /* VNODE_LOOKUP_XXX */
int fOpenMode = 0;
if (fOpen & RTFILE_O_NON_BLOCK)
fOpenMode |= O_NONBLOCK;
if (fOpen & RTFILE_O_WRITE_THROUGH)
fOpenMode |= O_SYNC;
/* create/truncate file */
switch (fOpen & RTFILE_O_ACTION_MASK)
{
case RTFILE_O_OPEN: break;
case RTFILE_O_OPEN_CREATE: fOpenMode |= O_CREAT; break;
case RTFILE_O_CREATE: fOpenMode |= O_CREAT | O_EXCL; break;
case RTFILE_O_CREATE_REPLACE: fOpenMode |= O_CREAT | O_TRUNC; break; /** @todo replacing needs fixing, this is *not* a 1:1 mapping! */
}
if (fOpen & RTFILE_O_TRUNCATE)
fOpenMode |= O_TRUNC;
switch (fOpen & RTFILE_O_ACCESS_MASK)
{
case RTFILE_O_READ:
fOpenMode |= FREAD;
break;
case RTFILE_O_WRITE:
fOpenMode |= fOpen & RTFILE_O_APPEND ? O_APPEND | FWRITE : FWRITE;
break;
case RTFILE_O_READWRITE:
fOpenMode |= fOpen & RTFILE_O_APPEND ? O_APPEND | FWRITE | FREAD : FWRITE | FREAD;
break;
default:
AssertMsgFailed(("RTFileOpen received an invalid RW value, fOpen=%#x\n", fOpen));
IPRT_DARWIN_RESTORE_EFL_AC();
return VERR_INVALID_PARAMETER;
}
pThis->fOpenMode = fOpenMode;
rc = vnode_open(pszFilename, fOpenMode, fCMode, fVnFlags, &pThis->hVnode, pThis->hVfsCtx);
if (rc == 0)
{
*phFile = pThis;
IPRT_DARWIN_RESTORE_EFL_AC();
return VINF_SUCCESS;
}
rc = RTErrConvertFromErrno(rc);
}
