+2002-09-30 Robert Collins <rbtcollins@hotmail.com>
+
+ * pthread.cc (pthread_mutex_init): Use new pthread_mutex::init.
+ * thread.cc: Change __pthread_mutex_init to pthread_mutex::init
+ throughout.
+ (MTinterface::Init): Initialise pthread_mutex support.
+ (pthread_mutex::mutexInitializationLock): Instantiate.
+ (pthread_mutex::initMutex): New method.
+ (__pthread_cond_dowait): Don't dereference untrusted pointers.
+ Use the new pthread_mutex::init method.
+ (__pthread_condattr_init): Don't dereference untrusted pointers.
+ (__pthread_mutex_init): Rename to pthread_mutex::init.
+ Lock and release mutexInitializationLock to prevent races on
+ mutex initialisation.
+ * thread.h (pthread_mutex::initMutex): New method, initialise
+ pthread_mutex supporting state on process initialisation.
+ (pthread_mutex::init): Initialise a single mutex.
+ (pthread_mutex::mutexInitializationLock): A win32 mutex for
+ syncronising pthread mutex initialisation.
+ (__pthread_mutex_init): Remove this.
+
2002-09-28 Christopher Faylor <cgf@redhat.com>
* thread.h (verifyable_object:~verifyable_object): Make virtual.
threadcount = 1; /*1 current thread when Init occurs.*/
pthread::initMainThread (&mainthread, myself->hProcess);
+ pthread_mutex::initMutex ();
if (forked)
return;
return true;
}
+HANDLE pthread_mutex::mutexInitializationLock;
+
+/* We can only be called once.
+ * TODO: (no rush) use a non copied memory section to
+ * hold an initialization flag.
+ */
+void
+pthread_mutex::initMutex ()
+{
+ mutexInitializationLock = CreateMutex (NULL, FALSE, NULL);
+ if (!mutexInitializationLock)
+ api_fatal ("Could not create win32 Mutex for pthread mutex static initializer support. The error code was %d\n", GetLastError());
+
+}
+
pthread_mutex::pthread_mutex (pthread_mutexattr *attr):verifyable_object (PTHREAD_MUTEX_MAGIC)
{
/*attr checked in the C call */
// broadcast occurs - we miss the broadcast. the functions aren't split properly.
int rv;
pthread_mutex **themutex = NULL;
- if (*mutex == PTHREAD_MUTEX_INITIALIZER)
- __pthread_mutex_init (mutex, NULL);
+ if (pthread_mutex::isGoodInitializer (mutex))
+ pthread_mutex::init (mutex, NULL);
themutex = mutex;
if (pthread_cond::isGoodInitializer (cond))
__pthread_cond_init (cond, NULL);
int
__pthread_condattr_init (pthread_condattr_t *condattr)
{
- /* FIXME: we dereference blindly! */
+ if (check_valid_pointer (condattr))
+ return EINVAL;
*condattr = new pthread_condattr;
if (!pthread_condattr::isGoodObject (condattr))
{
*/
int
-__pthread_mutex_init (pthread_mutex_t *mutex,
+pthread_mutex::init (pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr)
{
if (attr && !pthread_mutexattr::isGoodObject (attr) || check_valid_pointer (mutex))
return EINVAL;
+ DWORD waitResult = WaitForSingleObject (mutexInitializationLock, INFINITE);
+ if (waitResult != WAIT_OBJECT_0)
+ {
+ system_printf ("Recieved a unexpected wait result on mutexInitializationLock %d\n", waitResult);
+ return EINVAL;
+ }
/* FIXME: bugfix: we should check *mutex being a valid address */
- if (pthread_mutex::isGoodObject (mutex))
- return EBUSY;
+ if (isGoodObject (mutex))
+ {
+ if (! ReleaseMutex(mutexInitializationLock))
+ system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
+ return EBUSY;
+ }
*mutex = new pthread_mutex (attr ? (*attr) : NULL);
- if (!pthread_mutex::isGoodObject (mutex))
+ if (!isGoodObject (mutex))
{
delete (*mutex);
*mutex = NULL;
+ if (! ReleaseMutex(mutexInitializationLock))
+ system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
return EAGAIN;
}
+ if (! ReleaseMutex(mutexInitializationLock))
+ system_printf ("Recieved a unexpected result releasing mutexInitializationLock %d\n", GetLastError());
return 0;
}
{
pthread_mutex_t *themutex = (pthread_mutex_t *) mutex;
if (pthread_mutex::isGoodInitializer (mutex))
- __pthread_mutex_init ((pthread_mutex_t *) mutex, NULL);
+ pthread_mutex::init ((pthread_mutex_t *) mutex, NULL);
if (!pthread_mutex::isGoodObject (themutex))
return EINVAL;
/*We don't define _POSIX_THREAD_PRIO_PROTECT because we do't currently support
case VALID_STATIC_OBJECT:
if (pthread_mutex::isGoodInitializer (mutex))
{
- int rv = __pthread_mutex_init (mutex, NULL);
+ int rv = pthread_mutex::init (mutex, NULL);
if (rv)
return rv;
}
+ /* No else needed. If it's been initialized while we waited,
+ * we can just attempt to lock it
+ */
break;
case VALID_OBJECT:
break;
{
pthread_mutex_t *themutex = mutex;
if (pthread_mutex::isGoodInitializer (mutex))
- __pthread_mutex_init (mutex, NULL);
+ pthread_mutex::init (mutex, NULL);
if (!pthread_mutex::isGoodObject (themutex))
return EINVAL;
if ((*themutex)->TryLock ())
__pthread_mutex_unlock (pthread_mutex_t *mutex)
{
if (pthread_mutex::isGoodInitializer (mutex))
- __pthread_mutex_init (mutex, NULL);
+ pthread_mutex::init (mutex, NULL);
if (!pthread_mutex::isGoodObject (mutex))
return EINVAL;
(*mutex)->UnLock ();
{
pthread_mutex_t *themutex = mutex;
if (pthread_mutex::isGoodInitializer (mutex))
- __pthread_mutex_init (mutex, NULL);
+ pthread_mutex::init (mutex, NULL);
if (!pthread_mutex::isGoodObject (themutex))
return EINVAL;
return ENOSYS;
static bool isGoodObject(pthread_mutex_t const *);
static bool isGoodInitializer(pthread_mutex_t const *);
static bool isGoodInitializerOrObject(pthread_mutex_t const *);
+ static void initMutex ();
+ static int init (pthread_mutex_t *, const pthread_mutexattr_t *);
+
CRITICAL_SECTION criticalsection;
HANDLE win32_obj_id;
LONG condwaits;
pthread_mutex (pthread_mutexattr * = NULL);
pthread_mutex (pthread_mutex_t *, pthread_mutexattr *);
~pthread_mutex ();
+private:
+ static HANDLE mutexInitializationLock;
};
class pthread:public verifyable_object
int __pthread_equal (pthread_t * t1, pthread_t * t2);
/* Mutexes */
-int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
int __pthread_mutex_lock (pthread_mutex_t *);
int __pthread_mutex_trylock (pthread_mutex_t *);
int __pthread_mutex_unlock (pthread_mutex_t *);