pegasus/src/Pegasus/Common/Mutex.cpp - diff

Return to Mutex.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Mutex.cpp between version 1.3.14.2 and 1.18.6.1

version 1.3.14.2, 2006/07/28 17:41:27

version 1.18.6.1, 2013/06/03 22:35:13

Line 1

//%2006////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the "Software"),

// EMC Corporation; Symantec Corporation; The Open Group.

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Permission is hereby granted, free of charge, to any person obtaining a copy

//////////////////////////////////////////////////////////////////////////

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// Author: Mike Day (mdday@us.ibm.com)

// Modified By: Markus Mueller

// Ramnath Ravindran (Ramnath.Ravindran@compaq.com)

// David Eger (dteger@us.ibm.com)

// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Aruran, IBM (ashanmug@in.ibm.com) for BUG# 3518

// Reworked By: Mike Brasher (m.brasher@inovadevelopment.com)

//%/////////////////////////////////////////////////////////////////////////////

#include "Mutex.h"

#include "Time.h"

#include "PegasusAssert.h"

#include "Once.h"

#include "Exception.h"

#include "System.h"

#define MUTEX_LOCK_FAILED_KEY "Common.InternalException.MUTEX_LOCK_FAILED"

#define MUTEX_LOCK_FAILED_MSG "Failed to acquire mutex lock: $0"

PEGASUS_NAMESPACE_BEGIN

Line 59

Line 49

#if defined(PEGASUS_HAVE_PTHREADS)

static Once _once = PEGASUS_ONCE_INITIALIZER;

static pthread_mutexattr_t _attr;

static void _init_attr()

{

pthread_mutexattr_init(&_attr);

pthread_mutexattr_settype(&_attr, PTHREAD_MUTEX_RECURSIVE);

}

Mutex::Mutex()

{

pthread_mutexattr_init(&_rep.attr);

once(&_once, _init_attr);

pthread_mutex_init(&_rep.mutex, &_attr);

#if defined(PEGASUS_DEBUG)

_rep.count = 0;

#endif

}

// If your platform does not define PTHREAD_MUTEX_RECURSIVE, try

Mutex::Mutex(RecursiveTag)

// PTHREAD_MUTEX_RECURSIVE_NP.

{

pthread_mutexattr_settype(&_rep.attr, PTHREAD_MUTEX_RECURSIVE);

once(&_once, _init_attr);

pthread_mutex_init(&_rep.mutex, &_attr);

#if defined(PEGASUS_DEBUG)

_rep.count = 0;

#endif

}

pthread_mutex_init(&_rep.mutex, &_rep.attr);

Mutex::Mutex(NonRecursiveTag)

_rep.owner.clear();

{

pthread_mutex_init(&_rep.mutex, NULL);

#if defined(PEGASUS_DEBUG)

_rep.count = 0;

#endif

}

Mutex::~Mutex()

{

PEGASUS_DEBUG_ASSERT(_magic);

pthread_mutex_destroy(&_rep.mutex);

if (pthread_mutex_destroy(&_rep.mutex) == 0)

pthread_mutexattr_destroy(&_rep.attr);

}

void Mutex::lock(ThreadType caller)

void Mutex::lock()

{

PEGASUS_DEBUG_ASSERT(_magic);

switch (pthread_mutex_lock(&_rep.mutex))

int r = pthread_mutex_lock(&_rep.mutex);

{

case 0:

_rep.owner = caller;

break;

case EDEADLK:

if (r == 0)

throw Deadlock(_rep.owner);

{

#if defined(PEGASUS_DEBUG)

_rep.count++;

#endif

}

else

{

if (r != -1)

{

// Special behavior for Single UNIX Specification, Version 3

errno = r;

}

default:

throw Exception(MessageLoaderParms(

throw WaitFailed(_rep.owner);

MUTEX_LOCK_FAILED_KEY,

MUTEX_LOCK_FAILED_MSG,

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

void Mutex::try_lock(ThreadType caller)

Boolean Mutex::try_lock()

{

PEGASUS_DEBUG_ASSERT(_magic);

switch (pthread_mutex_trylock(&_rep.mutex))

int r = pthread_mutex_trylock(&_rep.mutex);

{

case 0:

_rep.owner = caller;

break;

case EBUSY:

if (r == 0)

throw AlreadyLocked(_rep.owner);

{

#if defined(PEGASUS_DEBUG)

_rep.count++;

#endif

return true;

}

case EDEADLK:

if (r != -1)

throw Deadlock(_rep.owner);

{

// Special behavior for Single UNIX Specification, Version 3

errno = r;

}

default:

if (errno == EBUSY)

throw WaitFailed(_rep.owner);

{

return false;

}

throw Exception(MessageLoaderParms(

MUTEX_LOCK_FAILED_KEY,

MUTEX_LOCK_FAILED_MSG,

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

void Mutex::timed_lock(Uint32 milliseconds, ThreadType caller)

Boolean Mutex::timed_lock(Uint32 milliseconds)

{

PEGASUS_DEBUG_ASSERT(_magic);

struct timeval now;

struct timeval finish;

struct timeval remaining;

Line 135

Line 163

finish.tv_usec = usec % 1000000;

}

for (;;)

while (!try_lock())

{

switch (pthread_mutex_trylock(&_rep.mutex))

{

case 0:

return;

case EBUSY:

{

gettimeofday(&now, NULL);

if (Time::subtract(&remaining, &finish, &now))

throw TimeOut(Threads::self());

{

return false;

}

Threads::yield();

break;

}

case EDEADLK:

return true;

throw Deadlock(Threads::self());

default:

throw WaitFailed(Threads::self());

}

void Mutex::unlock()

{

PEGASUS_DEBUG_ASSERT(_magic);

PEGASUS_DEBUG_ASSERT(_rep.count > 0);

ThreadType owner = _rep.owner;

#if defined(PEGASUS_DEBUG)

_rep.owner.clear();

_rep.count--;

#endif

if (pthread_mutex_unlock(&_rep.mutex) != 0)

// All documented error codes represent coding errors.

{

PEGASUS_FCT_EXECUTE_AND_ASSERT(0, pthread_mutex_unlock(&_rep.mutex));

_rep.owner = owner;

throw Permission(_rep.owner);

}

#if defined(PEGASUS_OS_LINUX)

void Mutex::reinitialize()

{

pthread_mutex_init(&_rep.mutex, &_attr);

#if defined(PEGASUS_DEBUG)

_rep.count = 0;

#endif

}

#endif

#endif /* PEGASUS_HAVE_PTHREADS */

Line 186

Line 211

#if defined(PEGASUS_HAVE_WINDOWS_THREADS)

static inline void _initialize(MutexRep& rep)

{

rep.handle = CreateMutex(NULL, FALSE, NULL);

if (rep.handle == NULL)

{

throw Exception(MessageLoaderParms(

"Common.InternalException.CREATE_MUTEX_FAILED",

"CreateMutex failed : $0",

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

rep.count = 0;

}

Mutex::Mutex()

{

_rep.handle = CreateMutex(NULL, FALSE, NULL);

_initialize(_rep);

_rep.owner = ThreadType(0);

}

_rep.count.clear();

Mutex::Mutex(RecursiveTag)

{

_initialize(_rep);

}

Mutex::Mutex(NonRecursiveTag)

{

_initialize(_rep);

}

Mutex::~Mutex()

Line 201

Line 247

CloseHandle(_rep.handle);

}

void Mutex::lock(ThreadType caller)

void Mutex::lock()

{

PEGASUS_DEBUG_ASSERT(_magic);

DWORD rc = WaitForSingleObject(_rep.handle, INFINITE);

if (rc == WAIT_FAILED)

throw WaitFailed(_rep.owner);

{

throw Exception(MessageLoaderParms(

MUTEX_LOCK_FAILED_KEY,

MUTEX_LOCK_FAILED_MSG,

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

_rep.owner = caller;

_rep.count++;

}

void Mutex::try_lock(ThreadType caller)

Boolean Mutex::try_lock()

{

PEGASUS_DEBUG_ASSERT(_magic);

DWORD rc = WaitForSingleObject(_rep.handle, 0);

if (rc == WAIT_TIMEOUT)

throw AlreadyLocked(_rep.owner);

{

return false;

}

if (rc == WAIT_FAILED)

throw WaitFailed(_rep.owner);

{

throw Exception(MessageLoaderParms(

MUTEX_LOCK_FAILED_KEY,

MUTEX_LOCK_FAILED_MSG,

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

_rep.owner = caller;

_rep.count++;

return true;

}

void Mutex::timed_lock(Uint32 milliseconds , ThreadType caller)

Boolean Mutex::timed_lock(Uint32 milliseconds)

{

PEGASUS_DEBUG_ASSERT(_magic);

DWORD rc = WaitForSingleObject(_rep.handle, milliseconds);

if (rc == WAIT_TIMEOUT)

throw TimeOut(_rep.owner);

return false;

if (rc == WAIT_FAILED)

throw WaitFailed(_rep.owner);

{

throw Exception(MessageLoaderParms(

MUTEX_LOCK_FAILED_KEY,

MUTEX_LOCK_FAILED_MSG,

PEGASUS_SYSTEM_ERRORMSG_NLS));

}

_rep.owner = caller;

_rep.count++;

return true;

}

void Mutex::unlock()

{

PEGASUS_DEBUG_ASSERT(_magic);

PEGASUS_DEBUG_ASSERT(_rep.count > 0);

_rep.owner.clear();

_rep.count--;

ReleaseMutex(_rep.handle);

}

Legend:

Removed from v.1.3.14.2
changed lines
	Added in v.1.18.6.1

No CVS admin address has been configured