lnk/microser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0b8a6739f634ab2a0f5b9ed9a7ed16c858c1575c
microser/mmslib/util/glbsem_w32.c
lnk 7205cb5cb9 自主协议库编译通过
2026-06-15 15:48:16 +08:00

1140 lines
36 KiB
C
Raw Blame History

/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/* (c) Copyright Systems Integration Specialists Company, Inc., */
/* 1997-2008, All Rights Reserved */
/* */
/* MODULE NAME : glbsem_w32.c */
/* PRODUCT(S) : */
/* */
/* MODULE DESCRIPTION : Multi-thread support for Windows ONLY. */
/* */
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
/* */
/* MODIFICATION LOG : */
/* Date Who Rev Comments */
/* -------- --- ------ ------------------------------------------- */
/* 06/10/08 EJV 21 Ported to Windows Vista. */
/* 03/27/08 EJV 20 Use S_MAX_PATH instead of MAX_PATH. */
/* 01/29/08 EJV 19 Use S_FMT_* macros to log pointers & handles.*/
/* 05/23/07 DSF 18 Added dependency on advapi32.dll */
/* 06/29/06 MDE,EJV 17 Added UNICODE support (gs_translate_name). */
/* Del <process.h>, see sysincs.h. */
/* 04/12/05 DSF 16 Added refCount member to GS_MUTEX (Windows) */
/* 01/06/05 DSF 15 Added owner member to GS_MUTEX (Windows) */
/* 01/14/05 EJV 14 Reversed change. */
/* 07/21/04 DWL 13 Added ifdef so non debug configs would build.*/
/* 07/02/04 DSF 12 Always link in winmm.lib */
/* 05/21/04 DSF 11 Timeout log is now FLOW instead of NERR */
/* 04/19/04 DSF 10 gs_wait_thread () now returns SD_TIMEOUT on */
/* timeouts */
/* 12/29/03 ASK 09 enable logLastError, pass gle to logLastError*/
/* 12/03/03 EJV 08 gs_is_win_ver(): chg return ST_RET to ST_INT;*/
/* Add SD_WIN_VER_2003_AND_LATER, replaced */
/* SD_WIN_VER_NET with SD_WIN_VER_2003; */
/* 12/01/03 EJV 07 gs_is_win_ver: chk for corr ret 1, 0, -1. */
/* Named mutex, event: for 2000S w/terminal serv*/
/* chg from XP to SD_WIN_VER_2K_AND_LATER. */
/* 11/24/03 DSF 06 Spelling */
/* 11/04/03 JRB 05 Del gs_sleep (use sMsSleep). */
/* 06/20/03 EJV 04 Renamed gs_mutex_get to gs_mutex_get_tm. */
/* 06/12/03 EJV 03 Redesigned mutex sems implementation. */
/* 06/10/03 EJV 02 Added gs_named_mutex_xxx functions. */
/* 06/06/03 JRB 01 NEW. Code taken out of glbsem.c */
/************************************************************************/
#include "glbtypes.h"
#include "sysincs.h"
#include "mem_chk.h"
#include "slog.h"
#include "glbsem.h"
#ifdef WIN32
#pragma comment(linker, "/defaultlib:winmm.lib")
#pragma comment(linker, "/defaultlib:advapi32.lib")
/************************************************************************/
/* For debug version, use a static pointer to avoid duplication of */
/* __FILE__ strings. */
#ifdef DEBUG_SISCO
SD_CONST static ST_CHAR *SD_CONST thisFileName = __FILE__;
#endif
static ST_VOID logLastError (DWORD errCode);
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/* */
/* MUTEX SEMAPHORE FUNCTIONS for _WIN32 */
/* */
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/************************************************************************/
/* gs_mutex_create */
/*----------------------------------------------------------------------*/
/* Initialize the mutex semaphore ms. */
/* CRITICAL_SECTION is used for mutex semaphore for faster operation. */
/* Parameters: */
/* ms pointer to mutex object */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_mutex_create (ST_MUTEX_SEM *ms)
{
ms->mutexType = GS_MUTEX_UNNAMED;
ms->owner = 0;
ms->refCount = 0;
InitializeCriticalSection (&ms->u.cs);
return (SD_SUCCESS);
}
/************************************************************************/
/* gs_translate_name */
/*----------------------------------------------------------------------*/
/* This function, if necessary, will prepend "Global\\" to the name and */
/* convert the name to Unicode. */
/* name ptr to name str (named mutex or sem). */
/* newName, wideName ptr to output buffer. */
/* bufSize output buffer size. */
/* */
/* !NOTE: The UNICODE was not tested. */
/************************************************************************/
#if defined (UNICODE)
ST_RET gs_translate_name (ST_CHAR *name, WCHAR *wideName, ST_UINT bufSize)
#else
ST_RET gs_translate_name (ST_CHAR *name, ST_CHAR *newName, ST_UINT bufSize)
#endif
{
#if defined (UNICODE)
ST_CHAR tmpName[S_MAX_PATH]; /* max size that a mutex/sem name can have */
#endif
ST_UINT maxLen;
ST_BOOLEAN bPrepend = SD_FALSE;
/* NOTE: do not put any logging to this function. It is used in DLLs. */
/* compute the max name size that can be handled & set bPrepend flag */
#if defined (UNICODE)
maxLen = sizeof(tmpName) - 1;
#else
maxLen = bufSize - 1;
#endif
if (gs_is_win_ver (SD_WIN_VER_2K_AND_LATER) == 1)
if (memcmp (name, "Global\\", strlen ("Global\\")) != 0)
{
/* need to prepend "Global\\" */
maxLen = maxLen - strlen ("Global\\");
bPrepend = SD_TRUE;
}
/* make sure we got buffer big enough for the resulting prepended name */
if (strlen(name) > maxLen)
return (SD_FAILURE);
#if defined (UNICODE)
{
/* copy the name to temporary buffer and prepend "Global\\" if necessary */
if (bPrepend)
sprintf (tmpName, "Global\\%s", name);
else
strcpy (tmpName, name);
/* Convert ANSI name to Unicode (error will be set if bufSize is too small) */
if (MultiByteToWideChar (CP_ACP, 0, tmpName, strlen (tmpName)+1, wideName, bufSize) == 0)
return (SD_FAILURE);
}
#else /* !defined (UNICODE) */
if (bPrepend)
sprintf (newName, "Global\\%s", name);
else
strcpy (newName, name);
#endif /* !defined (UNICODE) */
return (SD_SUCCESS);
}
/************************************************************************/
/* gs_named_mutex_create */
/*----------------------------------------------------------------------*/
/* Create/Open NAMED mutex. */
/* On Windows XP this function prepends 'Global\\' to the mutex name */
/* and sets the security descriptor in the way that the mutex can */
/* be accessed by processes in different user spaces (in Windows XP Fast*/
/* User Switching). */
/* For each call to this function the gs_named_mutex_destroy must be */
/* called. */
/* Parameters: */
/* ms pointer where to return handle to named mutex */
/* name pointer to mutex name. */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_named_mutex_create (ST_MUTEX_SEM *ms, ST_CHAR *name)
{
ST_RET ret = SD_SUCCESS;
HANDLE hMutex = NULL;
#if defined (UNICODE)
WCHAR mutexName[S_MAX_PATH];
#else
ST_CHAR mutexName[S_MAX_PATH];
#endif
if (ms == NULL || name == NULL)
{
#if defined(DEBUG_SISCO)
GLBSEM_LOG_ERR0 ("GLBSEM error: gs_named_mutex_create() failed ms=NULL or name=NULL");
#endif
return (SD_FAILURE);
}
ret = gs_translate_name (name, mutexName, (ST_UINT) (sizeof(mutexName)/sizeof(mutexName[0])));
if (ret != SD_SUCCESS)
{
#if defined(DEBUG_SISCO)
GLBSEM_LOG_ERR1 ("GLBSEM error: gs_translate_name () failed, name='%s'.", name);
#endif
return (ret);
}
/* set the mutex type */
ms->mutexType = GS_MUTEX_NAMED;
ms->owner = 0;
ms->refCount = 0;
if (gs_is_win_ver (SD_WIN_VER_2K_AND_LATER) == 1)
{
PSECURITY_DESCRIPTOR psd;
SECURITY_ATTRIBUTES sa;
/* This code allows the mutex to be accessed from different */
/* applications in different users (Windows XP Fast User Switching). */
psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
if (psd == NULL)
return (SD_FAILURE);
if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
{
LocalFree (psd);
return (SD_FAILURE);
}
if (!SetSecurityDescriptorDacl(psd, TRUE, (PACL) NULL, FALSE))
{
LocalFree (psd);
return (SD_FAILURE);
}
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = psd;
sa.bInheritHandle = TRUE;
hMutex = CreateMutex (&sa, /* security attributes */
SD_FALSE, /* FALSE is initially not owned */
mutexName); /* object name */
if (hMutex == NULL)
{
#if defined(DEBUG_SISCO)
DWORD gle = GetLastError ();
GLBSEM_LOG_ERR2 ("GLBSEM error: CreateMutex failed GLE=%d for %s",
(unsigned int) gle, mutexName);
#endif
ret = SD_FAILURE;
}
LocalFree (psd);
}
else
{
/* this is Win 98, NT or 2000 */
hMutex = CreateMutex (NULL, /* no security attributes */
SD_FALSE, /* FALSE is initially not owned */
mutexName); /* object name */
if (hMutex == NULL)
{
#if defined(DEBUG_SISCO)
DWORD gle = GetLastError ();
GLBSEM_LOG_ERR2 ("GLBSEM error: CreateMutex failed GLE=%d for %s",
(unsigned int) gle, mutexName);
#endif
ret = SD_FAILURE;
}
}
ms->u.hMutex = hMutex; /* return the handle to user */
return (ret);
}
/************************************************************************/
/* gs_mutex_get_tm */
/*----------------------------------------------------------------------*/
/* Lock the mutex semaphore ms. */
/* This function uses the gs_wait_event_sem to wait for ownership of */
/* the named mutex. The named mutex object can be also passed to the */
/* gs_wait_mult_event_sem function when waiting for multiple objects is */
/* required. */
/* */
/* Parameters: */
/* ms pointer to mutex object */
/* timeout Interval in milliseconds to wait for the named */
/* mutex to be owned, if -1L then the function will*/
/* be blocked indefinitely until the named mutex */
/* is owned. */
/* The timeout parameter is ignored for unnamed */
/* mutex. The function will wait indefinetely until*/
/* the mutex is owned. */
/* Return values: */
/* none */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/* SD_TIMEOUT timeout */
/* */
/* CRITICAL: gs_mutex_get_tm must NOT call any slog, stime, or mem_chk */
/* functions. These functions call gs_mutex_get_tm causing */
/* an infinite loop. Logging in the named mutex code is OK. */
/************************************************************************/
ST_RET gs_mutex_get_tm (ST_MUTEX_SEM *ms, ST_LONG timeout)
{
ST_RET ret = SD_SUCCESS;
if (!gs_already_inited) /* Make sure gs is initialized. */
gs_init ();
if (ms->mutexType == GS_MUTEX_UNNAMED)
/* ! do not put logging here to avoid infinite loop */
EnterCriticalSection (&ms->u.cs);
else
/* named mutex */
ret = gs_wait_event_sem ((ST_EVENT_SEM) ms->u.hMutex, timeout);
if (ret == SD_SUCCESS)
{
ms->owner = GET_THREAD_ID ();
++ms->refCount;
}
return (ret);
}
/************************************************************************/
/* gs_mutex_free */
/*----------------------------------------------------------------------*/
/* Unlock the mutex semaphore ms. */
/* Parameters: */
/* ms pointer to mutex object */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/* CRITICAL: gs_mutex_free must NOT call any slog, stime, or mem_chk */
/* functions. These functions call ge_mutex_free which would cause */
/* an infinite loop. Logging in the named mutex code is OK. */
/************************************************************************/
ST_RET gs_mutex_free (ST_MUTEX_SEM *ms)
{
ST_RET ret = SD_SUCCESS;
--ms->refCount;
if (ms->refCount == 0)
ms->owner = 0;
if (ms->mutexType == GS_MUTEX_UNNAMED)
/* ! do not put logging here to avoid infinite loop */
LeaveCriticalSection (&ms->u.cs);
else
{
/* named mutex */
if (ReleaseMutex (ms->u.hMutex) == SD_FALSE)
{
#if defined(DEBUG_SISCO)
DWORD gle = GetLastError ();
GLBSEM_LOG_ERR2 ("GLBSEM error: ReleaseMutex failed for hMutex=" S_FMT_HANDLE " (GLE=%d)",
ms->u.hMutex, (unsigned int) gle);
#endif
ret = SD_FAILURE;
}
}
return (ret);
}
/************************************************************************/
/* gs_mutex_destroy */
/*----------------------------------------------------------------------*/
/* Free all resources allocated for the MUTEX semaphore ms. */
/* Parameters: */
/* ms pointer to mutex object */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_mutex_destroy (ST_MUTEX_SEM *ms)
{
ST_RET ret = SD_SUCCESS;
if (ms->mutexType == GS_MUTEX_UNNAMED)
DeleteCriticalSection (&ms->u.cs);
else
{
/* named mutex */
if (CloseHandle (ms->u.hMutex) == SD_FALSE)
{
#if defined(DEBUG_SISCO)
DWORD gle = GetLastError ();
GLBSEM_LOG_ERR2 ("GLBSEM error: CloseHandle failed for hMutex=" S_FMT_HANDLE " (GLE=%d)",
ms->u.hMutex, (unsigned int) gle);
#endif
ret = SD_FAILURE;
}
}
return (ret);
}
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/* */
/* USER's EVENT SEMAPHORE FUNCTIONS for _WIN32 */
/* */
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/************************************************************************/
/* gs_get_event_sem */
/*----------------------------------------------------------------------*/
/* Create a "manual-reset" or "auto-reset" event semaphore. */
/* Parameters: */
/* manualReset SD_TRUE or SD_FALSE */
/* Return values: */
/* ST_EVENT_SEM handle to event semaphore object */
/************************************************************************/
ST_EVENT_SEM gs_get_event_sem (ST_BOOLEAN manualReset)
{
ST_EVENT_SEM retEventSem;
retEventSem = CreateEvent(NULL, // no security attributes
manualReset, // manual-reset event
FALSE, // initial state is signaled
NULL // object name
);
if (retEventSem == NULL)
GLBSEM_LOG_ERR1 ("GLBSEM error: CreateEvent failed for event semaphore, rc = %d", GetLastError ());
return (retEventSem);
}
/************************************************************************/
/* gs_get_named_event_sem */
/*----------------------------------------------------------------------*/
/* Create a "manual-reset" or "auto-reset" NAMED event semaphore. */
/* On Windows XP this function prepends 'Global\\' to the semaphore name*/
/* and sets the security descriptor in the way that the semaphore can */
/* be accessed by processes in different user spaces (in Windows XP Fast*/
/* User Switching). */
/* Parameters: */
/* name pointer to semaphore name. */
/* manualReset SD_TRUE or SD_FALSE */
/* Return values: */
/* ST_EVENT_SEM handle to named event semaphore object */
/************************************************************************/
ST_EVENT_SEM gs_get_named_event_sem (ST_CHAR *name, ST_BOOLEAN manualReset)
{
ST_EVENT_SEM retEventSem = NULL;
#if defined (UNICODE)
WCHAR semName[S_MAX_PATH];
#else
ST_CHAR semName[S_MAX_PATH];
#endif
/* NOTE: do not put any logging to this function. It is used in DLLs. */
if (gs_translate_name (name, semName, (ST_UINT) (sizeof(semName)/sizeof(semName[0])))
!= SD_SUCCESS)
return (NULL);
if (gs_is_win_ver (SD_WIN_VER_2K_AND_LATER) == 1)
{
PSECURITY_DESCRIPTOR psd;
SECURITY_ATTRIBUTES sa;
/* This code allows the event semaphore to be accessed from different */
/* applications in different users (Windows XP Fast User Switching). */
psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
if (psd == NULL)
return (NULL);
if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
{
LocalFree (psd);
return (NULL);
}
if (!SetSecurityDescriptorDacl(psd, TRUE, (PACL) NULL, FALSE))
{
LocalFree (psd);
return (NULL);
}
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = psd;
sa.bInheritHandle = TRUE;
retEventSem = CreateEvent(&sa, /* security attributes */
manualReset, /* manual-reset event */
SD_FALSE, /* initial state is non-signaled */
semName); /* object name */
LocalFree (psd);
}
else
{
/* this is Win 98, NT or 2000 */
retEventSem = CreateEvent (NULL, manualReset, SD_FALSE, semName);
}
return (retEventSem);
}
/************************************************************************/
/* gs_wait_event_sem */
/*----------------------------------------------------------------------*/
/* Wait for event semaphore es until it becomes signaled or timeout */
/* occurrs. */
/* If compiled with DEBUG_SISCO the gs_track variable need to be set to */
/* value >0 to enable the timing code. This way logging can be used */
/* by an application without degradation of the EVENT sem performance. */
/* Parameters: */
/* es event semaphore object */
/* timeout interval in milliseconds to wait for the es to */
/* be signaled, if -1L then the function will be */
/* blocked indefinitely until the event semaphore */
/* is signaled. */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/* SD_TIMEOUT timeout */
/************************************************************************/
ST_RET gs_wait_event_sem (ST_EVENT_SEM es, ST_LONG timeout)
{
ST_RET ret;
DWORD rc;
#if defined(DEBUG_SISCO)
DWORD gle;
ST_DOUBLE startTime;
ST_DOUBLE endTime;
ST_DOUBLE elapsedTime;
#endif
ST_THREAD_ID thisThreadId;
/* Let's see just who we are */
thisThreadId = GET_THREAD_ID();
#if defined(DEBUG_SISCO)
if (gs_track)
startTime = sGetMsTime ();
#endif
rc = WaitForSingleObject (es, timeout);
#if defined(DEBUG_SISCO)
if (gs_track)
{
endTime = sGetMsTime ();
elapsedTime = endTime - startTime;
if (elapsedTime > gs_hwEventTime)
gs_hwEventTime = elapsedTime;
}
#endif
if (rc == WAIT_FAILED)
{
#if defined(DEBUG_SISCO)
gle = GetLastError ();
GLBSEM_LOG_ERR3 ("GLBSEM error: WaitEvent rc=0x%04x, GLE=0x%04x, ThreadId=0x%08x",
(unsigned int) rc, (unsigned int)gle, thisThreadId);
logLastError (gle);
#endif
ret = SD_FAILURE;
}
else if (rc == WAIT_TIMEOUT)
ret = SD_TIMEOUT;
else
ret = SD_SUCCESS;
return (ret);
}
/************************************************************************/
/* gs_wait_mult_event_sem */
/*----------------------------------------------------------------------*/
/* Wait for event semaphores in table esTable until one of them becomes */
/* signaled or timeout occurrs. */
/* If compiled with DEBUG_SISCO the gs_track variable need to be set to */
/* value >0 to enable the timing code. This way logging can be used */
/* by an application without degradation of the EVENT sem performance. */
/* Parameters: */
/* numEvents number of event semaphores to wait for */
/* esTable pointer to table of event semaphore objects */
/* activity pointer to table where this function will mark */
/* proper index entry with SD_TRUE for the event */
/* semaphore that have been signaled */
/* timeout interval in milliseconds to wait for the es to */
/* be signaled, if -1L then the function will be */
/* blocked indefinitely until the event semaphore */
/* is signaled. */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/* SD_TIMEOUT timeout */
/************************************************************************/
ST_RET gs_wait_mult_event_sem (ST_INT numEvents, ST_EVENT_SEM *esTable,
ST_BOOLEAN *activity, ST_LONG timeout)
{
ST_RET ret;
DWORD rc;
ST_INT i;
#if defined(DEBUG_SISCO)
DWORD gle;
ST_DOUBLE startTime;
ST_DOUBLE endTime;
ST_DOUBLE elapsedTime;
#endif
ST_THREAD_ID thisThreadId;
/* Let's see just who we are */
thisThreadId = GET_THREAD_ID();
#if defined(DEBUG_SISCO)
if (gs_track)
startTime = sGetMsTime ();
#endif
rc = WaitForMultipleObjects (numEvents, esTable, FALSE, timeout);
#if defined(DEBUG_SISCO)
if (gs_track)
{
endTime = sGetMsTime ();
elapsedTime = endTime - startTime;
if (elapsedTime > gs_hwEventTime)
gs_hwEventTime = elapsedTime;
}
#endif
/* make sure activity array is zero'd out */
memset (activity, '\x0', sizeof (ST_BOOLEAN) * numEvents);
i = rc - WAIT_OBJECT_0;
if ((i >= 0) && (i < numEvents))
{
activity[i] = SD_TRUE;
ret = SD_SUCCESS;
}
else if (rc == WAIT_FAILED)
{
#if defined(DEBUG_SISCO)
gle = GetLastError ();
GLBSEM_LOG_ERR3 ("GLBSEM error: WaitEvent rc=0x%04x, GLE=0x%04x, ThreadId=0x%08x",
(unsigned int) rc, (unsigned int)gle, thisThreadId);
logLastError (gle);
#endif
ret = SD_FAILURE;
}
else if (rc == WAIT_TIMEOUT)
ret = SD_TIMEOUT;
else
ret = SD_SUCCESS;
return (ret);
}
/************************************************************************/
/* gs_signal_event_sem */
/*----------------------------------------------------------------------*/
/* Signal event semaphore es. */
/* Manual-Reset: all waiting threads are released, es remains signaled */
/* until reset explicitly by call to ResetEvent. */
/* Auto-Reset: first waiting thread is released and es will be reset */
/* to non-signaled state. If no thread is waiting the es */
/* remains in signaled state unless ResetEvent is called. */
/* Parameters: */
/* es event semaphore object */
/* Return values: */
/* none */
/************************************************************************/
ST_VOID gs_signal_event_sem (ST_EVENT_SEM es)
{
BOOL rc;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
rc = SetEvent(es);
#if defined(DEBUG_SISCO)
if (rc == FALSE)
{
gle = GetLastError ();
GLBSEM_LOG_ERR1 ("GLBSEM error: SetEvent GLE=0x%04x", (unsigned int) gle);
logLastError (gle);
}
#endif
}
/************************************************************************/
/* gs_pulse_event_sem */
/*----------------------------------------------------------------------*/
/* Uses PulseEvent to signal the event semaphore es. */
/* Manual-Reset: all waiting threads are released, es state changes to */
/* non-signaled. */
/* Auto-Reset: first waiting thread is released and es will be reset */
/* to non-signaled state even if no thread is waiting. */
/* Parameters: */
/* es event semaphore object */
/* Return values: */
/* none */
/************************************************************************/
ST_VOID gs_pulse_event_sem (ST_EVENT_SEM es)
{
BOOL rc;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
rc = PulseEvent(es);
#if defined(DEBUG_SISCO)
if (rc == FALSE)
{
gle = GetLastError ();
GLBSEM_LOG_ERR1 ("GLBSEM error: PulseEvent GLE=0x%04x", (unsigned int) gle);
logLastError (gle);
}
#endif
}
/************************************************************************/
/* gs_reset_event_sem */
/*----------------------------------------------------------------------*/
/* Reset event semaphore es. */
/* This function should be called after function gs_wait_event_sem or */
/* gs_wait_mult_event_sem return SD_SUCCESS and the signaled event */
/* semaphore is a "manual-reset" semaphore. */
/* Parameters: */
/* es event semaphore object */
/* Return values: */
/* none */
/************************************************************************/
ST_VOID gs_reset_event_sem (ST_EVENT_SEM es)
{
BOOL rc;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
rc = ResetEvent (es);
#if defined(DEBUG_SISCO)
if (rc == FALSE)
{
gle = GetLastError ();
GLBSEM_LOG_ERR1 ("GLBSEM error: ResetEvent gle=0x%04x", (unsigned int)gle);
logLastError (gle);
}
#endif
}
/************************************************************************/
/* gs_free_event_sem */
/*----------------------------------------------------------------------*/
/* Release resources taken be event semaphore es. */
/* Parameters: */
/* es event semaphore object */
/* Return values: */
/* none */
/************************************************************************/
ST_VOID gs_free_event_sem (ST_EVENT_SEM es)
{
BOOL rc;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
rc = CloseHandle (es);
#if defined(DEBUG_SISCO)
if (rc == FALSE)
{
gle = GetLastError ();
GLBSEM_LOG_ERR1 ("GLBSEM error: CloseHandle GLE=0x%04x", (unsigned int)gle);
logLastError (gle);
}
#endif
}
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/* */
/* USER's THREAD FUNCTIONS for _WIN32 */
/* */
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/************************************************************************/
/* gs_start_thread */
/*----------------------------------------------------------------------*/
/* Start a new thread. The thread handle should be closed after the */
/* thread terminates by calling the gs_close_thread(). The function */
/* gs_wait_thread can be used to wait until a thread terminates. */
/* Parameters: */
/* threadFunc pointer to thread function to run */
/* threadArg thread function argument list */
/* threadHandleOut pointer where to return thread handle */
/* threadIdOut pointer where to return thread ID */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_start_thread (ST_THREAD_RET (ST_THREAD_CALL_CONV *threadFunc) (ST_THREAD_ARG),
ST_THREAD_ARG threadArg,
ST_THREAD_HANDLE *threadHandleOut,
ST_THREAD_ID *threadIdOut)
{
ST_RET ret;
ST_THREAD_HANDLE threadHandle;
ST_THREAD_ID threadId;
threadHandle = _beginthreadex (NULL, /* No security */
0, /* Use def stack size */
threadFunc,
threadArg, /* Argument for thread */
0, /* Creation flags, 0 for running initial state */
&threadId); /* Thread identifier */
if (threadHandle == 0)
{
GLBSEM_LOG_ERR1 ("GLBSEM error: gs_start_thread _beginthreadex failed errno=%d",
errno);
ret = SD_FAILURE;
}
else
{
ret = SD_SUCCESS;
if (threadHandleOut != NULL)
*threadHandleOut = threadHandle;
if (threadIdOut != NULL)
*threadIdOut = threadId;
GLBSEM_LOG_FLOW2 ("GLBSEM: gs_start_thread created thread threadHandle=" S_FMT_THREAD_HANDLE
" threadId=0x%08x", threadHandle, threadId);
}
return (ret);
}
/************************************************************************/
/* gs_wait_thread */
/*----------------------------------------------------------------------*/
/* Wait until thread with threadHandle terminates or timeout occurrs. */
/* Parameters: */
/* threadHandle thread handle returned from gs_start_thread */
/* threadId thread ID returned from gs_start_thread */
/* timeout max time in milliseconds to wait for thread to */
/* terminate. */
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_wait_thread (ST_THREAD_HANDLE threadHandle,
ST_THREAD_ID threadId, ST_LONG timeout)
{
ST_RET ret;
DWORD rc;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
rc = WaitForSingleObject ((HANDLE)threadHandle, timeout);
if (rc != WAIT_OBJECT_0)
{
#if defined(DEBUG_SISCO)
gle = GetLastError ();
#endif
if (rc == WAIT_TIMEOUT)
{
ret = SD_TIMEOUT;
/* WAIT_FAILED or WAIT_TIMEOUT */
#if defined(DEBUG_SISCO)
GLBSEM_LOG_FLOW3 ("GLBSEM: Timeout=%d ms in Wait Thread threadHandle=" S_FMT_THREAD_HANDLE ", "
"threadId=0x%08x", timeout, threadHandle, threadId);
#endif
}
else
{
#if defined(DEBUG_SISCO)
GLBSEM_LOG_ERR3 ("GLBSEM error: Wait Thread threadHandle=" S_FMT_THREAD_HANDLE ", rc=0x%04x, GLE=0x%04x",
threadHandle, (unsigned int)rc, (unsigned int)gle);
logLastError (gle);
#endif
ret = SD_FAILURE;
}
}
else
ret = SD_SUCCESS;
return (ret);
}
/************************************************************************/
/* gs_close_thread */
/*----------------------------------------------------------------------*/
/* Cleanup after thread terminated. */
/* Parameters: */
/* threadHandle thread handle ret from gs_start_thread()*/
/* Return values: */
/* SD_SUCCESS function successful */
/* SD_FAILURE error occurred */
/************************************************************************/
ST_RET gs_close_thread (ST_THREAD_HANDLE threadHandle)
{
ST_RET ret = SD_SUCCESS;
#if defined(DEBUG_SISCO)
DWORD gle;
#endif
if (threadHandle)
{
if (CloseHandle ((HANDLE)threadHandle) == 0)
{
#if defined(DEBUG_SISCO)
gle = GetLastError ();
GLBSEM_LOG_ERR1 ("GLBSEM error: Close Thread GLE=0x%04x", (unsigned int)gle);
#endif
ret = SD_FAILURE;
}
}
else
{
GLBSEM_LOG_ERR1 ("GLBSEM error: Close Thread invalid threadHandle=" S_FMT_THREAD_HANDLE ".",
threadHandle);
ret = SD_FAILURE;
}
return (ret);
}
/************************************************************************/
/* gs_set_thread_name */
/*----------------------------------------------------------------------*/
/* Start a new thread. */
/* Parameters: */
/* threadId ID of Thread whose name is to be set */
/* -1 if name is to be set for calling */
/* thread */
/* pThreadName Name to set */
/************************************************************************/
#define THREADNAME_EXCEPT_ID 0x406D1388
#define THREADNAME_INFO_TYPE 0x1000
typedef struct tagTHREADNAME_INFO
{
ST_LONG type;
ST_CHAR *pName;
ST_THREAD_ID threadId;
LONG flags;
} THREADNAME_INFO;
ST_VOID gs_set_thread_name (ST_THREAD_ID threadId, ST_CHAR *pThreadName)
{
THREADNAME_INFO info;
info.type = THREADNAME_INFO_TYPE;
info.pName = pThreadName;
info.threadId = threadId;
info.flags = 0;
__try
{
#if (_MSC_VER >= 1300)
RaiseException (THREADNAME_EXCEPT_ID, 0,
sizeof (info) / sizeof (ST_LONG), (ULONG_PTR *) &info);
#else
RaiseException (THREADNAME_EXCEPT_ID, 0,
sizeof (info) / sizeof (ST_LONG), (DWORD *) &info);
#endif
}
__except (EXCEPTION_CONTINUE_EXECUTION)
{
}
}
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/* */
/* Misc. FUNCTIONS for _WIN32 */
/* */
/*---*---*---*---*---*---*---*---*---*---*---*---*---*--*/
/************************************************************************/
/* gs_is_win_ver */
/*----------------------------------------------------------------------*/
/* Accesses the OS version of the running system and checks if the */
/* version is ver. */
/* This function is compatible with Windows 95 and above. */
/* Parameters: */
/* ST_UINT ver see SD_WIN_* choices in glbsem.h */
/* Return: */
/* 1 If OS version is ver */
/* 0 If OS version is not ver */
/* -1 If could not access OS version info or ver invalid */
/************************************************************************/
ST_INT gs_is_win_ver (ST_UINT ver)
{
ST_INT ret = 0;
OSVERSIONINFO OsVerInfo; /* supported on Win 95 and up */
/* NOTE: do not put any logging to this function. It is used in DLLs. */
OsVerInfo.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
if (GetVersionEx (&OsVerInfo) == 0)
return (-1);
switch (ver)
{
case SD_WIN_VER_95_98_Me: /* 95, 98, Me */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
ret = 1;
break;
case SD_WIN_VER_NT_AND_LATER: /* NT 3.51, NT 4.0 and above */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
ret = 1;
break;
case SD_WIN_VER_2K_AND_LATER: /* 2000 and above */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
((OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion >= 0) ||
OsVerInfo.dwMajorVersion > 5))
ret = 1;
break;
case SD_WIN_VER_XP_AND_LATER: /* XP and above */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
((OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion >= 1) ||
OsVerInfo.dwMajorVersion > 5))
ret = 1;
break;
case SD_WIN_VER_2003_AND_LATER: /* 2003 and above */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
((OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion >= 2) ||
OsVerInfo.dwMajorVersion > 5))
ret = 1;
break;
case SD_WIN_VER_VISTA_AND_LATER: /* Vista and above */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
((OsVerInfo.dwMajorVersion == 6 && OsVerInfo.dwMinorVersion >= 0) ||
OsVerInfo.dwMajorVersion > 6))
ret = 1;
break;
case SD_WIN_VER_95:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
OsVerInfo.dwMajorVersion == 4 && OsVerInfo.dwMinorVersion == 0)
ret = 1;
break;
case SD_WIN_VER_98:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
OsVerInfo.dwMajorVersion == 4 && OsVerInfo.dwMinorVersion == 10)
ret = 1;
break;
case SD_WIN_VER_Me:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
OsVerInfo.dwMajorVersion == 4 && OsVerInfo.dwMinorVersion == 90)
ret = 1;
break;
case SD_WIN_VER_NT_351:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 3 && OsVerInfo.dwMinorVersion == 51)
ret = 1;
break;
case SD_WIN_VER_NT_40:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 4 && OsVerInfo.dwMinorVersion == 0)
ret = 1;
break;
case SD_WIN_VER_2000:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion == 0)
ret = 1;
break;
case SD_WIN_VER_XP:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion == 1)
ret = 1;
break;
case SD_WIN_VER_2003:
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 5 && OsVerInfo.dwMinorVersion == 2)
ret = 1;
break;
case SD_WIN_VER_VISTA: /* Vista workstation or Longhorn server */
if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
OsVerInfo.dwMajorVersion == 6 && OsVerInfo.dwMinorVersion == 0)
ret = 1;
break;
default:
ret = -1; /* invalid ver */
}
return (ret);
}
/************************************************************************/
/* logLastError */
/*----------------------------------------------------------------------*/
/* Parameters: */
/* Return values: */
/************************************************************************/
static ST_VOID logLastError (DWORD errCode)
{
LPVOID lpMsgBuf;
DWORD len;
len = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
errCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf,
0,
NULL);
if(len == 0) /* FormatMessage failed... */
return;
GLBSEM_LOG_CERR1 (" -> %s", lpMsgBuf);
// Free the buffer.
LocalFree( lpMsgBuf );
}
#endif
Reference in New Issue View Git Blame Copy Permalink