lib/lock: No need for stats all of the time

Way back when there was a concern that a release build might need
to be performance analyzed (for locks) in the field. At the time the
VMX wasn't considered to be a major bottleneck so the MXUser
statistics were built into every type of build.

Now a days, we have stats builds in the field when we need numbers
and the VMX is turning into a bottleneck. Remove the stats code
from all but stats builds. This saves ~7 clocks when acquiring
an uncontended exclusive lock in a release build.

The statsMem pointer is left in all builds to maintain the size of
the structure until will can find where a lock is used across two
copies of lib/lock with different build types.

Signed-off-by: Dmitry Torokhov <dtor@vmware.com>

diff --git a/open-vm-tools/lib/lock/ul.c b/open-vm-tools/lib/lock/ul.c
index aa60e707776e62c7b02c1d7b7203b838eb1f64f2..597fda62ee16f1ac5320ca4fa6d6ec8e144b93b9 100644 (file)
--- a/open-vm-tools/lib/lock/ul.c
+++ b/open-vm-tools/lib/lock/ul.c
@@ -446,8 +446,7 @@ MXUserAllocPerThread(void)
 
    ASSERT(perThreadLock);
 
-   MXRecLockAcquire(perThreadLock,
-                    NULL);          // non-stats
+   MXRecLockAcquire(perThreadLock);
 
    if (perThreadFreeList == NULL) {
       perThread = Util_SafeMalloc(sizeof *perThread);
@@ -495,8 +494,7 @@ MXUserFreePerThread(MXUserPerThread *perThread)  // IN:
    perThreadLock = MXUserInternalSingleton(&perThreadLockMem);
    ASSERT(perThreadLock);
 
-   MXRecLockAcquire(perThreadLock,
-                    NULL);          // non-stats
+   MXRecLockAcquire(perThreadLock);
    perThread->next = perThreadFreeList;
    perThreadFreeList = perThread;
    MXRecLockRelease(perThreadLock);

diff --git a/open-vm-tools/lib/lock/ulCondVar.c b/open-vm-tools/lib/lock/ulCondVar.c
index 53cdc9385d0a015723ba6aa36f9f7b3675933aed..f9d560a40a765cde52b8334689c4900528c25c98 100644 (file)
--- a/open-vm-tools/lib/lock/ulCondVar.c
+++ b/open-vm-tools/lib/lock/ulCondVar.c
@@ -300,8 +300,7 @@ MXUserWaitInternal(MXRecLock *lock,         // IN:
          LeaveCriticalSection(&condVar->x.compat.condVarLock);
       } while (!done);
 
-      MXRecLockAcquire(lock,
-                       NULL);  // non-stats
+      MXRecLockAcquire(lock);
 
       MXRecLockIncCount(lock, lockCount - 1);
 

diff --git a/open-vm-tools/lib/lock/ulExcl.c b/open-vm-tools/lib/lock/ulExcl.c
index 6c888d95cc5ce29cdf826ff00d8ae9970f5f8e3f..e7d0fe52af119215cc08d5db59e8c170774bfea8 100644 (file)
--- a/open-vm-tools/lib/lock/ulExcl.c
+++ b/open-vm-tools/lib/lock/ulExcl.c
@@ -62,7 +62,7 @@ static void
 MXUserStatsActionExcl(MXUserHeader *header)  // IN:
 {
    MXUserExclLock *lock = (MXUserExclLock *) header;
-   MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
    if (stats) {
       Bool isHot;
@@ -140,22 +140,27 @@ MXUser_ControlExclLock(MXUserExclLock *lock,  // IN/OUT:
 
    switch (command) {
    case MXUSER_CONTROL_ACQUISITION_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         va_list a;
-         uint64 minValue;
-         uint32 decades;
+         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);
+            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);
+            MXUserForceHisto(&stats->acquisitionHisto,
+                             MXUSER_STAT_CLASS_ACQUISITION, minValue, decades);
+
+            result = TRUE;
+         }
 
-         result = TRUE;
       } else {
          result = FALSE;
       }
@@ -164,22 +169,26 @@ MXUser_ControlExclLock(MXUserExclLock *lock,  // IN/OUT:
    }
 
    case MXUSER_CONTROL_HELD_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         va_list a;
-         uint32 minValue;
-         uint32 decades;
+         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);
+            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);
+            MXUserForceHisto(&stats->heldHisto, MXUSER_STAT_CLASS_HELD,
+                             minValue, decades);
 
-         result = TRUE;
+            result = TRUE;
+         }
       } else {
          result = FALSE;
       }
@@ -188,9 +197,8 @@ MXUser_ControlExclLock(MXUserExclLock *lock,  // IN/OUT:
    }
 
    case MXUSER_CONTROL_ENABLE_STATS: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
-
-      if (LIKELY(stats == NULL)) {
+      if (vmx86_stats) {
+         MXUserStats *stats;
          MXUserStats *before;
 
          stats = Util_SafeCalloc(1, sizeof(*stats));
@@ -198,19 +206,19 @@ MXUser_ControlExclLock(MXUserExclLock *lock,  // IN/OUT:
          MXUserAcquisitionStatsSetUp(&stats->acquisitionStats);
          MXUserBasicStatsSetUp(&stats->heldStats, MXUSER_STAT_CLASS_HELD);
 
-         before = (MXUserStats *) Atomic_ReadIfEqualWritePtr(&lock->statsMem,
-                                                             NULL,
-                                                             (void *) stats);
+         before = Atomic_ReadIfEqualWritePtr(&lock->statsMem, NULL,
+                                             (void *) stats);
 
          if (before) {
             free(stats);
          }
 
          lock->header.statsFunc = MXUserStatsActionExcl;
-      }
 
-      result = TRUE;
-      break;
+         result = TRUE;
+      } else {
+         result = FALSE;
+      }
    }
 
    default:
@@ -242,7 +250,7 @@ MXUserDumpExclLock(MXUserHeader *header)  // IN:
 {
    MXUserExclLock *lock = (MXUserExclLock *) header;
 
-   Warning("%s: Exclusive lock @ 0x%p\n", __FUNCTION__, lock);
+   Warning("%s: Exclusive lock @ %p\n", __FUNCTION__, lock);
 
    Warning("\tsignature 0x%X\n", lock->header.signature);
    Warning("\tname %s\n", lock->header.name);
@@ -251,7 +259,7 @@ MXUserDumpExclLock(MXUserHeader *header)  // IN:
 
    Warning("\tcount %d\n", MXRecLockCount(&lock->recursiveLock));
 
-   Warning("\taddress of owner data 0x%p\n",
+   Warning("\taddress of owner data %p\n",
            &lock->recursiveLock.nativeThreadID);
 }
 
@@ -277,6 +285,7 @@ MXUserExclLock *
 MXUser_CreateExclLock(const char *userName,  // IN:
                       MX_Rank rank)          // IN:
 {
+   Bool doStats;
    char *properName;
    MXUserExclLock *lock;
 
@@ -301,7 +310,13 @@ MXUser_CreateExclLock(const char *userName,  // IN:
    lock->header.serialNumber = MXUserAllocSerialNumber();
    lock->header.dumpFunc = MXUserDumpExclLock;
 
-   if (MXUserStatsEnabled()) {
+   if (vmx86_stats) {
+      doStats = MXUserStatsEnabled();
+   } else {
+      doStats = FALSE;
+   }
+
+   if (doStats) {
       MXUser_ControlExclLock(lock, MXUSER_CONTROL_ENABLE_STATS);
    } else {
       lock->header.statsFunc = NULL;
@@ -334,8 +349,6 @@ void
 MXUser_DestroyExclLock(MXUserExclLock *lock)  // IN:
 {
    if (lock != NULL) {
-      MXUserStats *stats;
-
       MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
 
       if (MXRecLockCount(&lock->recursiveLock) > 0) {
@@ -350,15 +363,18 @@ MXUser_DestroyExclLock(MXUserExclLock *lock)  // IN:
 
       MXUserRemoveFromList(&lock->header);
 
-      stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
-         MXUserBasicStatsTearDown(&stats->heldStats);
-         MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
-         MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+         if (LIKELY(stats != NULL)) {
+            MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
+            MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
 
-         free(stats);
+            MXUserBasicStatsTearDown(&stats->heldStats);
+            MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+
+            free(stats);
+         }
       }
 
       free(lock->header.name);
@@ -387,36 +403,39 @@ MXUser_DestroyExclLock(MXUserExclLock *lock)  // IN:
 void
 MXUser_AcquireExclLock(MXUserExclLock *lock)  // IN/OUT:
 {
-   MXUserStats *stats;
-
    ASSERT(lock);
    MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
-
    MXUserAcquisitionTracking(&lock->header, TRUE);
 
-   if (stats) {
-      MXUserHisto *histo;
-      VmTimeType value = 0;
+   if (vmx86_stats) {
+      Bool contended;
+      VmTimeType start = 0;
+      MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
+
+      if (LIKELY(stats != NULL)) {
+         start = Hostinfo_SystemTimerNS();
+      }
 
-      MXRecLockAcquire(&lock->recursiveLock, &value);
+      contended = MXRecLockAcquire(&lock->recursiveLock);
 
-      MXUserAcquisitionSample(&stats->acquisitionStats,
-                              TRUE,
-                              value != 0,  // True if contended
-                              value);
+      if (LIKELY(stats != NULL)) {
+         MXUserHisto *histo;
+         VmTimeType value = Hostinfo_SystemTimerNS() - start;
 
-      histo = Atomic_ReadPtr(&stats->acquisitionHisto);
+         MXUserAcquisitionSample(&stats->acquisitionStats, TRUE, contended,
+                                 value);
 
-      if (UNLIKELY(histo != NULL)) {
-         MXUserHistoSample(histo, value, GetReturnAddress());
-      }
+         histo = Atomic_ReadPtr(&stats->acquisitionHisto);
 
-      stats->holdStart = Hostinfo_SystemTimerNS();
+         if (UNLIKELY(histo != NULL)) {
+            MXUserHistoSample(histo, value, GetReturnAddress());
+         }
+
+         stats->holdStart = Hostinfo_SystemTimerNS();
+      }
    } else {
-      MXRecLockAcquire(&lock->recursiveLock,
-                       NULL);                 // non-stats
+      MXRecLockAcquire(&lock->recursiveLock);
    }
 
    if (vmx86_debug && (MXRecLockCount(&lock->recursiveLock) > 1)) {
@@ -446,23 +465,23 @@ MXUser_AcquireExclLock(MXUserExclLock *lock)  // IN/OUT:
 void
 MXUser_ReleaseExclLock(MXUserExclLock *lock)  // IN/OUT:
 {
-   MXUserStats *stats;
-
    ASSERT(lock);
    MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   if (vmx86_stats) {
+      MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-   if (stats) {
-      VmTimeType value = Hostinfo_SystemTimerNS() - stats->holdStart;
-      MXUserHisto *histo;
+      if (LIKELY(stats != NULL)) {
+         MXUserHisto *histo;
+         VmTimeType value = Hostinfo_SystemTimerNS() - stats->holdStart;
 
-      MXUserBasicStatsSample(&stats->heldStats, value);
+         MXUserBasicStatsSample(&stats->heldStats, value);
 
-      histo = Atomic_ReadPtr(&stats->heldHisto);
+         histo = Atomic_ReadPtr(&stats->heldHisto);
 
-      if (UNLIKELY(histo != NULL)) {
-         MXUserHistoSample(histo, value, GetReturnAddress());
+         if (UNLIKELY(histo != NULL)) {
+            MXUserHistoSample(histo, value, GetReturnAddress());
+         }
       }
    }
 
@@ -506,7 +525,6 @@ Bool
 MXUser_TryAcquireExclLock(MXUserExclLock *lock)  // IN/OUT:
 {
    Bool success;
-   MXUserStats *stats;
 
    ASSERT(lock);
    MXUserValidateHeader(&lock->header, MXUSER_TYPE_EXCL);
@@ -527,11 +545,13 @@ MXUser_TryAcquireExclLock(MXUserExclLock *lock)  // IN/OUT:
       }
    }
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   if (vmx86_stats) {
+      MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-   if (stats) {
-      MXUserAcquisitionSample(&stats->acquisitionStats, success, !success,
-                              0ULL);
+      if (LIKELY(stats != NULL)) {
+         MXUserAcquisitionSample(&stats->acquisitionStats, success, !success,
+                                 0ULL);
+      }
    }
 
    return success;
@@ -593,18 +613,17 @@ MXUser_CreateSingletonExclLock(Atomic_Ptr *lockStorage,  // IN/OUT:
 
    ASSERT(lockStorage);
 
-   lock = (MXUserExclLock *) Atomic_ReadPtr(lockStorage);
+   lock = Atomic_ReadPtr(lockStorage);
 
    if (UNLIKELY(lock == NULL)) {
       MXUserExclLock *newLock = MXUser_CreateExclLock(name, rank);
 
-      lock = (MXUserExclLock *) Atomic_ReadIfEqualWritePtr(lockStorage, NULL,
-                                                           (void *) newLock);
+      lock = Atomic_ReadIfEqualWritePtr(lockStorage, NULL, (void *) newLock);
 
       if (lock) {
          MXUser_DestroyExclLock(newLock);
       } else {
-         lock = (MXUserExclLock *) Atomic_ReadPtr(lockStorage);
+         lock = Atomic_ReadPtr(lockStorage);
       }
    }
 

diff --git a/open-vm-tools/lib/lock/ulInt.h b/open-vm-tools/lib/lock/ulInt.h
index 60f79dd982b8ec47a47201b6a6656ecc99bafc9f..abfa4905673be838d0f7347574ff501b4b568c60 100644 (file)
--- a/open-vm-tools/lib/lock/ulInt.h
+++ b/open-vm-tools/lib/lock/ulInt.h
@@ -39,7 +39,6 @@ typedef pthread_t MXUserThreadID;
 
 #include "vm_basic_types.h"
 #include "vthreadBase.h"
-#include "hostinfo.h"
 
 #include "circList.h"
 
@@ -282,77 +281,67 @@ MXRecLockIncCount(MXRecLock *lock,  // IN/OUT:
 }
 
 
-static INLINE void
-MXRecLockAcquire(MXRecLock *lock,       // IN/OUT:
-                 VmTimeType *duration)  // IN/OPT: !NULL for stats
+static INLINE Bool
+MXRecLockAcquire(MXRecLock *lock)  // IN/OUT:
 {
-   if (duration != NULL) {
-      *duration = 0ULL;
-   }
+   int err;
 
    if ((MXRecLockCount(lock) > 0) && MXRecLockIsOwner(lock)) {
       MXRecLockIncCount(lock, 1);
-   } else {
-      int err = MXRecLockTryAcquireInternal(lock);
 
-      if (err != 0) {
-         VmTimeType start;
-
-         if (vmx86_debug && (err != EBUSY)) {
-            Panic("%s: MXRecLockTryAcquireInternal returned %d\n",
-                  __FUNCTION__, err);
-         }
+      return FALSE;  // Not contended
+   }
 
-         if (duration != NULL) {
-            start = Hostinfo_SystemTimerNS();
-         }
+   err = MXRecLockTryAcquireInternal(lock);
 
-         err = MXRecLockAcquireInternal(lock);
+   if (err == 0) {
+      MXRecLockIncCount(lock, 1);
 
-         if (duration != NULL) {
-            *duration = Hostinfo_SystemTimerNS() - start;
-         }
-      }
+      return FALSE;  // Not contended
+   }
 
-      if (vmx86_debug && (err != 0)) {
-         Panic("%s: MXRecLockAcquireInternal returned %d\n", __FUNCTION__,
-               err);
-      }
+   if (vmx86_debug && (err != EBUSY)) {
+      Panic("%s: MXRecLockTryAcquireInternal error %d\n", __FUNCTION__, err);
+   }
 
-      ASSERT(MXRecLockCount(lock) == 0);
+   err = MXRecLockAcquireInternal(lock);
 
-      MXRecLockIncCount(lock, 1);
+   if (vmx86_debug && (err != 0)) {
+      Panic("%s: MXRecLockAcquireInternal error %d\n", __FUNCTION__, err);
    }
+
+   ASSERT(MXRecLockCount(lock) == 0);
+
+   MXRecLockIncCount(lock, 1);
+
+   return TRUE;  // Contended
 }
 
 
 static INLINE Bool
 MXRecLockTryAcquire(MXRecLock *lock)  // IN/OUT:
 {
-   Bool acquired;
+   int err;
 
    if ((MXRecLockCount(lock) > 0) && MXRecLockIsOwner(lock)) {
-      acquired = TRUE;
-   } else {
-      int err = MXRecLockTryAcquireInternal(lock);
-
-      if (err == 0) {
-         acquired = TRUE;
-      } else {
-         if (vmx86_debug && (err != EBUSY)) {
-            Panic("%s: MXRecLockTryAcquireInternal returned %d\n",
-                  __FUNCTION__, err);
-         }
-
-         acquired = FALSE;
-      }
+      MXRecLockIncCount(lock, 1);
+
+      return TRUE;  // Was acquired
    }
 
-   if (acquired) {
+   err = MXRecLockTryAcquireInternal(lock);
+
+   if (err == 0) {
       MXRecLockIncCount(lock, 1);
+
+      return TRUE;  // Was acquired
+   }
+
+   if (vmx86_debug && (err != EBUSY)) {
+      Panic("%s: MXRecLockTryAcquireInternal error %d\n", __FUNCTION__, err);
    }
 
-   return acquired;
+   return FALSE;  // Was not acquired
 }
 
 static INLINE void

diff --git a/open-vm-tools/lib/lock/ulRW.c b/open-vm-tools/lib/lock/ulRW.c
index f10262886b4b8db555856f8ace4688b7c03f5066..8ec5cb7d9da0eab0efd4b27b050388caeb826536 100644 (file)
--- a/open-vm-tools/lib/lock/ulRW.c
+++ b/open-vm-tools/lib/lock/ulRW.c
@@ -288,7 +288,7 @@ static void
 MXUserStatsActionRW(MXUserHeader *header)  // IN:
 {
    MXUserRWLock *lock = (MXUserRWLock *) header;
-   MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
    if (stats) {
       Bool isHot;
@@ -367,22 +367,26 @@ MXUser_ControlRWLock(MXUserRWLock *lock,  // IN/OUT:
 
    switch (command) {
    case MXUSER_CONTROL_ACQUISITION_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         va_list a;
-         uint64 minValue;
-         uint32 decades;
+         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);
+            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);
+            MXUserForceHisto(&stats->acquisitionHisto,
+                             MXUSER_STAT_CLASS_ACQUISITION, minValue, decades);
 
-         result = TRUE;
+            result = TRUE;
+         }
       } else {
          result = FALSE;
       }
@@ -391,22 +395,26 @@ MXUser_ControlRWLock(MXUserRWLock *lock,  // IN/OUT:
    }
 
    case MXUSER_CONTROL_HELD_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         va_list a;
-         uint32 minValue;
-         uint32 decades;
+         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);
+            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);
+            MXUserForceHisto(&stats->heldHisto, MXUSER_STAT_CLASS_HELD,
+                             minValue, decades);
 
-         result = TRUE;
+            result = TRUE;
+         }
       } else {
          result = FALSE;
       }
@@ -415,9 +423,8 @@ MXUser_ControlRWLock(MXUserRWLock *lock,  // IN/OUT:
    }
 
    case MXUSER_CONTROL_ENABLE_STATS: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
-
-      if (LIKELY(stats == NULL)) {
+      if (vmx86_stats) {
+         MXUserStats *stats;
          MXUserStats *before;
 
          stats = Util_SafeCalloc(1, sizeof(*stats));
@@ -425,18 +432,20 @@ MXUser_ControlRWLock(MXUserRWLock *lock,  // IN/OUT:
          MXUserAcquisitionStatsSetUp(&stats->acquisitionStats);
          MXUserBasicStatsSetUp(&stats->heldStats, MXUSER_STAT_CLASS_HELD);
 
-         before = (MXUserStats *) Atomic_ReadIfEqualWritePtr(&lock->statsMem,
-                                                             NULL,
-                                                             (void *) stats);
+         before = Atomic_ReadIfEqualWritePtr(&lock->statsMem, NULL,
+                                             (void *) stats);
 
          if (before) {
             free(stats);
          }
 
          lock->header.statsFunc = MXUserStatsActionRW;
+
+         result = TRUE;
+      } else {
+         result = FALSE;
       }
 
-      result = TRUE;
       break;
    }
 
@@ -545,11 +554,19 @@ MXUser_CreateRWLock(const char *userName,  // IN:
    lockInited = MXRecLockInit(&lock->recursiveLock);
 
    if (LIKELY(lockInited)) {
+      Bool doStats;
+
       lock->holderTable = HashTable_Alloc(256,
                                           HASH_INT_KEY | HASH_FLAG_ATOMIC,
                                           MXUserFreeHashEntry);
 
-      if (MXUserStatsEnabled()) {
+      if (vmx86_stats) {
+         doStats = MXUserStatsEnabled();
+      } else {
+         doStats = FALSE;
+      }
+
+      if (doStats) {
          MXUser_ControlRWLock(lock, MXUSER_CONTROL_ENABLE_STATS);
       } else {
          lock->header.statsFunc = NULL;
@@ -591,8 +608,6 @@ void
 MXUser_DestroyRWLock(MXUserRWLock *lock)  // IN:
 {
    if (LIKELY(lock != NULL)) {
-      MXUserStats *stats;
-
       MXUserValidateHeader(&lock->header, MXUSER_TYPE_RW);
 
       if (Atomic_Read(&lock->holderCount) != 0) {
@@ -612,19 +627,22 @@ MXUser_DestroyRWLock(MXUserRWLock *lock)  // IN:
 
       lock->header.signature = 0;  // just in case...
 
-      MXRecLockDestroy(&lock->recursiveLock);  
+      MXRecLockDestroy(&lock->recursiveLock);
 
       MXUserRemoveFromList(&lock->header);
 
-      stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
-         MXUserBasicStatsTearDown(&stats->heldStats);
-         MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
-         MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+         if (LIKELY(stats != NULL)) {
+            MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
+            MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
 
-         free(stats);
+            MXUserBasicStatsTearDown(&stats->heldStats);
+            MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+
+            free(stats);
+         }
       }
 
       HashTable_FreeUnsafe(lock->holderTable);
@@ -698,7 +716,6 @@ static INLINE void
 MXUserAcquisition(MXUserRWLock *lock,  // IN/OUT:
                   Bool forRead)        // IN:
 {
-   MXUserStats *stats;
    HolderContext *myContext;
 
    ASSERT(lock);
@@ -717,56 +734,56 @@ MXUserAcquisition(MXUserRWLock *lock,  // IN/OUT:
                                                                    "Write");
    }
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   if (vmx86_stats) {
+      Bool contended;
+      VmTimeType start = 0;
+      MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-   if (stats) {
-      VmTimeType value;
-      MXUserHisto *histo;
+      if (LIKELY(stats != NULL)) {
+         start = Hostinfo_SystemTimerNS();
+      }
 
       if (lock->useNative) {
          int err = 0;
-         Bool contended;
-         VmTimeType begin = Hostinfo_SystemTimerNS();
 
          contended = MXUserNativeRWAcquire(&lock->nativeLock, forRead, &err);
 
-         value = contended ? Hostinfo_SystemTimerNS() - begin : 0;
-
          if (UNLIKELY(err != 0)) {
             MXUserDumpAndPanic(&lock->header, "%s: Error %d: contended %d\n",
                                __FUNCTION__, err, contended);
          }
       } else {
-         value = 0;
-
-         MXRecLockAcquire(&lock->recursiveLock, &value);
+         contended = MXRecLockAcquire(&lock->recursiveLock);
       }
 
-      /*
-       * The statistics are not atomically safe so protect them when necessary.
-       */
+      if (LIKELY(stats != NULL)) {
+         MXUserHisto *histo;
+         VmTimeType value = Hostinfo_SystemTimerNS() - start;
 
-      if (forRead && lock->useNative) {
-         MXRecLockAcquire(&lock->recursiveLock,
-                          NULL);                 // non-stats
-      }
+         /*
+          * The statistics are not atomically safe so protect them when
+          * necessary.
+          */
 
-      MXUserAcquisitionSample(&stats->acquisitionStats,
-                              TRUE,
-                              value != 0,  // True when contended
-                              value);
+         if (forRead && lock->useNative) {
+            MXRecLockAcquire(&lock->recursiveLock);
+         }
 
-      histo = Atomic_ReadPtr(&stats->acquisitionHisto);
+         MXUserAcquisitionSample(&stats->acquisitionStats, TRUE, contended,
+                                 value);
 
-      if (UNLIKELY(histo != NULL)) {
-         MXUserHistoSample(histo, value, GetReturnAddress());
-      }
+         histo = Atomic_ReadPtr(&stats->acquisitionHisto);
 
-      if (forRead && lock->useNative) {
-         MXRecLockRelease(&lock->recursiveLock);
-      }
+         if (UNLIKELY(histo != NULL)) {
+            MXUserHistoSample(histo, value, GetReturnAddress());
+         }
+
+         if (forRead && lock->useNative) {
+            MXRecLockRelease(&lock->recursiveLock);
+         }
 
-      myContext->holdStart = Hostinfo_SystemTimerNS();
+         myContext->holdStart = Hostinfo_SystemTimerNS();
+      }
    } else {
       if (LIKELY(lock->useNative)) {
          int err = 0;
@@ -778,8 +795,7 @@ MXUserAcquisition(MXUserRWLock *lock,  // IN/OUT:
                                __FUNCTION__, err);
          }
       } else {
-         MXRecLockAcquire(&lock->recursiveLock,
-                          NULL);                 // non-stats
+         MXRecLockAcquire(&lock->recursiveLock);
       }
    }
 
@@ -904,7 +920,6 @@ MXUser_IsCurThreadHoldingRWLock(MXUserRWLock *lock,  // IN:
 void
 MXUser_ReleaseRWLock(MXUserRWLock *lock)  // IN/OUT:
 {
-   MXUserStats *stats;
    HolderContext *myContext;
 
    ASSERT(lock);
@@ -912,32 +927,33 @@ MXUser_ReleaseRWLock(MXUserRWLock *lock)  // IN/OUT:
 
    myContext = MXUserGetHolderContext(lock);
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   if (vmx86_stats) {
+      MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-   if (stats) {
-      VmTimeType duration = Hostinfo_SystemTimerNS() - myContext->holdStart;
-      MXUserHisto *histo;
+      if (LIKELY(stats != NULL)) {
+         MXUserHisto *histo;
+         VmTimeType duration = Hostinfo_SystemTimerNS() - myContext->holdStart;
 
-      /*
-       * The statistics are not always atomically safe so protect them
-       * when necessary
-       */
+         /*
+          * The statistics are not always atomically safe so protect them
+          * when necessary
+          */
 
-      if ((myContext->state == RW_LOCKED_FOR_READ) && lock->useNative) {
-         MXRecLockAcquire(&lock->recursiveLock,
-                          NULL);                 // non-stats
-      }
+         if ((myContext->state == RW_LOCKED_FOR_READ) && lock->useNative) {
+            MXRecLockAcquire(&lock->recursiveLock);
+         }
 
-      MXUserBasicStatsSample(&stats->heldStats, duration);
+         MXUserBasicStatsSample(&stats->heldStats, duration);
 
-      histo = Atomic_ReadPtr(&stats->heldHisto);
+         histo = Atomic_ReadPtr(&stats->heldHisto);
 
-      if (UNLIKELY(histo != NULL)) {
-         MXUserHistoSample(histo, duration, GetReturnAddress());
-      }
+         if (UNLIKELY(histo != NULL)) {
+            MXUserHistoSample(histo, duration, GetReturnAddress());
+         }
 
-      if ((myContext->state == RW_LOCKED_FOR_READ) && lock->useNative) {
-         MXRecLockRelease(&lock->recursiveLock);
+         if ((myContext->state == RW_LOCKED_FOR_READ) && lock->useNative) {
+            MXRecLockRelease(&lock->recursiveLock);
+         }
       }
    }
 
@@ -999,18 +1015,17 @@ MXUser_CreateSingletonRWLock(Atomic_Ptr *lockStorage,  // IN/OUT:
 
    ASSERT(lockStorage);
 
-   lock = (MXUserRWLock *) Atomic_ReadPtr(lockStorage);
+   lock = Atomic_ReadPtr(lockStorage);
 
    if (UNLIKELY(lock == NULL)) {
       MXUserRWLock *newLock = MXUser_CreateRWLock(name, rank);
 
-      lock = (MXUserRWLock *) Atomic_ReadIfEqualWritePtr(lockStorage, NULL,
-                                                         (void *) newLock);
+      lock = Atomic_ReadIfEqualWritePtr(lockStorage, NULL, (void *) newLock);
 
       if (lock) {
          MXUser_DestroyRWLock(newLock);
       } else {
-         lock = (MXUserRWLock *) Atomic_ReadPtr(lockStorage);
+         lock = Atomic_ReadPtr(lockStorage);
       }
    }
 

diff --git a/open-vm-tools/lib/lock/ulRec.c b/open-vm-tools/lib/lock/ulRec.c
index dddc19cb638cb7d6cf4ac1edd5e4da71f590c155..e5d125b82c54ec80b9aa74cddea568b1336963a2 100644 (file)
--- a/open-vm-tools/lib/lock/ulRec.c
+++ b/open-vm-tools/lib/lock/ulRec.c
@@ -76,7 +76,7 @@ static void
 MXUserStatsActionRec(MXUserHeader *header)  // IN:
 {
    MXUserRecLock *lock = (MXUserRecLock *) header;
-   MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+   MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
    if (stats) {
       Bool isHot;
@@ -156,45 +156,54 @@ MXUser_ControlRecLock(MXUserRecLock *lock,  // IN/OUT:
 
    switch (command) {
    case MXUSER_CONTROL_ACQUISITION_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats && (lock->vmmLock == NULL)) {
-         va_list a;
-         uint32 decades;
-         uint64 minValue;
+         if ((stats != NULL) && (lock->vmmLock == NULL)) {
+            va_list a;
+            uint32 decades;
+            uint64 minValue;
 
-         va_start(a, command);
-         minValue = va_arg(a, uint64);
-         decades = va_arg(a, uint32);
-         va_end(a);
+            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);
+            MXUserForceHisto(&stats->acquisitionHisto,
+                             MXUSER_STAT_CLASS_ACQUISITION, minValue, decades);
 
-         result = TRUE;
+            result = TRUE;
+         } else {
+            result = FALSE;
+         }
       } else {
          result = FALSE;
       }
+
       break;
    }
 
    case MXUSER_CONTROL_HELD_HISTO: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats && (lock->vmmLock == NULL)) {
-         va_list a;
-         uint32 decades;
-         uint64 minValue;
+         if ((stats != NULL) && (lock->vmmLock == NULL)) {
+            va_list a;
+            uint32 decades;
+            uint32 minValue;
 
-         va_start(a, command);
-         minValue = va_arg(a, uint64);
-         decades = va_arg(a, uint32);
-         va_end(a);
+            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;
+            MXUserForceHisto(&stats->heldHisto, MXUSER_STAT_CLASS_HELD,
+                             minValue, decades);
+
+            result = TRUE;
+         } else {
+            result = FALSE;
+         }
       } else {
          result = FALSE;
       }
@@ -203,9 +212,8 @@ MXUser_ControlRecLock(MXUserRecLock *lock,  // IN/OUT:
    }
 
    case MXUSER_CONTROL_ENABLE_STATS: {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
-
-      if (LIKELY(stats == NULL)) {
+      if (vmx86_stats) {
+         MXUserStats *stats;
          MXUserStats *before;
 
          stats = Util_SafeCalloc(1, sizeof(*stats));
@@ -213,18 +221,20 @@ MXUser_ControlRecLock(MXUserRecLock *lock,  // IN/OUT:
          MXUserAcquisitionStatsSetUp(&stats->acquisitionStats);
          MXUserBasicStatsSetUp(&stats->heldStats, MXUSER_STAT_CLASS_HELD);
 
-         before = (MXUserStats *) Atomic_ReadIfEqualWritePtr(&lock->statsMem,
-                                                             NULL,
-                                                             (void *) stats);
+         before = Atomic_ReadIfEqualWritePtr(&lock->statsMem, NULL,
+                                             (void *) stats);
 
          if (before) {
             free(stats);
          }
 
          lock->header.statsFunc = MXUserStatsActionRec;
+
+         result = TRUE;
+      } else {
+         result = FALSE;
       }
 
-      result = TRUE;
       break;
    }
 
@@ -261,7 +271,7 @@ MXUserDumpRecLock(MXUserHeader *header)  // IN:
 {
    MXUserRecLock *lock = (MXUserRecLock *) header;
 
-   Warning("%s: Recursive lock @ 0x%p\n", __FUNCTION__, lock);
+   Warning("%s: Recursive lock @ %p\n", __FUNCTION__, lock);
 
    Warning("\tsignature 0x%X\n", lock->header.signature);
    Warning("\tname %s\n", lock->header.name);
@@ -272,10 +282,10 @@ MXUserDumpRecLock(MXUserHeader *header)  // IN:
    if (lock->vmmLock == NULL) {
       Warning("\tcount %d\n", MXRecLockCount(&lock->recursiveLock));
 
-      Warning("\taddress of owner data 0x%p\n",
+      Warning("\taddress of owner data %p\n",
               &lock->recursiveLock.nativeThreadID);
    } else {
-      Warning("\tvmmLock 0x%p\n", lock->vmmLock);
+      Warning("\tvmmLock %p\n", lock->vmmLock);
    }
 }
 
@@ -305,6 +315,7 @@ MXUserCreateRecLock(const char *userName,  // IN:
                     MX_Rank rank,          // IN:
                     Bool beSilent)         // IN:
 {
+   Bool doStats;
    char *properName;
    MXUserRecLock *lock;
 
@@ -332,11 +343,17 @@ MXUserCreateRecLock(const char *userName,  // IN:
    lock->header.serialNumber = MXUserAllocSerialNumber();
    lock->header.dumpFunc = MXUserDumpRecLock;
 
-   if (beSilent || !MXUserStatsEnabled()) {
-      lock->header.statsFunc = NULL;
-      Atomic_WritePtr(&lock->statsMem, NULL);
+   if (beSilent) {
+      doStats = FALSE;
    } else {
+      doStats = vmx86_stats && MXUserStatsEnabled();
+   }
+
+   if (doStats) {
       MXUser_ControlRecLock(lock, MXUSER_CONTROL_ENABLE_STATS);
+   } else {
+      lock->header.statsFunc = NULL;
+      Atomic_WritePtr(&lock->statsMem, NULL);
    }
 
    MXUserAddToList(&lock->header);
@@ -429,8 +446,6 @@ MXUserCondDestroyRecLock(MXUserRecLock *lock)  // IN:
 
    if (Atomic_FetchAndDec(&lock->refCount) == 1) {
       if (lock->vmmLock == NULL) {
-         MXUserStats *stats;
-
          if (MXRecLockCount(&lock->recursiveLock) > 0) {
             MXUserDumpAndPanic(&lock->header,
                                "%s: Destroy of an acquired recursive lock\n",
@@ -441,15 +456,18 @@ MXUserCondDestroyRecLock(MXUserRecLock *lock)  // IN:
 
          MXUserRemoveFromList(&lock->header);
 
-         stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+         if (vmx86_stats) {
+            MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-         if (stats) {
-            MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
-            MXUserBasicStatsTearDown(&stats->heldStats);
-            MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
-            MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+            if (LIKELY(stats != NULL)) {
+               MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
+               MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
 
-            free(stats);
+               MXUserBasicStatsTearDown(&stats->heldStats);
+               MXUserHistoTearDown(Atomic_ReadPtr(&stats->heldHisto));
+
+               free(stats);
+            }
          }
       }
 
@@ -499,35 +517,39 @@ MXUser_AcquireRecLock(MXUserRecLock *lock)  // IN/OUT:
       ASSERT(MXUserMX_LockRec);
       (*MXUserMX_LockRec)(lock->vmmLock);
    } else {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
-
       /* Rank checking is only done on the first acquisition */
       MXUserAcquisitionTracking(&lock->header, TRUE);
 
-      if (stats) {
-         VmTimeType value = 0;
+      if (vmx86_stats) {
+         Bool contended;
+         VmTimeType start = 0;
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-         MXRecLockAcquire(&lock->recursiveLock, &value);
+         if (LIKELY(stats != NULL)) {
+            start = Hostinfo_SystemTimerNS();
+         }
 
-         if (MXRecLockCount(&lock->recursiveLock) == 1) {
-            MXUserHisto *histo;
+         contended = MXRecLockAcquire(&lock->recursiveLock);
 
-            MXUserAcquisitionSample(&stats->acquisitionStats,
-                                    TRUE,
-                                    value != 0,  // True if contended
-                                    value);
+         if (LIKELY(stats != NULL)) {
+            if (MXRecLockCount(&lock->recursiveLock) == 1) {
+               MXUserHisto *histo;
+               VmTimeType value = Hostinfo_SystemTimerNS() - start;
 
-            histo = Atomic_ReadPtr(&stats->acquisitionHisto);
+               MXUserAcquisitionSample(&stats->acquisitionStats, TRUE,
+                                       contended, value);
 
-            if (UNLIKELY(histo != NULL)) {
-               MXUserHistoSample(histo, value, GetReturnAddress());
-            }
+               histo = Atomic_ReadPtr(&stats->acquisitionHisto);
 
-            stats->holdStart = Hostinfo_SystemTimerNS();
+               if (UNLIKELY(histo != NULL)) {
+                  MXUserHistoSample(histo, value, GetReturnAddress());
+               }
+
+               stats->holdStart = Hostinfo_SystemTimerNS();
+            }
          }
       } else {
-         MXRecLockAcquire(&lock->recursiveLock,
-                          NULL);                 /* non-stats */
+         MXRecLockAcquire(&lock->recursiveLock);
       }
    }
 
@@ -565,17 +587,19 @@ MXUser_ReleaseRecLock(MXUserRecLock *lock)  // IN/OUT:
       ASSERT(MXUserMX_UnlockRec);
       (*MXUserMX_UnlockRec)(lock->vmmLock);
    } else {
-      MXUserStats *stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         if (MXRecLockCount(&lock->recursiveLock) == 1) {
-            VmTimeType value = Hostinfo_SystemTimerNS() - stats->holdStart;
-            MXUserHisto *histo = Atomic_ReadPtr(&stats->heldHisto);
+         if (LIKELY(stats != NULL)) {
+            if (MXRecLockCount(&lock->recursiveLock) == 1) {
+               VmTimeType value = Hostinfo_SystemTimerNS() - stats->holdStart;
+               MXUserHisto *histo = Atomic_ReadPtr(&stats->heldHisto);
 
-            MXUserBasicStatsSample(&stats->heldStats, value);
+               MXUserBasicStatsSample(&stats->heldStats, value);
 
-            if (UNLIKELY(histo != NULL)) {
-               MXUserHistoSample(histo, value, GetReturnAddress());
+               if (UNLIKELY(histo != NULL)) {
+                  MXUserHistoSample(histo, value, GetReturnAddress());
+               }
             }
          }
       }
@@ -641,8 +665,6 @@ MXUser_TryAcquireRecLock(MXUserRecLock *lock)  // IN/OUT:
       ASSERT(MXUserMX_TryLockRec);
       success = (*MXUserMX_TryLockRec)(lock->vmmLock);
    } else {
-      MXUserStats *stats;
-
       if (MXUserTryAcquireFail(lock->header.name)) {
          success = FALSE;
          goto bail;
@@ -654,11 +676,13 @@ MXUser_TryAcquireRecLock(MXUserRecLock *lock)  // IN/OUT:
          MXUserAcquisitionTracking(&lock->header, FALSE);
       }
 
-      stats = (MXUserStats *) Atomic_ReadPtr(&lock->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&lock->statsMem);
 
-      if (stats) {
-         MXUserAcquisitionSample(&stats->acquisitionStats, success,
-                                 !success, 0ULL);
+         if (LIKELY(stats != NULL)) {
+            MXUserAcquisitionSample(&stats->acquisitionStats, success,
+                                    !success, 0ULL);
+         }
       }
    }
 
@@ -742,18 +766,17 @@ MXUser_CreateSingletonRecLock(Atomic_Ptr *lockStorage,  // IN/OUT:
 
    ASSERT(lockStorage);
 
-   lock = (MXUserRecLock *) Atomic_ReadPtr(lockStorage);
+   lock = Atomic_ReadPtr(lockStorage);
 
    if (UNLIKELY(lock == NULL)) {
       MXUserRecLock *newLock = MXUser_CreateRecLock(name, rank);
 
-      lock = (MXUserRecLock *) Atomic_ReadIfEqualWritePtr(lockStorage, NULL,
-                                                          (void *) newLock);
+      lock = Atomic_ReadIfEqualWritePtr(lockStorage, NULL, (void *) newLock);
 
       if (lock) {
          MXUser_DestroyRecLock(newLock);
       } else {
-         lock = (MXUserRecLock *) Atomic_ReadPtr(lockStorage);
+         lock = Atomic_ReadPtr(lockStorage);
       }
    }
 

diff --git a/open-vm-tools/lib/lock/ulSema.c b/open-vm-tools/lib/lock/ulSema.c
index 6915bb444fbc1b5048dd1f40cc75219ead25f7ad..4cd87f1e13303ba464322f162807e3c8a0c1b1ad 100644 (file)
--- a/open-vm-tools/lib/lock/ulSema.c
+++ b/open-vm-tools/lib/lock/ulSema.c
@@ -463,7 +463,7 @@ MXUserDumpSemaphore(MXUserHeader *header)  // IN:
 {
    MXUserSemaphore *sema = (MXUserSemaphore *) header;
 
-   Warning("%s: semaphore @ 0x%p\n", __FUNCTION__, sema);
+   Warning("%s: semaphore @ %p\n", __FUNCTION__, sema);
 
    Warning("\tsignature 0x%X\n", sema->header.signature);
    Warning("\tname %s\n", sema->header.name);
@@ -471,7 +471,7 @@ MXUserDumpSemaphore(MXUserHeader *header)  // IN:
    Warning("\tserial number %u\n", sema->header.serialNumber);
 
    Warning("\treference count %u\n", Atomic_Read(&sema->activeUserCount));
-   Warning("\taddress of native semaphore 0x%p\n", &sema->nativeSemaphore);
+   Warning("\taddress of native semaphore %p\n", &sema->nativeSemaphore);
 }
 
 
@@ -511,6 +511,7 @@ MXUser_CreateSemaphore(const char *userName,  // IN:
    }
 
    if (LIKELY(MXUserInit(&sema->nativeSemaphore) == 0)) {
+      Bool doStats;
       MXUserStats *stats;
 
       sema->header.signature = MXUserGetSignature(MXUSER_TYPE_SEMA);
@@ -519,7 +520,13 @@ MXUser_CreateSemaphore(const char *userName,  // IN:
       sema->header.serialNumber = MXUserAllocSerialNumber();
       sema->header.dumpFunc = MXUserDumpSemaphore;
 
-      if (MXUserStatsEnabled()) {
+      if (vmx86_stats) {
+         doStats = MXUserStatsEnabled();
+      } else {
+         doStats = FALSE;
+      }
+
+      if (doStats) {
          sema->header.statsFunc = MXUserStatsActionSema;
 
          stats = Util_SafeCalloc(1, sizeof(*stats));
@@ -564,7 +571,6 @@ MXUser_DestroySemaphore(MXUserSemaphore *sema)  // IN:
 {
    if (LIKELY(sema != NULL)) {
       int err;
-      MXUserStats *stats;
 
       MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
 
@@ -574,6 +580,8 @@ MXUser_DestroySemaphore(MXUserSemaphore *sema)  // IN:
                             __FUNCTION__);
       }
 
+      sema->header.signature = 0;  // just in case...
+
       err = MXUserDestroy(&sema->nativeSemaphore);
 
       if (UNLIKELY(err != 0)) {
@@ -581,17 +589,17 @@ MXUser_DestroySemaphore(MXUserSemaphore *sema)  // IN:
                             __FUNCTION__, err);
       }
 
-      sema->header.signature = 0;  // just in case...
-
       MXUserRemoveFromList(&sema->header);
 
-      stats = (MXUserStats *) Atomic_ReadPtr(&sema->statsMem);
+      if (vmx86_stats) {
+         MXUserStats *stats = Atomic_ReadPtr(&sema->statsMem);
 
-      if (stats) {
-         MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
-         MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
+         if (LIKELY(stats != NULL)) {
+            MXUserAcquisitionStatsTearDown(&stats->acquisitionStats);
+            MXUserHistoTearDown(Atomic_ReadPtr(&stats->acquisitionHisto));
 
-         free(stats);
+            free(stats);
+         }
       }
 
       free(sema->header.name);
@@ -623,7 +631,6 @@ void
 MXUser_DownSemaphore(MXUserSemaphore *sema)  // IN/OUT:
 {
    int err;
-   MXUserStats *stats;
 
    ASSERT(sema);
    MXUserValidateHeader(&sema->header, MXUSER_TYPE_SEMA);
@@ -632,11 +639,14 @@ MXUser_DownSemaphore(MXUserSemaphore *sema)  // IN/OUT:
 
    MXUserAcquisitionTracking(&sema->header, TRUE);  // rank checking
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&sema->statsMem);
-
-   if (stats) { 
+   if (vmx86_stats) {
+      VmTimeType start = 0;
       Bool tryDownSuccess = FALSE;
-      VmTimeType begin = Hostinfo_SystemTimerNS();
+      MXUserStats *stats = Atomic_ReadPtr(&sema->statsMem);
+
+      if (LIKELY(stats != NULL)) {
+         start = Hostinfo_SystemTimerNS();
+      }
 
       err = MXUserTryDown(&sema->nativeSemaphore, &tryDownSuccess);
 
@@ -644,19 +654,19 @@ MXUser_DownSemaphore(MXUserSemaphore *sema)  // IN/OUT:
          if (!tryDownSuccess) {
             err = MXUserDown(&sema->nativeSemaphore);
          }
+      }
 
-         if (LIKELY(err == 0)) {
-            MXUserHisto *histo;
-            VmTimeType value = Hostinfo_SystemTimerNS() - begin;
+      if (LIKELY((err == 0) && (stats != NULL))) {
+         MXUserHisto *histo;
+         VmTimeType value = Hostinfo_SystemTimerNS() - start;
 
-            MXUserAcquisitionSample(&stats->acquisitionStats, TRUE,
-                                    !tryDownSuccess, value);
+         MXUserAcquisitionSample(&stats->acquisitionStats, TRUE,
+                                 !tryDownSuccess, value);
 
-            histo = Atomic_ReadPtr(&stats->acquisitionHisto);
+         histo = Atomic_ReadPtr(&stats->acquisitionHisto);
 
-            if (UNLIKELY(histo != NULL)) {
-               MXUserHistoSample(histo, value, GetReturnAddress());
-            }
+         if (UNLIKELY(histo != NULL)) {
+            MXUserHistoSample(histo, value, GetReturnAddress());
          }
       }
    } else {
@@ -698,7 +708,6 @@ MXUser_TimedDownSemaphore(MXUserSemaphore *sema,  // IN/OUT:
                           uint32 msecWait)        // IN:
 {
    int err;
-   MXUserStats *stats;
    Bool downOccurred = FALSE;
 
    ASSERT(sema);
@@ -708,11 +717,14 @@ MXUser_TimedDownSemaphore(MXUserSemaphore *sema,  // IN/OUT:
 
    MXUserAcquisitionTracking(&sema->header, TRUE);  // rank checking
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&sema->statsMem);
-
-   if (stats) { 
+   if (vmx86_stats) {
+      VmTimeType start = 0;
       Bool tryDownSuccess = FALSE;
-      VmTimeType begin = Hostinfo_SystemTimerNS();
+      MXUserStats *stats = Atomic_ReadPtr(&sema->statsMem);
+
+      if (LIKELY(stats != NULL)) { 
+         start = Hostinfo_SystemTimerNS();
+      }
 
       err = MXUserTryDown(&sema->nativeSemaphore, &tryDownSuccess);
 
@@ -723,19 +735,19 @@ MXUser_TimedDownSemaphore(MXUserSemaphore *sema,  // IN/OUT:
             err = MXUserTimedDown(&sema->nativeSemaphore, msecWait,
                                   &downOccurred);
          }
+      }
 
-         if (LIKELY(err == 0)) {
-            VmTimeType value = Hostinfo_SystemTimerNS() - begin;
+      if (LIKELY((err == 0) && (stats != NULL))) {
+         VmTimeType value = Hostinfo_SystemTimerNS() - start;
 
-            MXUserAcquisitionSample(&stats->acquisitionStats, downOccurred,
-                                    !tryDownSuccess, value);
+         MXUserAcquisitionSample(&stats->acquisitionStats, downOccurred,
+                                 !tryDownSuccess, value);
 
-            if (downOccurred) {
-               MXUserHisto *histo = Atomic_ReadPtr(&stats->acquisitionHisto);
+         if (downOccurred) {
+            MXUserHisto *histo = Atomic_ReadPtr(&stats->acquisitionHisto);
 
-               if (UNLIKELY(histo != NULL)) {
-                  MXUserHistoSample(histo, value, GetReturnAddress());
-               }
+            if (UNLIKELY(histo != NULL)) {
+               MXUserHistoSample(histo, value, GetReturnAddress());
             }
          }
       }
@@ -782,7 +794,6 @@ Bool
 MXUser_TryDownSemaphore(MXUserSemaphore *sema)  // IN/OUT:
 {
    int err;
-   MXUserStats *stats;
    Bool downOccurred = FALSE;
 
    ASSERT(sema);
@@ -797,11 +808,13 @@ MXUser_TryDownSemaphore(MXUserSemaphore *sema)  // IN/OUT:
                          __FUNCTION__, err);
    }
 
-   stats = (MXUserStats *) Atomic_ReadPtr(&sema->statsMem);
+   if (vmx86_stats) {
+      MXUserStats *stats = Atomic_ReadPtr(&sema->statsMem);
 
-   if (stats) {
-      MXUserAcquisitionSample(&stats->acquisitionStats, downOccurred,
-                              !downOccurred, 0ULL);
+      if (LIKELY(stats != NULL)) {
+         MXUserAcquisitionSample(&stats->acquisitionStats, downOccurred,
+                                 !downOccurred, 0ULL);
+      }
    }
 
    Atomic_Dec(&sema->activeUserCount);
@@ -877,19 +890,17 @@ MXUser_CreateSingletonSemaphore(Atomic_Ptr *semaStorage,  // IN/OUT:
 
    ASSERT(semaStorage);
 
-   sema = (MXUserSemaphore *) Atomic_ReadPtr(semaStorage);
+   sema = Atomic_ReadPtr(semaStorage);
 
    if (UNLIKELY(sema == NULL)) {
       MXUserSemaphore *newSema = MXUser_CreateSemaphore(name, rank);
 
-      sema = (MXUserSemaphore *) Atomic_ReadIfEqualWritePtr(semaStorage,
-                                                            NULL,
-                                                            (void *) newSema);
+      sema = Atomic_ReadIfEqualWritePtr(semaStorage, NULL, (void *) newSema);
 
       if (sema) {
          MXUser_DestroySemaphore(newSema);
       } else {
-         sema = (MXUserSemaphore *) Atomic_ReadPtr(semaStorage);
+         sema = Atomic_ReadPtr(semaStorage);
       }
    }
 

diff --git a/open-vm-tools/lib/lock/ulStats.c b/open-vm-tools/lib/lock/ulStats.c
index c8e39893faae89399ca0c6867a53cb4f621306e7..2bc66e1082ec0a95608fe3c4114fa5a614016659 100644 (file)
--- a/open-vm-tools/lib/lock/ulStats.c
+++ b/open-vm-tools/lib/lock/ulStats.c
@@ -87,8 +87,7 @@ MXUserAddToList(MXUserHeader *header)  // IN:
 
    /* Tolerate a failure. This is too low down to log */
    if (listLock) {
-      MXRecLockAcquire(listLock,
-                       NULL);     // non-stats
+      MXRecLockAcquire(listLock);
       LIST_QUEUE(&header->item, &mxUserLockList);
       MXRecLockRelease(listLock);
    }
@@ -118,8 +117,7 @@ MXUserRemoveFromList(MXUserHeader *header)  // IN:
 
    /* Tolerate a failure. This is too low down to log */
    if (listLock) {
-      MXRecLockAcquire(listLock,
-                       NULL);     // non-stats
+      MXRecLockAcquire(listLock);
       LIST_DEL(&header->item, &mxUserLockList);
       MXRecLockRelease(listLock);
    }