From: VMware, Inc <> Date: Thu, 17 Dec 2009 23:06:40 +0000 (-0800) Subject: Internal branch sync. Included in this change: X-Git-Tag: 2009.12.16-217847~3 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e1f1ddd3e381bd1405b4a1922c4de604eadb94af;p=thirdparty%2Fopen-vm-tools.git Internal branch sync. Included in this change: . lib/lock: minor performance optimizations, cleanups and other improvements. . finish removal of lib/sync. . Changes in shared code that don't affect open-vm-tools functionality. Signed-off-by: Marcelo Vanzin --- diff --git a/open-vm-tools/configure.ac b/open-vm-tools/configure.ac index f6456c646..a89f376b6 100644 --- a/open-vm-tools/configure.ac +++ b/open-vm-tools/configure.ac @@ -1247,7 +1247,6 @@ AC_CONFIG_FILES([ \ lib/slashProc/Makefile \ lib/string/Makefile \ lib/stubs/Makefile \ - lib/sync/Makefile \ lib/syncDriver/Makefile \ lib/system/Makefile \ lib/unicode/Makefile \ diff --git a/open-vm-tools/lib/Makefile.am b/open-vm-tools/lib/Makefile.am index 974c77cf3..1ab47c20f 100644 --- a/open-vm-tools/lib/Makefile.am +++ b/open-vm-tools/lib/Makefile.am @@ -76,7 +76,6 @@ endif SUBDIRS += SLPv2Parser SUBDIRS += string SUBDIRS += stubs -SUBDIRS += sync SUBDIRS += syncDriver SUBDIRS += system SUBDIRS += unicode diff --git a/open-vm-tools/lib/file/fileLockPosix.c b/open-vm-tools/lib/file/fileLockPosix.c index f3542ac2d..45cddb64a 100644 --- a/open-vm-tools/lib/file/fileLockPosix.c +++ b/open-vm-tools/lib/file/fileLockPosix.c @@ -237,9 +237,10 @@ FileLockGetPid(void) * For a UserWorld, we want to get this cartel's proxy's cos pid. */ if (fileLockOptions.userWorld) { - int pid = 0; + int pid, err; - VMKernel_GetLockPid(&pid); + err = VMKernel_GetLockPid(&pid); + ASSERT_NOT_IMPLEMENTED(err == 0); return pid; } diff --git a/open-vm-tools/lib/include/syncMutex.h b/open-vm-tools/lib/include/syncMutex.h deleted file mode 100644 index d53c7b582..000000000 --- a/open-vm-tools/lib/include/syncMutex.h +++ /dev/null @@ -1,74 +0,0 @@ -/********************************************************* - * Copyright (C) 1998 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 - * by the Free Software Foundation version 2.1 and no later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - *********************************************************/ - -/* - * syncMutex.h -- - * - * Implements a platform independent mutex - */ - -#ifndef _SYNC_MUTEX_H_ -#define _SYNC_MUTEX_H_ - -#define INCLUDE_ALLOW_USERLEVEL -#define INCLUDE_ALLOW_VMCORE -#include "includeCheck.h" - -#if !defined(_WIN32) -#if defined(N_PLAT_NLM) -#include -#include -#include -#include -#else -#include -#endif -#endif - -#include "syncWaitQ.h" -#include "vm_atomic.h" - -/* - * SyncMutex -- - */ - -typedef struct SyncMutex { -#if defined(N_PLAT_NLM) - LONG semaphoreHandle; -#else - SyncWaitQ wq; - - /* Is the mutex unlocked? --hpreg */ - Atomic_uint32 unlocked; -#if !defined(_WIN32) - pthread_mutex_t _mutex; -#endif -#endif -} SyncMutex; - -Bool SyncMutex_Init(SyncMutex *that, - char const *path); -void SyncMutex_Destroy(SyncMutex *that); -Bool SyncMutex_Lock(SyncMutex *that); -Bool SyncMutex_Unlock(SyncMutex *that); - -#if !defined(N_PLAT_NLM) -Bool SyncMutex_Trylock(SyncMutex *that); -#endif - -#endif // #ifndef _SYNC_MUTEX_H_ diff --git a/open-vm-tools/lib/include/syncWaitQ.h b/open-vm-tools/lib/include/syncWaitQ.h deleted file mode 100644 index c78a110e3..000000000 --- a/open-vm-tools/lib/include/syncWaitQ.h +++ /dev/null @@ -1,127 +0,0 @@ -/********************************************************* - * Copyright (C) 1998 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 - * by the Free Software Foundation version 2.1 and no later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - *********************************************************/ - -/* - * syncWaitQ.h -- - * - * Implements a platform independent wait queue - */ - -#ifndef _SYNC_WAITQ_H_ -#define _SYNC_WAITQ_H_ - -#define INCLUDE_ALLOW_USERLEVEL -#define INCLUDE_ALLOW_VMCORE -#include "includeCheck.h" - -#if __APPLE__ -#include -#endif - -#include "vm_atomic.h" - -/* - * syncWaitQ.h -- - * - * The semantics of this wait queue primitive are as follows: - * - * o Client threads can add themselves to a waitqueue object and - * receive a pollable handle via a call to SyncWaitQ_Add - * - * o When the waitqueue is woken up, each handle that was - * previously obtained via a call to SyncWaitQ_Add becomes - * signaled and remains so until it is removed via a call to - * SyncWaitQ_Remove. Any calls to SyncWaitQ_Add, after the queue - * has been woken up, will return fresh, unsignaled handles. - * - * For more information please refer to comments in the - * respective syncWaitQ{host}.c files - * - * -- Ticho. - * - */ - -/* - * SyncWaitQ -- - * - * Memory buffer that stores information about an wait queue - * object. - * - * In the case of named queues, this structure can be allocated - * on shared memory and shared between multiple processes. - * - * This structure, however, cannot be memcpy()-ed - */ - - -typedef struct SyncWaitQ { - /* - * Common members used for both named and unnamed objects - */ - - // Whether the waitqueue has been initialized; - Bool initialized; -#ifndef _WIN32 - // Whether queue uses eventfd or pipe - Bool usesEventFd; -#endif - // Whether there are any waiters on this queue - Atomic_uint32 waiters; - // A unique sequence number of the queue - Atomic_uint64 seq; - - /* - * Members used in case of named objects - */ - - // Name of the waitqueue object (FIFO path on Linux or Event name on Win32) - char *pathName; - - /* - * The following handles are only used only in the case of - * anonymous pipes. - * - * On Win32 the readHandle is a handle to an event object - * - * On Posix the rwHandles are the read and write ends of an anonymous pipe, - * or eventfd handle. - * - * -- Ticho - */ - -#ifdef _WIN32 - Atomic_uint64 readHandle; -#else - union { - Atomic_uint64 pipeHandles64; - Atomic_uint32 pipeHandles[2]; - Atomic_uint32 eventHandle; - } u; -# if __APPLE__ - pthread_mutex_t mutex; -# endif -#endif // #ifdef _WIN32 -} SyncWaitQ; - -Bool SyncWaitQ_Init(SyncWaitQ *that, char const *path); -void SyncWaitQ_Destroy(SyncWaitQ *that); -PollDevHandle SyncWaitQ_Add(SyncWaitQ *that); -Bool SyncWaitQ_Remove(SyncWaitQ *that, PollDevHandle fd); -Bool SyncWaitQ_WakeUp(SyncWaitQ *that); - -#endif // #infdef _SYNC_WAITQ_H_ diff --git a/open-vm-tools/lib/lock/ul.c b/open-vm-tools/lib/lock/ul.c index 94e08a97c..81b7ad876 100644 --- a/open-vm-tools/lib/lock/ul.c +++ b/open-vm-tools/lib/lock/ul.c @@ -49,6 +49,7 @@ MXUserIDHack(void) MXUserThreadCurID = VThread_CurID; } + /* *----------------------------------------------------------------------------- * @@ -66,22 +67,14 @@ MXUserIDHack(void) */ void -MXUserDumpAndPanic(MXRecLock *lock, // IN: - const char *fmt, // IN: - ...) // IN: +MXUserDumpAndPanic(MXUserHeader *header, // IN: + const char *fmt, // IN: + ...) // IN: { char *msg; va_list ap; - Warning("%s: Lock @ %p\n", __FUNCTION__, lock); - Warning("%s: signature %X\n", __FUNCTION__, lock->lockHeader.lockSignature); - Warning("%s: count %u\n", __FUNCTION__, lock->lockHeader.lockCount); - Warning("%s: name %s\n", __FUNCTION__, lock->lockHeader.lockName); - Warning("%s: caller %p\n", __FUNCTION__, lock->lockHeader.lockCaller); - Warning("%s: rank %d\n", __FUNCTION__, lock->lockHeader.lockRank); - - Warning("%s: VThreadID %d\n", __FUNCTION__, - (int) lock->lockHeader.lockVThreadID); + (*header->lockDumper)(header); va_start(ap, fmt); msg = Str_SafeVasprintf(NULL, fmt, ap); diff --git a/open-vm-tools/lib/lock/ulAcquire.c b/open-vm-tools/lib/lock/ulAcquire.c index 68fed439c..02450d970 100644 --- a/open-vm-tools/lib/lock/ulAcquire.c +++ b/open-vm-tools/lib/lock/ulAcquire.c @@ -41,10 +41,12 @@ void MXUser_AcquireExclLock(MXUserExclLock *lock) // IN/OUT: { - MXRecLockAcquire(&lock->basic, MXGetThreadID(), GetReturnAddress()); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - if (MXRecLockCount(&lock->basic) > 1) { - MXUserDumpAndPanic(&lock->basic, + MXRecLockAcquire(&lock->lockRecursive, GetReturnAddress()); + + if (MXRecLockCount(&lock->lockRecursive) > 1) { + MXUserDumpAndPanic(&lock->lockHeader, "%s: Acquire on an acquired exclusive lock", __FUNCTION__); } @@ -56,8 +58,7 @@ MXUser_AcquireExclLock(MXUserExclLock *lock) // IN/OUT: * * MXUser_AcquireRecLock -- * - * An acquisition is made (lock is taken) on the specified recursive - * lock. + * An acquisition is made (lock is taken) on the specified recursive lock. * * Only the owner (thread) of a recursive lock may recurse on it. * @@ -73,5 +74,7 @@ MXUser_AcquireExclLock(MXUserExclLock *lock) // IN/OUT: void MXUser_AcquireRecLock(MXUserRecLock *lock) // IN/OUT: { - MXRecLockAcquire(&lock->basic, MXGetThreadID(), GetReturnAddress()); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + MXRecLockAcquire(&lock->lockRecursive, GetReturnAddress()); } diff --git a/open-vm-tools/lib/lock/ulCreate.c b/open-vm-tools/lib/lock/ulCreate.c index 820cb6cc3..6f95acca2 100644 --- a/open-vm-tools/lib/lock/ulCreate.c +++ b/open-vm-tools/lib/lock/ulCreate.c @@ -24,6 +24,42 @@ #include "ulInt.h" +/* + *----------------------------------------------------------------------------- + * + * MXUserDumpExclLock + * + * Dump an exclusive lock. + * + * Results: + * A dump. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +static void +MXUserDumpExclLock(MXUserHeader *header) // IN: +{ + MXUserExclLock *lock = (MXUserExclLock *) header; + + Warning("%s: Exclusive lock @ %p\n", __FUNCTION__, lock); + + Warning("\tsignature %X\n", lock->lockHeader.lockSignature); + Warning("\tname %s\n", lock->lockHeader.lockName); + Warning("\trank %d\n", lock->lockHeader.lockRank); + + Warning("\tcount %u\n", lock->lockRecursive.lockCount); + +#if defined(VMX86_DEBUG) + Warning("\tcaller %p\n", lock->lockRecursive.lockCaller); + Warning("\tVThreadID %d\n", (int) lock->lockRecursive.lockVThreadID); +#endif +} + + /* *----------------------------------------------------------------------------- * @@ -56,7 +92,12 @@ MXUser_CreateExclLock(const char *userName, // IN: properName = Util_SafeStrdup(userName); } - if (!MXRecLockInit(&lock->basic, properName, rank)) { + lock->lockHeader.lockName = properName; + lock->lockHeader.lockSignature = USERLOCK_SIGNATURE; + lock->lockHeader.lockRank = rank; + lock->lockHeader.lockDumper = MXUserDumpExclLock; + + if (!MXRecLockInit(&lock->lockRecursive)) { free(lock); free(properName); lock = NULL; @@ -66,6 +107,44 @@ MXUser_CreateExclLock(const char *userName, // IN: } +/* + *----------------------------------------------------------------------------- + * + * MXUserDumpRecLock + * + * Dump an recursive lock. + * + * Results: + * A dump. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +static void +MXUserDumpRecLock(MXUserHeader *header) // IN: +{ + MXUserRecLock *lock = (MXUserRecLock *) header; + + Warning("%s: Recursive lock @ %p\n", __FUNCTION__, lock); + + Warning("\tsignature %X\n", lock->lockHeader.lockSignature); + Warning("\tname %s\n", lock->lockHeader.lockName); + Warning("\trank %d\n", lock->lockHeader.lockRank); + + Warning("\tcount %u\n", lock->lockRecursive.lockCount); + +#if defined(VMX86_DEBUG) + Warning("\tcaller %p\n", lock->lockRecursive.lockCaller); + Warning("\tVThreadID %d\n", (int) lock->lockRecursive.lockVThreadID); +#endif + + Warning("\tlockVmm %p\n", lock->lockVmm); +} + + /* *----------------------------------------------------------------------------- * @@ -100,8 +179,13 @@ MXUser_CreateRecLock(const char *userName, // IN: properName = Util_SafeStrdup(userName); } - if (MXRecLockInit(&lock->basic, properName, rank)) { - lock->vmmLock = NULL; + lock->lockHeader.lockName = properName; + lock->lockHeader.lockSignature = USERLOCK_SIGNATURE; + lock->lockHeader.lockRank = rank; + lock->lockHeader.lockDumper = MXUserDumpRecLock; + + if (MXRecLockInit(&lock->lockRecursive)) { + lock->lockVmm = NULL; } else { free(lock); free(properName); diff --git a/open-vm-tools/lib/lock/ulDestroy.c b/open-vm-tools/lib/lock/ulDestroy.c index 73f52400d..c2b57799c 100644 --- a/open-vm-tools/lib/lock/ulDestroy.c +++ b/open-vm-tools/lib/lock/ulDestroy.c @@ -40,13 +40,16 @@ void MXUser_DestroyExclLock(MXUserExclLock *lock) // IN: { if (lock != NULL) { - if (MXRecLockCount(&lock->basic) > 0) { - MXUserDumpAndPanic(&lock->basic, + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + if (MXRecLockCount(&lock->lockRecursive) > 0) { + MXUserDumpAndPanic(&lock->lockHeader, "%s: Destroy of an acquired exclusive lock", __FUNCTION__); } - MXRecLockDestroy(&lock->basic); + MXRecLockDestroy(&lock->lockRecursive); + free((void *) lock->lockHeader.lockName); free(lock); } } @@ -72,13 +75,16 @@ void MXUser_DestroyRecLock(MXUserRecLock *lock) // IN: { if (lock != NULL) { - if (MXRecLockCount(&lock->basic) > 0) { - MXUserDumpAndPanic(&lock->basic, + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + if (MXRecLockCount(&lock->lockRecursive) > 0) { + MXUserDumpAndPanic(&lock->lockHeader, "%s: Destroy of an acquired recursive lock", __FUNCTION__); } - MXRecLockDestroy(&lock->basic); + MXRecLockDestroy(&lock->lockRecursive); + free((void *) lock->lockHeader.lockName); free(lock); } } diff --git a/open-vm-tools/lib/lock/ulInt.h b/open-vm-tools/lib/lock/ulInt.h index 876d0ab58..15fdd61f7 100644 --- a/open-vm-tools/lib/lock/ulInt.h +++ b/open-vm-tools/lib/lock/ulInt.h @@ -25,9 +25,11 @@ #include #include +#include #if defined(_WIN32) typedef DWORD MXThreadID; +#define MXUSER_INVALID_OWNER 0xFFFFFFFF #else #include #include @@ -41,45 +43,25 @@ typedef pthread_t MXThreadID; void MXUserIDHack(void); EXTERN VThreadID (*MXUserThreadCurID)(void); -/* - * MXUser lock header - all MXUser locks start with this - */ - -#define USERLOCK_SIGNATURE 0x75677976 // 'LOCK' in memory - -typedef struct { - const char *lockName; - uint32 lockSignature; - int lockCount; // May be Atomic someday (read-write locks?) - MXThreadID lockOwner; // Native thread ID - MX_Rank lockRank; - VThreadID lockVThreadID; - - /* - * Statistics data - * - * The fancy statistics that we will keep on each lock will live here too, - * attached via a pointer. - */ - - const void *lockCaller; // return address of lock acquisition routine -} MXUserHeader; - /* * A portable recursive lock. - * - * The MXUser simple and recursive locks are built on top of this. */ #define MXUSER_MAX_REC_DEPTH 16 typedef struct { - MXUserHeader lockHeader; - #if defined(_WIN32) - CRITICAL_SECTION lockObject; + CRITICAL_SECTION lockObject; // Native lock object #else - pthread_mutex_t lockObject; + pthread_mutex_t lockObject; // Native lock object +#endif + + int lockCount; // Acquisition count + MXThreadID lockOwner; // Native thread ID + +#if defined(VMX86_DEBUG) + VThreadID lockVThreadID; // VThreadID, when available + const void *lockCaller; // return address of acquisition routine #endif } MXRecLock; @@ -92,15 +74,14 @@ typedef struct { * - exclusive (non-recursive) locks catch the recursion and panic * rather than deadlock. * - * There are 7 environment specific primitives: + * There are 6 environment specific primitives: * - * MXGetThreadID (thread identification) - * MXRecLockIsOwner (is lock owned by caller?) - * MXRecLockObjectInit (initialize) - * MXRecLockDestroy (dispose after use) - * MXRecLockAcquire (lock) - * MXRecLockTryAcquire (conditional lock) - * MXRecLockRelease (unlock) + * MXRecLockObjectInit initialize native lock before use + * MXRecLockDestroy destroy lock after use + * MXRecLockIsOwner is lock owned by caller? + * MXRecLockAcquire lock + * MXRecLockTryAcquire conditional lock + * MXRecLockRelease unlock * * Windows has a native recursive lock, the CRITICAL_SECTION. POSIXen, * unfortunately, do not ensure access to such a facility. The recursive @@ -110,22 +91,6 @@ typedef struct { */ #if defined(_WIN32) -static INLINE MXThreadID -MXGetThreadID(void) -{ - return GetCurrentThreadId(); -} - - -static INLINE Bool -MXRecLockIsOwner(const MXRecLock *lock) // IN: -{ - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - return lock->lockHeader.lockOwner == MXGetThreadID(); -} - - static INLINE Bool MXRecLockObjectInit(CRITICAL_SECTION *lockObject) // IN/OUT: { @@ -138,60 +103,62 @@ MXRecLockObjectInit(CRITICAL_SECTION *lockObject) // IN/OUT: static INLINE void MXRecLockDestroy(MXRecLock *lock) // IN/OUT: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - DeleteCriticalSection(&lock->lockObject); - free((void *) lock->lockHeader.lockName); +} + + +static INLINE Bool +MXRecLockIsOwner(const MXRecLock *lock) // IN: +{ + return lock->lockOwner == GetCurrentThreadId(); } static INLINE void MXRecLockAcquire(MXRecLock *lock, // IN/OUT: - MXThreadID self, // IN: const void *location) // IN: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - EnterCriticalSection(&lock->lockObject); - ASSERT((lock->lockHeader.lockCount >= 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); + ASSERT((lock->lockCount >= 0) && (lock->lockCount < MXUSER_MAX_REC_DEPTH)); - if (lock->lockHeader.lockCount == 0) { - ASSERT(lock->lockHeader.lockVThreadID == VTHREAD_INVALID_ID); - lock->lockHeader.lockOwner = self; - lock->lockHeader.lockCaller = location; - lock->lockHeader.lockVThreadID = (*MXUserThreadCurID)(); + if (lock->lockCount == 0) { + ASSERT(lock->lockOwner == MXUSER_INVALID_OWNER); + lock->lockOwner = GetCurrentThreadId(); +#if defined(VMX86_DEBUG) + lock->lockCaller = location; + lock->lockVThreadID = (*MXUserThreadCurID)(); +#endif } - lock->lockHeader.lockCount++; + lock->lockCount++; } static INLINE Bool MXRecLockTryAcquire(MXRecLock *lock, // IN/OUT: - MXThreadID self, // IN: const void *location) // IN: { Bool success; - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - success = TryEnterCriticalSection(&lock->lockObject); if (success) { - ASSERT((lock->lockHeader.lockCount >= 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); - - if (lock->lockHeader.lockCount == 0) { - ASSERT(lock->lockHeader.lockVThreadID == VTHREAD_INVALID_ID); - lock->lockHeader.lockOwner = self; - lock->lockHeader.lockCaller = location; - lock->lockHeader.lockVThreadID = (*MXUserThreadCurID)(); + ASSERT((lock->lockCount >= 0) && + (lock->lockCount < MXUSER_MAX_REC_DEPTH)); + + if (lock->lockCount == 0) { + ASSERT(lock->lockOwner == MXUSER_INVALID_OWNER); + lock->lockOwner = GetCurrentThreadId(); + +#if defined(VMX86_DEBUG) + lock->lockCaller = location; + lock->lockVThreadID = (*MXUserThreadCurID)(); +#endif } - lock->lockHeader.lockCount++; + lock->lockCount++; } return success; @@ -201,37 +168,22 @@ MXRecLockTryAcquire(MXRecLock *lock, // IN/OUT: static INLINE void MXRecLockRelease(MXRecLock *lock) // IN/OUT: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + ASSERT((lock->lockCount > 0) && (lock->lockCount < MXUSER_MAX_REC_DEPTH)); - ASSERT((lock->lockHeader.lockCount > 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); + lock->lockCount--; - lock->lockHeader.lockCount--; + if (lock->lockCount == 0) { + lock->lockOwner = MXUSER_INVALID_OWNER; - if (lock->lockHeader.lockCount == 0) { - lock->lockHeader.lockCaller = NULL; - lock->lockHeader.lockVThreadID = VTHREAD_INVALID_ID; +#if defined(VMX86_DEBUG) + lock->lockCaller = NULL; + lock->lockVThreadID = VTHREAD_INVALID_ID; +#endif } LeaveCriticalSection(&lock->lockObject); } #else -static INLINE MXThreadID -MXGetThreadID(void) -{ - return pthread_self(); -} - - -static INLINE Bool -MXRecLockIsOwner(const MXRecLock *lock) // IN: -{ - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - return pthread_equal(lock->lockHeader.lockOwner, pthread_self()); -} - - static INLINE Bool MXRecLockObjectInit(pthread_mutex_t *lockObject) // IN/OUT: { @@ -244,31 +196,31 @@ MXRecLockDestroy(MXRecLock *lock) // IN/OUT: { int err; - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - err = pthread_mutex_destroy(&lock->lockObject); if (vmx86_debug && (err != 0)) { Panic("%s: pthread_mutex_destroy returned %d\n", __FUNCTION__, err); } +} + - free((void *) lock->lockHeader.lockName); +static INLINE Bool +MXRecLockIsOwner(const MXRecLock *lock) // IN: +{ + return pthread_equal(lock->lockOwner, pthread_self()); } static INLINE void MXRecLockAcquire(MXRecLock *lock, // IN/OUT: - MXThreadID self, // IN: void *location) // IN: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - if ((lock->lockHeader.lockCount != 0) && - pthread_equal(lock->lockHeader.lockOwner, pthread_self())) { - ASSERT((lock->lockHeader.lockCount > 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); + if ((lock->lockCount != 0) && + pthread_equal(lock->lockOwner, pthread_self())) { + ASSERT((lock->lockCount > 0) && + (lock->lockCount < MXUSER_MAX_REC_DEPTH)); - lock->lockHeader.lockCount++; + lock->lockCount++; } else { int err; @@ -278,41 +230,44 @@ MXRecLockAcquire(MXRecLock *lock, // IN/OUT: Panic("%s: pthread_mutex_lock returned %d\n", __FUNCTION__, err); } - ASSERT(lock->lockHeader.lockCount == 0); - ASSERT(lock->lockHeader.lockVThreadID == VTHREAD_INVALID_ID); + ASSERT(lock->lockCount == 0); + ASSERT(lock->lockVThreadID == VTHREAD_INVALID_ID); - lock->lockHeader.lockOwner = self; - lock->lockHeader.lockCaller = location; - lock->lockHeader.lockCount = 1; - lock->lockHeader.lockVThreadID = (*MXUserThreadCurID)(); + lock->lockOwner = pthread_self(); + lock->lockCount = 1; + +#if defined(VMX86_DEBUG) + lock->lockCaller = location; + lock->lockVThreadID = (*MXUserThreadCurID)(); +#endif } } static INLINE Bool MXRecLockTryAcquire(MXRecLock *lock, // IN/OUT: - MXThreadID self, // IN: void *location) // IN: { int err; Bool acquired; - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - err = pthread_mutex_trylock(&lock->lockObject); if (err == 0) { - ASSERT((lock->lockHeader.lockCount >= 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); - - if (lock->lockHeader.lockCount == 0) { - ASSERT(lock->lockHeader.lockVThreadID == VTHREAD_INVALID_ID); - lock->lockHeader.lockOwner = self; - lock->lockHeader.lockCaller = location; - lock->lockHeader.lockVThreadID = (*MXUserThreadCurID)(); + ASSERT((lock->lockCount >= 0) && + (lock->lockCount < MXUSER_MAX_REC_DEPTH)); + + if (lock->lockCount == 0) { + ASSERT(lock->lockVThreadID == VTHREAD_INVALID_ID); + lock->lockOwner = pthread_self(); + +#if defined(VMX86_DEBUG) + lock->lockCaller = location; + lock->lockVThreadID = (*MXUserThreadCurID)(); +#endif } - lock->lockHeader.lockCount++; + lock->lockCount++; acquired = TRUE; } else { @@ -330,18 +285,20 @@ MXRecLockTryAcquire(MXRecLock *lock, // IN/OUT: static INLINE void MXRecLockRelease(MXRecLock *lock) // IN/OUT: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - ASSERT((lock->lockHeader.lockCount > 0) && - (lock->lockHeader.lockCount < MXUSER_MAX_REC_DEPTH)); + ASSERT((lock->lockCount > 0) && (lock->lockCount < MXUSER_MAX_REC_DEPTH)); - lock->lockHeader.lockCount--; + lock->lockCount--; - if (lock->lockHeader.lockCount == 0) { + if (lock->lockCount == 0) { int err; - lock->lockHeader.lockCaller = NULL; - lock->lockHeader.lockVThreadID = VTHREAD_INVALID_ID; + /* a hack but it works portably */ + memset((void *) &lock->lockOwner, 0xFF, sizeof(lock->lockOwner)); + +#if defined(VMX86_DEBUG) + lock->lockCaller = NULL; + lock->lockVThreadID = VTHREAD_INVALID_ID; +#endif err = pthread_mutex_unlock(&lock->lockObject); @@ -353,37 +310,30 @@ MXRecLockRelease(MXRecLock *lock) // IN/OUT: #endif -static INLINE void -MXRecLockInitHeader(MXRecLock *lock, // IN/OUT: - const char *userName, // IN: - MX_Rank rank) // IN: -{ - lock->lockHeader.lockName = userName; - lock->lockHeader.lockSignature = USERLOCK_SIGNATURE; - lock->lockHeader.lockCount = 0; - lock->lockHeader.lockRank = rank; - lock->lockHeader.lockVThreadID = VTHREAD_INVALID_ID; - lock->lockHeader.lockCaller = NULL; -} - - /* * Initialization of portable recursive lock. */ static INLINE Bool -MXRecLockInit(MXRecLock *lock, // IN/OUT: - const char *userName, // IN: - MX_Rank rank) // IN: +MXRecLockInit(MXRecLock *lock) // IN/OUT: { - ASSERT(rank == RANK_UNRANKED); // NOT FOR LONG - ASSERT(userName != NULL); - if (!MXRecLockObjectInit(&lock->lockObject)) { return FALSE; } - MXRecLockInitHeader(lock, userName, rank); +#if defined(_WIN32) + lock->lockOwner = MXUSER_INVALID_OWNER; +#else + /* a hack but it works portably */ + memset((void *) &lock->lockOwner, 0xFF, sizeof(lock->lockOwner)); +#endif + + lock->lockCount = 0; + +#if defined(VMX86_DEBUG) + lock->lockVThreadID = VTHREAD_INVALID_ID; + lock->lockCaller = NULL; +#endif return TRUE; } @@ -392,26 +342,23 @@ MXRecLockInit(MXRecLock *lock, // IN/OUT: static INLINE uint32 MXRecLockCount(const MXRecLock *lock) // IN: { - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - return lock->lockHeader.lockCount; + return lock->lockCount; } -static INLINE const char * -MXRecLockName(const MXRecLock *lock) // IN: -{ - ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - - return lock->lockHeader.lockName; -} +/* + * MXUser lock header - all MXUser locks start with this + */ +#define USERLOCK_SIGNATURE 0x75677976 // 'LOCK' in memory -static INLINE uint32 -MXRecLockSignature(const MXRecLock *lock) // IN: -{ - return lock->lockHeader.lockSignature; -} +typedef struct MXUserHeader { + uint32 lockSignature; + MX_Rank lockRank; + const char *lockName; + void (*lockDumper)(struct MXUserHeader *); + /* THIS SPACE FOR RENT (STATISTICS POINTER) */ +} MXUserHeader; /* * The internal lock types @@ -419,12 +366,16 @@ MXRecLockSignature(const MXRecLock *lock) // IN: struct MXUserExclLock { - MXRecLock basic; + MXUserHeader lockHeader; + + MXRecLock lockRecursive; }; struct MXUserRecLock { - MXRecLock basic; + MXUserHeader lockHeader; + + MXRecLock lockRecursive; /* * This is the MX recursive lock override pointer. This pointer is NULL @@ -437,22 +388,25 @@ struct MXUserRecLock * !NULL use pointed to MX recursive lock */ - void *vmmLock; + void *lockVmm; }; struct MXUserRWLock { - MXRecLock lockRecursive; // Used as a header or maybe for real - - uint8 lockTaken[VTHREAD_MAX_THREADS]; + MXUserHeader lockHeader; #if defined(_WIN32) + MXRecLock lockRecursive; SRWLOCK lockReadWrite; #else #if defined(PTHREAD_RWLOCK_INITIALIZER) - pthread_rwlock_t lockObject; + pthread_rwlock_t lockReadWrite; +#else + MXRecLock lockRecursive; #endif #endif + + uint8 lockTaken[VTHREAD_MAX_THREADS]; }; /* @@ -465,7 +419,7 @@ struct MXUserRWLock Bool MXUserIsAllUnlocked(const MXUserRWLock *lock); -void MXUserDumpAndPanic(MXRecLock *lock, +void MXUserDumpAndPanic(MXUserHeader *header, const char *fmt, ...); #endif diff --git a/open-vm-tools/lib/lock/ulIsLocked.c b/open-vm-tools/lib/lock/ulIsLocked.c index 8626199b0..2329eaa17 100644 --- a/open-vm-tools/lib/lock/ulIsLocked.c +++ b/open-vm-tools/lib/lock/ulIsLocked.c @@ -41,7 +41,7 @@ Bool MXUser_IsLockedByCurThreadExclLock(const MXUserExclLock *lock) // IN: { - return MXRecLockIsOwner(&lock->basic); + return MXRecLockIsOwner(&lock->lockRecursive); } @@ -65,6 +65,6 @@ MXUser_IsLockedByCurThreadExclLock(const MXUserExclLock *lock) // IN: Bool MXUser_IsLockedByCurThreadRecLock(const MXUserRecLock *lock) // IN: { - return MXRecLockIsOwner(&lock->basic); + return MXRecLockIsOwner(&lock->lockRecursive); } diff --git a/open-vm-tools/lib/lock/ulRWPosix.c b/open-vm-tools/lib/lock/ulRWPosix.c index f22a1928b..ee316e85b 100644 --- a/open-vm-tools/lib/lock/ulRWPosix.c +++ b/open-vm-tools/lib/lock/ulRWPosix.c @@ -25,6 +25,53 @@ #include "ulInt.h" +/* + *----------------------------------------------------------------------------- + * + * MXUserDumpRWLock + * + * Dump an read-write lock. + * + * Results: + * A dump. + * + * Side effects: + * None + * + *----------------------------------------------------------------------------- + */ + +static void +MXUserDumpRWLock(MXUserHeader *header) // IN: +{ + uint32 i; + MXUserRWLock *lock = (MXUserRWLock *) header; + + Warning("%s: Read-write lock @ %p\n", __FUNCTION__, lock); + + Warning("\tsignature %X\n", lock->lockHeader.lockSignature); + Warning("\tname %s\n", lock->lockHeader.lockName); + Warning("\trank %d\n", lock->lockHeader.lockRank); + +#if defined(PTHREAD_RWLOCK_INITIALIZER) + Warning("\tlockReadWrite %p\n", &lock->lockReadWrite); +#else + Warning("\tcount %u\n", lock->lockRecursive.lockCount); + +#if defined(VMX86_DEBUG) + Warning("\tcaller %p\n", lock->lockRecursive.lockCaller); + Warning("\tVThreadID %d\n", (int) lock->lockRecursive.lockVThreadID); +#endif +#endif + + for (i = 0; i < VTHREAD_MAX_THREADS; i++) { + if (lock->lockTaken[i] != RW_UNLOCKED) { + Warning("\tlockTaken[%d] %u\n", i, lock->lockTaken[i]); + } + } +} + + /* *----------------------------------------------------------------------------- * @@ -63,20 +110,26 @@ MXUser_CreateRWLock(const char *userName, // IN: properName = Util_SafeStrdup(userName); } + lock->lockHeader.lockName = properName; + lock->lockHeader.lockSignature = USERLOCK_SIGNATURE; + lock->lockHeader.lockRank = rank; + lock->lockHeader.lockDumper = MXUserDumpRWLock; + #if defined(PTHREAD_RWLOCK_INITIALIZER) - if (pthread_rwlock_init(&lock->lockObject, NULL) != 0) { + /* Initialize the native read-write lock */ + if (pthread_rwlock_init(&lock->lockReadWrite, NULL) != 0) { free((void *) properName); free(lock); lock = NULL; } -#endif - - /* Establish standard header. This may get used for real too. */ - if (!MXRecLockInit(&lock->lockRecursive, properName, rank)) { +#else + /* Create recursive lock used for emulation */ + if (!MXRecLockInit(&lock->lockRecursive)) { free((void *) properName); free(lock); lock = NULL; } +#endif return lock; } @@ -107,33 +160,33 @@ MXUser_AcquireForRead(MXUserRWLock *lock) // IN/OUT: VThreadID self = VThread_CurID(); - ASSERT(MXRecLockSignature(&lock->lockRecursive) == USERLOCK_SIGNATURE); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); #if defined(PTHREAD_RWLOCK_INITIALIZER) - err = pthread_rwlock_rdlock(&lock->lockObject); + err = pthread_rwlock_rdlock(&lock->lockReadWrite); if (err == 0) { if (lock->lockTaken[self] == RW_LOCKED_FOR_READ) { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: AcquireForRead after AcquireForRead", __FUNCTION__); } } else { - MXUserDumpAndPanic(&lock->lockRecursive, "%s: %s", + MXUserDumpAndPanic(&lock->lockHeader, "%s: %s", (err == EDEADLK) ? "Deadlock detected (%d)" : "Internal error (%d)", __FUNCTION__, err); } #else - MXRecLockAcquire(&lock->lockRecursive, MXGetThreadID(), GetReturnAddress()); + MXRecLockAcquire(&lock->lockRecursive, GetReturnAddress()); if (lock->lockTaken[self] != RW_UNLOCKED) { if (lock->lockTaken[self] == RW_LOCKED_FOR_READ) { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: AcquireForRead after AcquireForRead" __FUNCTION__, self); } else { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: AcquireForRead after AcquireForWrite" __FUNCTION__, self); } @@ -171,27 +224,27 @@ MXUser_AcquireForWrite(MXUserRWLock *lock) // IN/OUT: VThreadID self = VThread_CurID(); - ASSERT(MXRecLockSignature(&lock->lockRecursive) == USERLOCK_SIGNATURE); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); #if defined(PTHREAD_RWLOCK_INITIALIZER) - err = pthread_rwlock_wrlock(&lock->lockObject); + err = pthread_rwlock_wrlock(&lock->lockReadWrite); if (err != 0) { - MXUserDumpAndPanic(&lock->lockRecursive, "%s: %s", + MXUserDumpAndPanic(&lock->lockHeader, "%s: %s", (err == EDEADLK) ? "Deadlock detected (%d)" : "Internal error (%d)", __FUNCTION__, err); } #else - MXRecLockAcquire(&lock->lockRecursive, MXGetThreadID(), GetReturnAddress()); + MXRecLockAcquire(&lock->lockRecursive, GetReturnAddress()); if (lock->lockTaken[self] != RW_UNLOCKED) { if (lock->lockTaken[self] == RW_LOCKED_FOR_READ) { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: AcquireForRead after AcquireForWrite" __FUNCTION__); } else { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: AcquireForWrite after AcquireForWrite" __FUNCTION__); } @@ -226,10 +279,10 @@ MXUser_ReleaseRWLock(MXUserRWLock *lock) // IN/OUT: VThreadID self = VThread_CurID(); uint8 myState = lock->lockTaken[self]; - ASSERT(MXRecLockSignature(&lock->lockRecursive) == USERLOCK_SIGNATURE); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); if (myState == RW_UNLOCKED) { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: Release of read-lock not by owner (%d)", __FUNCTION__, self); } @@ -241,7 +294,7 @@ MXUser_ReleaseRWLock(MXUserRWLock *lock) // IN/OUT: ASSERT(MXUserIsAllUnlocked(lock)); } - pthread_rwlock_unlock(&lock->lockObject); + pthread_rwlock_unlock(&lock->lockReadWrite); #else ASSERT(MXUserIsAllUnlocked(lock)); MXRecLockRelease(&lock->lockRecursive); @@ -269,19 +322,21 @@ void MXUser_DestroyRWLock(MXUserRWLock *lock) // IN: { if (lock != NULL) { - ASSERT(MXRecLockSignature(&lock->lockRecursive) == USERLOCK_SIGNATURE); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); if (!MXUserIsAllUnlocked(lock)) { - MXUserDumpAndPanic(&lock->lockRecursive, + MXUserDumpAndPanic(&lock->lockHeader, "%s: Destroy on read-lock while still acquired", __FUNCTION__); } #if defined(PTHREAD_RWLOCK_INITIALIZER) - pthread_rwlock_destroy(&lock->lockObject); + pthread_rwlock_destroy(&lock->lockReadWrite); +#else + MXRecLockDestroy(&lock->lockRecursive); #endif - MXRecLockDestroy(&lock->lockRecursive); + free((void *) lock->lockHeader.lockName); free(lock); } } diff --git a/open-vm-tools/lib/lock/ulRelease.c b/open-vm-tools/lib/lock/ulRelease.c index dc2d724c9..ae9fa95a7 100644 --- a/open-vm-tools/lib/lock/ulRelease.c +++ b/open-vm-tools/lib/lock/ulRelease.c @@ -21,40 +21,6 @@ #include "ulInt.h" -/* - *----------------------------------------------------------------------------- - * - * MXUserReleaseExclLock -- - * - * Release (unlock) a lock. - * - * Results: - * The lock is released. - * - * Side effects: - * None - * - *----------------------------------------------------------------------------- - */ - -static INLINE void -MXUserReleaseExclLock(MXRecLock *lock, // IN/OUT: - char *type) // IN: -{ - if (!MXRecLockIsOwner(lock)) { - if (MXRecLockCount(lock) == 0) { - MXUserDumpAndPanic(lock, "%s: Release of an unacquired %s lock", - __FUNCTION__, type); - } else { - MXUserDumpAndPanic(lock, "%s: Release of owned %s lock", - __FUNCTION__, type); - } - } - - MXRecLockRelease(lock); -} - - /* *----------------------------------------------------------------------------- * @@ -74,7 +40,21 @@ MXUserReleaseExclLock(MXRecLock *lock, // IN/OUT: void MXUser_ReleaseExclLock(MXUserExclLock *lock) // IN/OUT: { - MXUserReleaseExclLock(&lock->basic, "exclusive"); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + if (!MXRecLockIsOwner(&lock->lockRecursive)) { + if (MXRecLockCount(&lock->lockRecursive) == 0) { + MXUserDumpAndPanic(&lock->lockHeader, + "%s: Release of an unacquired exclusive lock", + __FUNCTION__); + } else { + MXUserDumpAndPanic(&lock->lockHeader, + "%s: Release of owned exclusive lock", + __FUNCTION__); + } + } + + MXRecLockRelease(&lock->lockRecursive); } @@ -97,5 +77,19 @@ MXUser_ReleaseExclLock(MXUserExclLock *lock) // IN/OUT: void MXUser_ReleaseRecLock(MXUserRecLock *lock) // IN/OUT: { - MXUserReleaseExclLock(&lock->basic, "recursive"); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + if (!MXRecLockIsOwner(&lock->lockRecursive)) { + if (MXRecLockCount(&lock->lockRecursive) == 0) { + MXUserDumpAndPanic(&lock->lockHeader, + "%s: Release of an unacquired recursive lock", + __FUNCTION__); + } else { + MXUserDumpAndPanic(&lock->lockHeader, + "%s: Release of owned recursive lock", + __FUNCTION__); + } + } + + MXRecLockRelease(&lock->lockRecursive); } diff --git a/open-vm-tools/lib/lock/ulTryAcquire.c b/open-vm-tools/lib/lock/ulTryAcquire.c index e4dd8a2e9..8379d69cb 100644 --- a/open-vm-tools/lib/lock/ulTryAcquire.c +++ b/open-vm-tools/lib/lock/ulTryAcquire.c @@ -44,11 +44,12 @@ MXUser_TryAcquireExclLock(MXUserExclLock *lock) // IN/OUT: { Bool success; - success = MXRecLockTryAcquire(&lock->basic, MXGetThreadID(), - GetReturnAddress()); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); - if (success && (MXRecLockCount(&lock->basic) > 1)) { - MXUserDumpAndPanic(&lock->basic, + success = MXRecLockTryAcquire(&lock->lockRecursive, GetReturnAddress()); + + if (success && (MXRecLockCount(&lock->lockRecursive) > 1)) { + MXUserDumpAndPanic(&lock->lockHeader, "%s: Acquire on an acquired exclusive lock", __FUNCTION__); } @@ -79,6 +80,7 @@ MXUser_TryAcquireExclLock(MXUserExclLock *lock) // IN/OUT: Bool MXUser_TryAcquireRecLock(MXUserRecLock *lock) // IN/OUT: { - return MXRecLockTryAcquire(&lock->basic, MXGetThreadID(), - GetReturnAddress()); + ASSERT(lock->lockHeader.lockSignature == USERLOCK_SIGNATURE); + + return MXRecLockTryAcquire(&lock->lockRecursive, GetReturnAddress()); } diff --git a/open-vm-tools/lib/misc/hostinfoPosix.c b/open-vm-tools/lib/misc/hostinfoPosix.c index 3a0b56e84..eeeb620d0 100644 --- a/open-vm-tools/lib/misc/hostinfoPosix.c +++ b/open-vm-tools/lib/misc/hostinfoPosix.c @@ -102,7 +102,6 @@ #include "x86cpuid.h" #endif -#include "syncMutex.h" #include "unicode.h" #include "guest_os.h" #include "dynbuf.h" diff --git a/open-vm-tools/lib/sync/Makefile.am b/open-vm-tools/lib/sync/Makefile.am deleted file mode 100644 index cc0cb11c2..000000000 --- a/open-vm-tools/lib/sync/Makefile.am +++ /dev/null @@ -1,22 +0,0 @@ -################################################################################ -### Copyright 2007 VMware, Inc. All rights reserved. -### -### This program is free software; you can redistribute it and/or modify -### it under the terms of version 2 of the GNU General Public License as -### published by the Free Software Foundation. -### -### This program is distributed in the hope that it will be useful, -### but WITHOUT ANY WARRANTY; without even the implied warranty of -### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -### GNU General Public License for more details. -### -### You should have received a copy of the GNU General Public License -### along with this program; if not, write to the Free Software -### Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -################################################################################ - -noinst_LTLIBRARIES = libSync.la - -libSync_la_SOURCES = -libSync_la_SOURCES += syncMutexPthread.c - diff --git a/open-vm-tools/lib/sync/syncMutexPthread.c b/open-vm-tools/lib/sync/syncMutexPthread.c deleted file mode 100644 index d23776e78..000000000 --- a/open-vm-tools/lib/sync/syncMutexPthread.c +++ /dev/null @@ -1,167 +0,0 @@ -/********************************************************* - * Copyright (C) 1998 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 - * by the Free Software Foundation version 2.1 and no later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the Lesser GNU General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - *********************************************************/ - -/* - * syncMutexPthread.c -- - * - * Implements a non-recursive mutex using pthreads - */ - -#include -#include -#include - -#include "vm_assert.h" -#include "syncMutex.h" -#include "util.h" - -/* - *---------------------------------------------------------------------- - * - * SyncMutex_Init -- - * - * Initializes a mutex structure. The 'path' parameter names the - * mutex. If 'path' is NULL, then an anonymous mutex is - * created. (see SyncWaitQ_Init) - * - * Results: - * TRUE on success and FALSE otherwise - * - *---------------------------------------------------------------------- - */ - -Bool -SyncMutex_Init(SyncMutex *that, // OUT: - char const *path) // IN: -{ - int error; - - error = pthread_mutex_init(&that->_mutex, NULL); - if (error != 0) { - return FALSE; - } - - return TRUE; -} - - -/* - *---------------------------------------------------------------------- - * - * SyncMutex_Destroy -- - * - * Frees members of the specified mutex structure - * (see SyncWaitQ_Destroy for side effects) - * - *---------------------------------------------------------------------- - */ - -void -SyncMutex_Destroy(SyncMutex *that) // IN: -{ -#ifdef VMX86_DEBUG - int error = -#endif - pthread_mutex_destroy(&that->_mutex); -#ifdef VMX86_DEBUG - ASSERT(error != EBUSY); -#endif -} - - -/* - *---------------------------------------------------------------------- - * - * SyncMutex_Lock -- - * - * Obtains the mutex - * - * Results: - * TRUE on success and FALSE otherwise - * - *---------------------------------------------------------------------- - */ - -Bool -SyncMutex_Lock(SyncMutex *that) // IN -{ - int error = pthread_mutex_lock(&that->_mutex); - - ASSERT(error != EINVAL); - if (error != 0) { - return FALSE; - } - - return TRUE; -} - - -/* - *---------------------------------------------------------------------- - * - * SyncMutex_Unlock -- - * - * Releases the mutex - * - * Results: - * TRUE on success and FALSE otherwise - * - *---------------------------------------------------------------------- - */ - -Bool -SyncMutex_Unlock(SyncMutex *that) // IN -{ - int error = pthread_mutex_unlock(&that->_mutex); - - ASSERT(error != EINVAL); - if (error != 0) { - return FALSE; - } - - return TRUE; -} - - -/* - *----------------------------------------------------------------------------- - * - * SyncMutex_Trylock -- - * - * Tries to lock the mutex. Returns without blocking. - * - * Results: - * TRUE if the mutex was locked, FALSE otherwise. - * - * Side effects: - * None. - * - *----------------------------------------------------------------------------- - */ - -Bool -SyncMutex_Trylock(SyncMutex *that) // IN: -{ - ASSERT(that); -#ifdef VMX86_SERVER - NOT_IMPLEMENTED(); - return FALSE; -#else - return (0 == pthread_mutex_trylock(&that->_mutex)); -#endif -} diff --git a/open-vm-tools/libvmtools/Makefile.am b/open-vm-tools/libvmtools/Makefile.am index 0a9fc7279..f9097c66c 100644 --- a/open-vm-tools/libvmtools/Makefile.am +++ b/open-vm-tools/libvmtools/Makefile.am @@ -36,7 +36,6 @@ libvmtools_la_LIBADD += ../lib/rpcChannel/libRpcChannel.la libvmtools_la_LIBADD += ../lib/rpcOut/libRpcOut.la libvmtools_la_LIBADD += ../lib/rpcVmx/libRpcVmx.la libvmtools_la_LIBADD += ../lib/string/libString.la -libvmtools_la_LIBADD += ../lib/sync/libSync.la libvmtools_la_LIBADD += ../lib/syncDriver/libSyncDriver.la libvmtools_la_LIBADD += ../lib/system/libSystem.la libvmtools_la_LIBADD += ../lib/stubs/libStubsCS.la diff --git a/open-vm-tools/toolbox/Makefile.am b/open-vm-tools/toolbox/Makefile.am index 2540c994b..e88d0193c 100644 --- a/open-vm-tools/toolbox/Makefile.am +++ b/open-vm-tools/toolbox/Makefile.am @@ -37,7 +37,6 @@ COMMON += ../lib/backdoor/libBackdoor.la COMMON += ../lib/dict/libDict.la COMMON += ../lib/message/libMessage.la COMMON += ../lib/unicode/libUnicode.la -COMMON += ../lib/sync/libSync.la COMMON += ../lib/lock/libLock.la COMMON += ../lib/nothread/libNothread.la COMMON += ../lib/misc/libMisc.la diff --git a/open-vm-tools/vmware-user/Makefile.am b/open-vm-tools/vmware-user/Makefile.am index 11587dc8c..b948b7b3d 100644 --- a/open-vm-tools/vmware-user/Makefile.am +++ b/open-vm-tools/vmware-user/Makefile.am @@ -52,7 +52,6 @@ vmware_user_LDADD += ../lib/rpcOut/libRpcOut.la vmware_user_LDADD += ../lib/rpcVmx/libRpcVmx.la vmware_user_LDADD += ../lib/SLPv2Parser/libSLPv2Parser.la vmware_user_LDADD += ../lib/string/libString.la -vmware_user_LDADD += ../lib/sync/libSync.la vmware_user_LDADD += ../lib/syncDriver/libSyncDriver.la vmware_user_LDADD += ../lib/system/libSystem.la if ENABLE_UNITY