Bool
Id_AuthSet(void const *buf, // IN
size_t size) // IN
{
AuthorizationRef newProcAuth;
AuthorizationExternalForm const *ext =
(AuthorizationExternalForm const *)buf;
if (!buf || size != sizeof *ext) {
Warning("%s: Invalid argument.\n", __func__);
return FALSE;
}
ASSERT(!Atomic_ReadPtr(&procAuth));
if (AuthorizationCreateFromExternalForm(ext,
&newProcAuth) != errAuthorizationSuccess) {
Warning("AuthorizationCreateFromExternalForm failed.\n");
return FALSE;
}
if (Atomic_ReadIfEqualWritePtr(&procAuth, NULL, newProcAuth)) {
/*
* This is meant to be called very early on in the life of the
* process. If someone else has snuck in an authorization,
* we're toast.
*/
NOT_IMPLEMENTED();
}
return TRUE;
}
MXUserSemaphore *
MXUser_CreateSingletonSemaphore(Atomic_Ptr *semaStorage, // IN/OUT:
const char *name, // IN:
MX_Rank rank) // IN:
{
MXUserSemaphore *sema;
ASSERT(semaStorage);
sema = Atomic_ReadPtr(semaStorage);
if (UNLIKELY(sema == NULL)) {
MXUserSemaphore *newSema = MXUser_CreateSemaphore(name, rank);
sema = Atomic_ReadIfEqualWritePtr(semaStorage, NULL, (void *) newSema);
if (sema) {
MXUser_DestroySemaphore(newSema);
} else {
sema = Atomic_ReadPtr(semaStorage);
}
}
return sema;
}
MXUserExclLock *
MXUser_CreateSingletonExclLock(Atomic_Ptr *lockStorage, // IN/OUT:
const char *name, // IN:
MX_Rank rank) // IN:
{
MXUserExclLock *lock;
ASSERT(lockStorage);
lock = Atomic_ReadPtr(lockStorage);
if (UNLIKELY(lock == NULL)) {
MXUserExclLock *newLock = MXUser_CreateExclLock(name, rank);
lock = Atomic_ReadIfEqualWritePtr(lockStorage, NULL, (void *) newLock);
if (lock) {
MXUser_DestroyExclLock(newLock);
} else {
lock = Atomic_ReadPtr(lockStorage);
}
}
return lock;
}
static AuthorizationRef
IdAuthGet(void)
{
if (UNLIKELY(Atomic_ReadPtr(&procAuth) == NULL)) {
AuthorizationRef newProcAuth = IdAuthCreate();
if (Atomic_ReadIfEqualWritePtr(&procAuth, NULL, newProcAuth)) {
// Someone else snuck in before we did. Free the new authorization.
AuthorizationFree(newProcAuth, kAuthorizationFlagDefaults);
}
}
ASSERT(Atomic_ReadPtr(&procAuth) != NULL);
return Atomic_ReadPtr(&procAuth);
}
static INLINE void
MXUserForceHisto(Atomic_Ptr *histoPtr, // IN/OUT:
char *typeName, // IN:
uint64 minValue, // IN:
uint32 decades) // IN:
{
MXUserHisto *ptr = Atomic_ReadPtr(histoPtr);
if (ptr == NULL) {
MXUserHisto *before;
ptr = MXUserHistoSetUp(typeName, minValue, decades);
before = Atomic_ReadIfEqualWritePtr(histoPtr, NULL, (void *) ptr);
if (before) {
MXUserHistoTearDown(ptr);
}
}
}
static uint32
SimpleRandomNumber(const char *machineID, // IN:
const char *executionID) // IN:
{
static Atomic_Ptr atomic; /* Implicitly initialized to NULL. --mbellon */
char *context;
context = Atomic_ReadPtr(&atomic);
if (context == NULL) {
void *p;
uint32 value = 0;
/*
* Use the machineID and executionID to hopefully start each machine
* and process/thread at a different place in the answer stream.
*/
while (*machineID) {
value += *machineID++;
}
while (*executionID) {
value += *executionID++;
}
p = Random_QuickSeed(value);
if (Atomic_ReadIfEqualWritePtr(&atomic, NULL, p)) {
free(p);
}
context = Atomic_ReadPtr(&atomic);
ASSERT(context);
}
return (Random_Quick(context) >> 8) & 0xFFFF;
}
Bool
MXUser_ControlExclLock(MXUserExclLock *lock, // IN/OUT:
uint32 command, // IN:
...) // IN:
{
Bool result;
ASSERT(lock);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
switch (command) {
case MXUSER_CONTROL_ACQUISITION_HISTO: {
if (vmx86_stats) {
MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
if (stats == NULL) {
result = FALSE;
} else {
va_list a;
uint32 decades;
uint64 minValue;
va_start(a, command);
minValue = va_arg(a, uint64);
decades = va_arg(a, uint32);
va_end(a);
MXUserForceHisto(&stats->acquisitionHisto,
MXUSER_STAT_CLASS_ACQUISITION, minValue, decades);
result = TRUE;
}
} else {
result = FALSE;
}
break;
}
case MXUSER_CONTROL_HELD_HISTO: {
if (vmx86_stats) {
MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
if (stats == NULL) {
result = FALSE;
} else {
va_list a;
uint32 decades;
uint32 minValue;
va_start(a, command);
minValue = va_arg(a, uint64);
decades = va_arg(a, uint32);
va_end(a);
MXUserForceHisto(&stats->heldHisto, MXUSER_STAT_CLASS_HELD,
minValue, decades);
result = TRUE;
}
} else {
result = FALSE;
}
break;
}
case MXUSER_CONTROL_ENABLE_STATS: {
if (vmx86_stats) {
MXUserStats *stats;
MXUserStats *before;
stats = Util_SafeCalloc(1, sizeof(*stats));
MXUserAcquisitionStatsSetUp(&stats->acquisitionStats);
MXUserBasicStatsSetUp(&stats->heldStats, MXUSER_STAT_CLASS_HELD);
before = Atomic_ReadIfEqualWritePtr(&lock->statsMem, NULL,
(void *) stats);
if (before) {
free(stats);
}
lock->header.statsFunc = MXUserStatsActionExcl;
result = TRUE;
} else {
result = FALSE;
}
break;
}
default:
result = FALSE;
}
return result;
}
Bool
MXUser_ControlRWLock(MXUserRWLock *lock, // IN/OUT:
uint32 command, // IN:
...) // IN:
{
Bool result;
ASSERT(lock);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_RW);
switch (command) {
case MXUSER_CONTROL_ACQUISITION_HISTO: {
if (vmx86_stats) {
MXUserAcquireStats *acquireStats;
acquireStats = Atomic_ReadPtr(&lock->acquireStatsMem);
if (acquireStats == NULL) {
result = FALSE;
} else {
va_list a;
uint32 decades;
uint64 minValue;
va_start(a, command);
minValue = va_arg(a, uint64);
decades = va_arg(a, uint32);
va_end(a);
MXUserForceHisto(&acquireStats->histo,
MXUSER_STAT_CLASS_ACQUISITION, minValue, decades);
result = TRUE;
}
} else {
result = FALSE;
}
break;
}
case MXUSER_CONTROL_HELD_HISTO: {
if (vmx86_stats) {
MXUserHeldStats *heldStats = Atomic_ReadPtr(&lock->heldStatsMem);
if (heldStats == NULL) {
result = FALSE;
} else {
va_list a;
uint32 decades;
uint32 minValue;
va_start(a, command);
minValue = va_arg(a, uint64);
decades = va_arg(a, uint32);
va_end(a);
MXUserForceHisto(&heldStats->histo, MXUSER_STAT_CLASS_HELD,
minValue, decades);
result = TRUE;
}
} else {
result = FALSE;
}
break;
}
case MXUSER_CONTROL_ENABLE_STATS: {
if (vmx86_stats) {
va_list a;
Bool trackHeldTimes;
MXUserHeldStats *heldStats;
MXUserAcquireStats *acquireStats;
acquireStats = Atomic_ReadPtr(&lock->acquireStatsMem);
if (LIKELY(acquireStats == NULL)) {
MXUserAcquireStats *before;
acquireStats = Util_SafeCalloc(1, sizeof(*acquireStats));
MXUserAcquisitionStatsSetUp(&acquireStats->data);
before = Atomic_ReadIfEqualWritePtr(&lock->acquireStatsMem, NULL,
(void *) acquireStats);
if (before) {
free(acquireStats);
}
}
va_start(a, command);
trackHeldTimes = va_arg(a, int);
va_end(a);
heldStats = Atomic_ReadPtr(&lock->heldStatsMem);
if ((heldStats == NULL) && trackHeldTimes) {
MXUserHeldStats *before;
heldStats = Util_SafeCalloc(1, sizeof(*heldStats));
MXUserBasicStatsSetUp(&heldStats->data, MXUSER_STAT_CLASS_HELD);
before = Atomic_ReadIfEqualWritePtr(&lock->heldStatsMem, NULL,
(void *) heldStats);
if (before) {
free(heldStats);
}
}
lock->header.statsFunc = MXUserStatsActionRW;
result = TRUE;
} else {
result = FALSE;
}
break;
}
default:
result = FALSE;
}