Make the ASSERTs consitent in their coding; clean up a few things.
Bool retval = TRUE;
char *dupPath = NULL;
- while (Posix_Statfs(dupPath ? dupPath : pathName,
- pstatfsbuf) == -1) {
+ while (Posix_Statfs(dupPath ? dupPath : pathName, pstatfsbuf) == -1) {
if (errno != ENOENT || doNotAscend) {
retval = FALSE;
break;
syndrome = Atomic_Read(&syndromeMem);
}
- ASSERT(syndrome);
+ ASSERT(syndrome != 0);
return syndrome;
}
signature = (MXUserSyndrome() & 0x0FFFFFFF) | (objectType << 28);
- ASSERT(signature);
+ ASSERT(signature != 0);
return signature;
}
MXUserPerThread *perThread;
MXRecLock *perThreadLock = MXUserInternalSingleton(&perThreadLockMem);
- ASSERT(perThreadLock);
+ ASSERT(perThreadLock != NULL);
MXRecLockAcquire(perThreadLock,
NULL); // non-stats
MXRecLockRelease(perThreadLock);
- ASSERT(perThread);
+ ASSERT(perThread != NULL);
memset(perThread, 0, sizeof *perThread); // ensure all zeros
{
MXRecLock *perThreadLock;
- ASSERT(perThread);
+ ASSERT(perThread != NULL);
ASSERT(perThread->next == NULL);
perThreadLock = MXUserInternalSingleton(&perThreadLockMem);
- ASSERT(perThreadLock);
+ ASSERT(perThreadLock != NULL);
MXRecLockAcquire(perThreadLock,
NULL); // non-stats
*/
perThread = HashTable_LookupOrInsert(hash, tid, newEntry);
- ASSERT(perThread);
+ ASSERT(perThread != NULL);
if (perThread != newEntry) {
MXUserFreePerThread(newEntry);
Bool foundOnce = TRUE;
MX_Rank maxRank = RANK_UNRANKED;
- ASSERT(perThread);
+ ASSERT(perThread != NULL);
/*
* Determine the maximum rank held. Note if the lock being acquired
char *properName;
MXUserBarrier *barrier;
- ASSERT(count);
+ ASSERT(count != 0);
barrier = Util_SafeCalloc(1, sizeof *barrier);
BarrierContext *ptr;
uint32 context;
- ASSERT(barrier);
+ ASSERT(barrier != NULL);
MXUserValidateHeader(&barrier->header, MXUSER_TYPE_BARRIER);
MXUser_AcquireExclLock(barrier->lock);
{
MXUserBarrier *barrier;
- ASSERT(barrierStorage);
+ ASSERT(barrierStorage != NULL);
barrier = Atomic_ReadPtr(barrierStorage);
/*********************************************************
- * Copyright (C) 2010-2017 VMware, Inc. All rights reserved.
+ * Copyright (C) 2010-2019 VMware, Inc. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
MXUserCondVar *condVar, // IN/OUT:
uint32 waitTimeMsec) // IN:
{
- ASSERT(header);
- ASSERT(lock);
- ASSERT(condVar);
+ ASSERT(header != NULL);
+ ASSERT(lock != NULL);
+ ASSERT(condVar != NULL);
ASSERT(condVar->signature == MXUserGetSignature(MXUSER_TYPE_CONDVAR));
if (condVar->ownerLock != lock) {
{
int err;
- ASSERT(condVar);
+ ASSERT(condVar != NULL);
ASSERT(condVar->signature == MXUserGetSignature(MXUSER_TYPE_CONDVAR));
err = MXUserSignalInternal(condVar);
{
int err;
- ASSERT(condVar);
+ ASSERT(condVar != NULL);
ASSERT(condVar->signature == MXUserGetSignature(MXUSER_TYPE_CONDVAR));
err = MXUserBroadcastInternal(condVar);
Bool trackAcquisitionTime, // IN:
Bool trackHeldTime) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
Bool
MXUser_DisableStatsExclLock(MXUserExclLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
void
MXUser_AcquireExclLock(MXUserExclLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
MXUserAcquisitionTracking(&lock->header, TRUE);
void
MXUser_ReleaseExclLock(MXUserExclLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (vmx86_stats) {
{
Bool success;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
if (MXUserTryAcquireFail(lock->header.name)) {
Bool
MXUser_IsCurThreadHoldingExclLock(MXUserExclLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
return MXRecLockIsOwner(&lock->recursiveLock);
{
MXUserExclLock *lock;
- ASSERT(lockStorage);
+ ASSERT(lockStorage != NULL);
lock = Atomic_ReadPtr(lockStorage);
MXUserCondVar *
MXUser_CreateCondVarExclLock(MXUserExclLock *lock)
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
return MXUserCreateCondVar(&lock->header, &lock->recursiveLock);
MXUser_WaitCondVarExclLock(MXUserExclLock *lock, // IN:
MXUserCondVar *condVar) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
MXUserWaitCondVar(&lock->header, &lock->recursiveLock, condVar,
MXUserCondVar *condVar, // IN:
uint32 waitTimeMsec) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
MXUserWaitCondVar(&lock->header, &lock->recursiveLock, condVar,
{
HolderContext *myContext;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_RW);
MXUserAcquisitionTracking(&lock->header, TRUE);
{
HolderContext *myContext;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_RW);
myContext = MXUserGetHolderContext(lock);
{
HolderContext *myContext;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_RW);
myContext = MXUserGetHolderContext(lock);
{
MXUserRWLock *lock;
- ASSERT(lockStorage);
+ ASSERT(lockStorage != NULL);
lock = Atomic_ReadPtr(lockStorage);
Bool trackAcquisitionTime, // IN:
Bool trackHeldTime) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
if (vmx86_stats) {
Bool
MXUser_DisableStatsRecLock(MXUserRecLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
if (vmx86_stats) {
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
if (vmx86_stats) {
static void
MXUserCondDestroyRecLock(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
void
MXUser_AcquireRecLock(MXUserRecLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
void
MXUser_ReleaseRecLock(MXUserRecLock *lock) // IN/OUT:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
{
Bool success;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
{
Bool result;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
{
MXUserRecLock *lock;
- ASSERT(lockStorage);
+ ASSERT(lockStorage != NULL);
lock = Atomic_ReadPtr(lockStorage);
{
MXUserCondVar *condVar;
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(lock->vmmLock == NULL); // only unbound locks
MXUser_WaitCondVarRecLock(MXUserRecLock *lock, // IN:
MXUserCondVar *condVar) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(lock->vmmLock == NULL); // only unbound locks
MXUserCondVar *condVar, // IN:
uint32 waitTimeMsec) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(lock->vmmLock == NULL); // only unbound locks
void
MXUser_DumpRecLock(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
MXUserDumpRecLock(&lock->header);
struct MX_MutexRec *
MXUser_GetRecLockVmm(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
return lock->vmmLock;
MX_Rank
MXUser_GetRecLockRank(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
return lock->header.rank;
char *name;
MXUserRecLock *lock;
- ASSERT(mutex);
+ ASSERT(mutex != NULL);
/*
* Cannot perform a binding unless MX_Init has been called. As a side
void
MXUser_IncRefRecLock(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
ASSERT(Atomic_Read(&lock->refCount) > 0);
void
MXUser_DecRefRecLock(MXUserRecLock *lock) // IN:
{
- ASSERT(lock);
+ ASSERT(lock != NULL);
MXUserValidateHeader(&lock->header, MXUSER_TYPE_REC);
MXUserCondDestroyRecLock(lock);
{
int err;
- ASSERT(sema);
+ ASSERT(sema != NULL);
MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
Atomic_Inc(&sema->activeUserCount);
int err;
Bool downOccurred = FALSE;
- ASSERT(sema);
+ ASSERT(sema != NULL);
MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
Atomic_Inc(&sema->activeUserCount);
int err;
Bool downOccurred = FALSE;
- ASSERT(sema);
+ ASSERT(sema != NULL);
MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
Atomic_Inc(&sema->activeUserCount);
{
int err;
- ASSERT(sema);
+ ASSERT(sema != NULL);
MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
/*
{
MXUserSemaphore *sema;
- ASSERT(semaStorage);
+ ASSERT(semaStorage != NULL);
sema = Atomic_ReadPtr(semaStorage);