apr-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Daniel May" <dan...@spryware.com>
Subject RE: Cross Process Mutex
Date Mon, 21 Nov 2005 01:58:43 GMT
The solution we used was specific to the pthreads mutex implementation.
I am not sure what the formal definitions of proc and global mutex's are
in the scope of APR, but I needed a global mutex that would hold across
two or more independent processes.

We chose the shared memory route using pthreads.  Here is a code

typedef struct _SHARED_MUTEX_HEADER  
	pthread_mutex_t  m_mutex;
	uint32_t	instanceCount;
	unsigned	pid;
	bool		isValid;

SHARED_MUTEX_HEADER *CreateMutex(char *name)
            SHARED_MUTEX_HEADER *pMem = shm_alloc_ptr(name);
		pthread_mutexattr_t  attr;	

			m_valid = false;
		else if(0==::pthread_mutex_init(&pMem->m_mutex, &attr))
			m_valid = true;
			m_valid = false;

		pMem->isValid = m_valid;
            return pMem;

Of course, this is pseudo code, assuming you have something called
shm_alloc_ptr() that returns a pointer to shared mem.
We are using the APR apr_shm_* calls for this.

There is also the possiblility that that mutex will get orphaned if the
process who last took ownership of the shared memory dies, so we added
the pid to the structure so we can verify if the current owner of the
mutex is still alive.

	if(::pthread_mutex_trylock(&pMem->m_mutex) == EBUSY)
		if(IsAlive(pMem->pid) == false)
            if(::pthread_mutex_trylock(&pMem->m_mutex) == EBUSY)
	pMem->pid = getpid();


-----Original Message-----
From: cbrazvan@laitek.com [mailto:cbrazvan@laitek.com] 
Sent: Sunday, November 20, 2005 3:46 PM
To: Daniel May
Subject: Cross Process Mutex

Hello Daniel.

First of all, I hope you will indulge my intrusion and will forgive me
for contacting you directly.

I am having exactly the same problem you describe on APR-dev mailing
developing name based cross-process locking on *nix systems.
I'm trying to figure this one out for several hours now and all my hopes
are shattered.

One of the posts there was proposing a shared-memory based mutex-lookup
mechanism, which was what I originally thought I needed to do.
Using file-based locks would be another approach, but trusting the
file-system doing a good job on this in a time-critical environment
would probably be foolish.

Have you found a good, simple solution to this?

Thank you and best regards,

View raw message