semrw-generic.cpp revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/* $Id$ */
/** @file
* Excerpt from kProfileR3.cpp.
*/
/*
* Copyright (c) 2005-2007 knut st. osmundsen <bird-src-spam@anduin.net>
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License as published by the Free Software Foundation,
* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
* distribution. VirtualBox OSE is distributed in the hope that it will
* be useful, but WITHOUT ANY WARRANTY of any kind.
*
* If you received this file as part of a commercial VirtualBox
* distribution, then only the terms of your commercial VirtualBox
* license agreement apply instead of the previous paragraph.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#if defined(__WIN__)
# include <windows.h>
# include <psapi.h>
# include <malloc.h>
# define IN_RING3
# if _MSC_VER >= 1400
# include <intrin.h>
# define HAVE_INTRIN
# endif
# define KPRF_USE_PTHREAD
# include <pthread.h>
# include <stdint.h>
# define KPRF_USE_MMAN
# include <unistd.h>
# include <stdlib.h>
# ifndef O_BINARY
# define O_BINARY 0
# endif
# define INCL_BASE
# include <os2s.h>
# include <stdint.h>
#else
# error "not ported to this OS..."
#endif
/*
* Instantiate the header.
*/
#else
#endif
#if 1
# ifdef __GNUC__
# define KPRF_ASSERT(expr) do { if (!(expr)) { __asm__ __volatile__("int3\n\tnop\n\t");} } while (0)
# else
} } while (0)
# endif
#else
# define KPRF_ASSERT(expr) do { } while (0)
#endif
#include "prfcore.h.h"
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/** Mutex lock type. */
#if defined(KPRF_USE_PTHREAD)
#endif
/** Pointer to a mutex lock. */
#if defined(KPRF_USE_PTHREAD)
typedef enum KPRF_TYPE(,RWLOCKSTATE)
{
RWLOCK_STATE_32BIT_HACK = 0x7fffffff
} KPRF_TYPE(,RWLOCKSTATE);
/** Update the state. */
{
/** This mutex serialize the access and updating of the members
* of this structure. */
/** The current number of readers. */
/** The number of readers waiting. */
/** The current number of waiting writers. */
# if defined(__WIN__)
/** The handle of the event object on which the waiting readers block. (manual reset). */
/** The handle of the event object on which the waiting writers block. (manual reset). */
/** The handle of the event semaphore on which the waiting readers block. */
/** The handle of the event semaphore on which the waiting writers block. */
# endif
/** The current state of the read-write lock. */
#endif
/**
* Initializes a mutex.
*
* @returns 0 on success.
* @returns -1 on failure.
* @param pMutex The mutex to init.
*/
{
#if defined(KPRF_USE_PTHREAD)
return 0;
return -1;
return 0;
if (!_fmutex_create(pMutex, 0))
return 0;
return -1;
#endif
}
/**
* Deletes a mutex.
*
* @param pMutex The mutex to delete.
*/
{
#if defined(KPRF_USE_PTHREAD)
#endif
}
/**
* Locks a mutex.
* @param pMutex The mutex lock.
*/
{
#if defined(__WIN__)
#elif defined(KPRF_USE_PTHREAD)
#endif
}
/**
* Unlocks a mutex.
* @param pMutex The mutex lock.
*/
{
#if defined(__WIN__)
#elif defined(KPRF_USE_PTHREAD)
#endif
}
/**
* Initializes a read-write lock.
*
* @returns 0 on success.
* @returns -1 on failure.
* @param pRWLock The read-write lock to initialize.
*/
{
#if defined(KPRF_USE_PTHREAD)
return 0;
return -1;
return -1;
pRWLock->cReadersWaiting = 0;
pRWLock->cWritersWaiting = 0;
# if defined(__WIN__)
return 0;
if (!rc)
{
if (!rc)
return 0;
}
# endif
return -1;
#endif
}
/**
* Deleters a read-write lock.
*
* @param pRWLock The read-write lock to delete.
*/
{
#if defined(KPRF_USE_PTHREAD)
return;
pRWLock->cReadersWaiting = 0;
pRWLock->cWritersWaiting = 0;
# if defined(__WIN__)
# endif
#endif
}
/**
* Acquires read access to the read-write lock.
* @param pRWLock The read-write lock.
*/
{
#if defined(KPRF_USE_PTHREAD)
return;
{
return;
}
for (;;)
{
/* have to wait */
# if defined(__WIN__)
# endif
# if defined(__WIN__)
{
case WAIT_IO_COMPLETION:
case WAIT_TIMEOUT:
case WAIT_OBJECT_0:
break;
case WAIT_ABANDONED:
default:
return;
}
{
case NO_ERROR:
case ERROR_SEM_TIMEOUT:
case ERROR_TIMEOUT:
case ERROR_INTERRUPT:
break;
default:
return;
}
# endif
{
return;
}
}
#endif
}
/**
* Releases read access to the read-write lock.
* @param pRWLock The read-write lock.
*/
{
#if defined(KPRF_USE_PTHREAD)
return;
/*
* If we're still in the shared state, or if there
* are more readers out there, or if there are no
* waiting writers, all we have to do is decrement an leave.
*
* That's the most frequent, thing and should be fast.
*/
|| !pRWLock->cWritersWaiting)
{
return;
}
/*
* Wake up one (or more on OS/2) waiting writers.
*/
# if defined(__WIN__)
# endif
#endif
}
/**
* Acquires write access to the read-write lock.
* @param pRWLock The read-write lock.
*/
{
#if defined(KPRF_USE_PTHREAD)
return;
)
{
return;
}
/*
* We'll have to wait.
*/
for (;;)
{
# if defined(__WIN__)
# endif
# if defined(__WIN__)
{
case WAIT_IO_COMPLETION:
case WAIT_TIMEOUT:
case WAIT_OBJECT_0:
break;
case WAIT_ABANDONED:
default:
return;
}
{
case NO_ERROR:
case ERROR_SEM_TIMEOUT:
case ERROR_TIMEOUT:
case ERROR_INTERRUPT:
break;
default:
return;
}
# endif
/*
* Try acquire the lock.
*/
)
{
return;
}
}
#endif
}
/**
* Releases write access to the read-write lock.
* @param pRWLock The read-write lock.
*/
{
#if defined(KPRF_USE_PTHREAD)
return;
/*
* The common thing is that there are noone waiting.
* But, before that usual paranoia.
*/
{
return;
}
if ( !pRWLock->cReadersWaiting
&& !pRWLock->cWritersWaiting)
{
return;
}
/*
* Someone is waiting, wake them up as we change the state.
*/
# if defined(__WIN__)
# endif
if (pRWLock->cWritersWaiting)
{
}
else
{
}
# if defined(__WIN__)
# endif
#endif
}