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 snippet: typedef struct _SHARED_MUTEX_HEADER { pthread_mutex_t m_mutex; uint32_t instanceCount; unsigned pid; bool isValid; } SHARED_MUTEX_HEADER; SHARED_MUTEX_HEADER *CreateMutex(char *name) { SHARED_MUTEX_HEADER *pMem = shm_alloc_ptr(name); pthread_mutexattr_t attr; ::pthread_mutexattr_init(&attr); ::pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); if(0!=::pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED)) m_valid = false; else if(0==::pthread_mutex_init(&pMem->m_mutex, &attr)) m_valid = true; else m_valid = false; ::pthread_mutexattr_destroy(&attr); 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. int TryMutex(SHARED_MUTEX_HEADER *pMem) { if(::pthread_mutex_trylock(&pMem->m_mutex) == EBUSY) { if(IsAlive(pMem->pid) == false) return RETURN_CODE_ABANDONED; if(::pthread_mutex_trylock(&pMem->m_mutex) == EBUSY) return RETURN_CODE_FAILURE; } pMem->pid = getpid(); return RETURN_CODE_SUCCESS; } -----Original Message----- From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] 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 list: 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, Razvan