As discussed earlier on new-httpd and [EMAIL PROTECTED], the lock scope
CROSS_PROCESS is not portable, where LOCKALL is. I've fixed
that by simply removing CROSS_PROCESS. The scopes we have left use names
that are overloaded and confusing (LOCKALL vs CROSS_PROCESS huh?)
so I went ahead and dropped the whole thing in favor of something
more consistent and disambiguous, the POSIXified names:
APR_PROCESS_PRIVATE -- (old INTRAPROCESS) synchronizes threads in the current
process.
APR_PROCESS_SHARED -- (old CROSS_PROCESS *and* LOCKALL) synchronizes threads
across processes and their threads. Essentially acts as global lock
on all platforms.
The two patches must be applied in order (apr first, then httpd) since
one depends on the other. The httpd changes were simple string
replacements, but I looked them over before submitting. The apr changes
seemed to work fine with the various apr/test/ routines on my platform
(linux 2.4), but I don't have access to all the platforms that this
patch might affect.
-aaron
Index: srclib/apr/file_io/os2/open.c
===================================================================
RCS file: /home/cvspublic/apr/file_io/os2/open.c,v
retrieving revision 1.42
diff -u -r1.42 open.c
--- srclib/apr/file_io/os2/open.c 2001/06/07 14:32:10 1.42
+++ srclib/apr/file_io/os2/open.c 2001/07/02 17:55:57
@@ -98,7 +98,7 @@
if (dafile->buffered) {
dafile->buffer = apr_palloc(cntxt, APR_FILE_BUFSIZE);
- rv = apr_lock_create(&dafile->mutex, APR_MUTEX, APR_INTRAPROCESS,
NULL, cntxt);
+ rv = apr_lock_create(&dafile->mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, cntxt);
if (rv)
return rv;
Index: srclib/apr/file_io/unix/filedup.c
===================================================================
RCS file: /home/cvspublic/apr/file_io/unix/filedup.c,v
retrieving revision 1.30
diff -u -r1.30 filedup.c
--- srclib/apr/file_io/unix/filedup.c 2001/06/27 19:40:34 1.30
+++ srclib/apr/file_io/unix/filedup.c 2001/07/02 17:55:58
@@ -80,7 +80,7 @@
(*new_file)->buffered = old_file->buffered;
if ((*new_file)->buffered) {
#if APR_HAS_THREADS
- apr_lock_create(&((*new_file)->thlock), APR_MUTEX, APR_INTRAPROCESS,
NULL,
+ apr_lock_create(&((*new_file)->thlock), APR_MUTEX,
APR_PROCESS_PRIVATE, NULL,
p);
#endif
(*new_file)->buffer = apr_palloc(p, APR_FILE_BUFSIZE);
Index: srclib/apr/file_io/unix/open.c
===================================================================
RCS file: /home/cvspublic/apr/file_io/unix/open.c,v
retrieving revision 1.77
diff -u -r1.77 open.c
--- srclib/apr/file_io/unix/open.c 2001/06/27 19:40:34 1.77
+++ srclib/apr/file_io/unix/open.c 2001/07/02 17:55:58
@@ -114,8 +114,8 @@
if ((*new)->buffered) {
(*new)->buffer = apr_palloc(cont, APR_FILE_BUFSIZE);
#if APR_HAS_THREADS
- rv = apr_lock_create(&((*new)->thlock), APR_MUTEX, APR_INTRAPROCESS,
- NULL, cont);
+ rv = apr_lock_create(&((*new)->thlock), APR_MUTEX,
+ APR_PROCESS_PRIVATE, NULL, cont);
if (rv) {
return rv;
}
Index: srclib/apr/file_io/win32/open.c
===================================================================
RCS file: /home/cvspublic/apr/file_io/win32/open.c,v
retrieving revision 1.77
diff -u -r1.77 open.c
--- srclib/apr/file_io/win32/open.c 2001/06/27 19:40:41 1.77
+++ srclib/apr/file_io/win32/open.c 2001/07/02 17:56:00
@@ -272,7 +272,7 @@
if (flag & APR_BUFFERED) {
(*new)->buffered = 1;
(*new)->buffer = apr_palloc(cont, APR_FILE_BUFSIZE);
- rv = apr_lock_create(&(*new)->mutex, APR_MUTEX, APR_INTRAPROCESS,
NULL, cont);
+ rv = apr_lock_create(&(*new)->mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, cont);
if (rv) {
if (file_cleanup(*new) == APR_SUCCESS) {
Index: srclib/apr/include/apr_lock.h
===================================================================
RCS file: /home/cvspublic/apr/include/apr_lock.h,v
retrieving revision 1.28
diff -u -r1.28 apr_lock.h
--- srclib/apr/include/apr_lock.h 2001/06/26 02:05:00 1.28
+++ srclib/apr/include/apr_lock.h 2001/07/02 17:56:01
@@ -67,8 +67,13 @@
* @package APR lock library
*/
-typedef enum {APR_CROSS_PROCESS, APR_INTRAPROCESS, APR_LOCKALL}
apr_lockscope_e;
+/* Support for code that's still using the old lockscope enums. */
+#define APR_INTRAPROCESS APR_PROCESS_PRIVATE
+#define APR_CROSS_PROCESS APR_PROCESS_SHARED
+#define APR_LOCKALL APR_PROCESS_SHARED
+typedef enum {APR_PROCESS_PRIVATE, APR_PROCESS_SHARED} apr_lockscope_e;
+
typedef enum {APR_MUTEX, APR_READWRITE} apr_locktype_e;
typedef enum {APR_READER, APR_WRITER} apr_readerwriter_e;
@@ -87,17 +92,15 @@
* </PRE>
* @param scope The scope of the lock to create, one of:
* <PRE>
- * APR_CROSS_PROCESS lock processes from the protected area.
- * APR_INTRAPROCESS lock threads from the protected area.
- * APR_LOCKALL lock processes and threads from the
- * protected area.
+ * APR_PROCESS_PRIVATE lock only threads in this process from
+ * the protected area.
+ * APR_PROCESS_SHARED lock threads in this and other processes
+ * from the protected area.
* </PRE>
* @param fname A file name to use if the lock mechanism requires one. This
* argument should always be provided. The lock code itself will
* determine if it should be used.
* @param pool The pool to operate on.
- * @tip APR_CROSS_PROCESS may lock both processes and threads, but it is
- * only guaranteed to lock processes.
* @deffunc apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e
type, apr_lockscope_e scope, const char *fname, apr_pool_t *pool)
*/
APR_DECLARE(apr_status_t) apr_lock_create(apr_lock_t **lock,
@@ -197,10 +200,10 @@
* </PRE>
* @param scope The scope of the lock to create, one of:
* <PRE>
- * APR_CROSS_PROCESS lock processes from the protected area.
- * APR_INTRAPROCESS lock threads from the protected area.
- * APR_LOCKALL lock processes and threads from the
- * protected area.
+ * APR_PROCESS_PRIVATE lock only threads in this process from
+ * the protected area.
+ * APR_PROCESS_SHARED lock threads in this and other processes
+ * from the protected area.
* </PRE>
* @param mech The mechanism to use for the interprocess lock, if any; one of
* <PRE>
@@ -214,8 +217,6 @@
* argument should always be provided. The lock code itself will
* determine if it should be used.
* @param pool The pool to operate on.
- * @tip APR_CROSS_PROCESS may lock both processes and threads, but it is
- * only guaranteed to lock processes.
* @deffunc apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e
type, apr_lockscope_e scope, const char *fname, apr_pool_t *pool)
*/
APR_DECLARE(apr_status_t) apr_lock_create_np(apr_lock_t **lock,
Index: srclib/apr/lib/apr_pools.c
===================================================================
RCS file: /home/cvspublic/apr/lib/apr_pools.c,v
retrieving revision 1.98
diff -u -r1.98 apr_pools.c
--- srclib/apr/lib/apr_pools.c 2001/06/13 16:10:18 1.98
+++ srclib/apr/lib/apr_pools.c 2001/07/02 17:56:02
@@ -805,13 +805,13 @@
stack_var_init(&s);
#endif
#if APR_HAS_THREADS
- status = apr_lock_create(&alloc_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ status = apr_lock_create(&alloc_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, globalp);
if (status != APR_SUCCESS) {
apr_lock_destroy(alloc_mutex);
return status;
}
- status = apr_lock_create(&spawn_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ status = apr_lock_create(&spawn_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, globalp);
if (status != APR_SUCCESS) {
apr_lock_destroy(spawn_mutex);
Index: srclib/apr/locks/os2/locks.c
===================================================================
RCS file: /home/cvspublic/apr/locks/os2/locks.c,v
retrieving revision 1.32
diff -u -r1.32 locks.c
--- srclib/apr/locks/os2/locks.c 2001/06/06 03:18:43 1.32
+++ srclib/apr/locks/os2/locks.c 2001/07/02 17:56:04
@@ -100,7 +100,7 @@
else
semname = apr_pstrcat(pool, "/SEM32/", fname, NULL);
- rc = DosCreateMutexSem(semname, &(new->hMutex), scope == APR_CROSS_PROCESS
? DC_SEM_SHARED : 0, FALSE);
+ rc = DosCreateMutexSem(semname, &(new->hMutex), scope ==
APR_PROCESS_SHARED ? DC_SEM_SHARED : 0, FALSE);
*lock = new;
if (!rc)
Index: srclib/apr/locks/unix/locks.c
===================================================================
RCS file: /home/cvspublic/apr/locks/unix/locks.c,v
retrieving revision 1.59
diff -u -r1.59 locks.c
--- srclib/apr/locks/unix/locks.c 2001/07/02 01:39:10 1.59
+++ srclib/apr/locks/unix/locks.c 2001/07/02 17:56:05
@@ -181,44 +181,39 @@
{
apr_status_t stat;
- if (new->scope != APR_INTRAPROCESS) {
+ if (new->scope == APR_PROCESS_SHARED) {
if ((stat = choose_method(new, mech)) != APR_SUCCESS) {
return stat;
}
}
- if (new->scope != APR_CROSS_PROCESS) {
#if APR_HAS_THREADS
- if (new->type == APR_READWRITE) {
+ if (new->type == APR_READWRITE) {
#if APR_HAS_RWLOCK_SERIALIZE
- new->intra_meth = &apr_unix_rwlock_methods;
-#else
- return APR_ENOTIMPL; /* 'cause we don't have rwlocks */
-#endif
- }
- else {
- new->intra_meth = &apr_unix_intra_methods;
- }
-#else
- if (new->scope == APR_INTRAPROCESS) {
- return APR_ENOTIMPL; /* 'cause we don't have threads */
- }
-#endif
+ new->intra_meth = &apr_unix_rwlock_methods;
+#else /* !APR_HAS_RWLOCK_SERIALIZE */
+ return APR_ENOTIMPL; /* 'cause we don't have rwlocks */
+#endif /* APR_HAS_RWLOCK_SERIALIZE */
+ }
+ else {
+ new->intra_meth = &apr_unix_intra_methods;
+ }
+#else /* !APR_HAS_THREADS */
+ if (new->scope == APR_PROCESS_PRIVATE) {
+ return APR_ENOTIMPL; /* 'cause we don't have threads */
}
+#endif /* APR_HAS_THREADS */
switch (new->scope) {
- case APR_LOCKALL:
+ case APR_PROCESS_SHARED:
if (new->inter_meth->flags & APR_PROCESS_LOCK_MECH_IS_GLOBAL) {
new->meth = new->inter_meth;
}
else {
new->meth = &lockall_methods;
}
- break;
- case APR_CROSS_PROCESS:
- new->meth = new->inter_meth;
break;
- case APR_INTRAPROCESS:
+ case APR_PROCESS_PRIVATE:
new->meth = new->intra_meth;
}
@@ -323,7 +318,7 @@
apr_status_t apr_lock_child_init(apr_lock_t **lock, const char *fname,
apr_pool_t *cont)
{
- if ((*lock)->scope != APR_INTRAPROCESS)
+ if ((*lock)->scope == APR_PROCESS_SHARED)
return (*lock)->meth->child_init(lock, cont, fname);
return APR_SUCCESS;
}
Index: srclib/apr/locks/win32/locks.c
===================================================================
RCS file: /home/cvspublic/apr/locks/win32/locks.c,v
retrieving revision 1.44
diff -u -r1.44 locks.c
--- srclib/apr/locks/win32/locks.c 2001/06/13 14:41:26 1.44
+++ srclib/apr/locks/win32/locks.c 2001/07/02 17:56:06
@@ -66,7 +66,7 @@
switch (lock->type)
{
case APR_MUTEX:
- if (lock->scope == APR_INTRAPROCESS) {
+ if (lock->scope == APR_PROCESS_PRIVATE) {
DeleteCriticalSection(&lock->section);
return APR_SUCCESS;
} else {
@@ -106,14 +106,14 @@
sec.nLength = sizeof(SECURITY_ATTRIBUTES);
sec.lpSecurityDescriptor = NULL;
- if (scope == APR_CROSS_PROCESS || scope == APR_LOCKALL) {
+ if (scope == APR_PROCESS_SHARED) {
sec.bInheritHandle = TRUE;
}
else {
sec.bInheritHandle = FALSE;
}
- if (scope == APR_INTRAPROCESS) {
+ if (scope == APR_PROCESS_PRIVATE) {
InitializeCriticalSection(&newlock->section);
} else {
newlock->mutex = CreateMutex(&sec, FALSE, fname);
@@ -129,7 +129,7 @@
apr_pool_t *pool)
{
/* This routine should not be called (and OpenMutex will fail if called)
- * on a INTRAPROCESS lock
+ * on a INTRAPROCESS (aka PROCESS_PRIVATE) lock.
*/
(*lock) = (apr_lock_t *)apr_palloc(pool, sizeof(apr_lock_t));
@@ -151,7 +151,7 @@
switch (lock->type)
{
case APR_MUTEX:
- if (lock->scope == APR_INTRAPROCESS) {
+ if (lock->scope == APR_PROCESS_PRIVATE) {
EnterCriticalSection(&lock->section);
return APR_SUCCESS;
} else {
@@ -195,7 +195,7 @@
switch (lock->type)
{
case APR_MUTEX:
- if (lock->scope == APR_INTRAPROCESS) {
+ if (lock->scope == APR_PROCESS_PRIVATE) {
LeaveCriticalSection(&lock->section);
return APR_SUCCESS;
} else {
Index: srclib/apr/memory/unix/apr_sms.c
===================================================================
RCS file: /home/cvspublic/apr/memory/unix/apr_sms.c,v
retrieving revision 1.33
diff -u -r1.33 apr_sms.c
--- srclib/apr/memory/unix/apr_sms.c 2001/07/02 16:21:48 1.33
+++ srclib/apr/memory/unix/apr_sms.c 2001/07/02 17:56:09
@@ -253,7 +253,7 @@
apr_sms_assert(sms);
/* Create the sms framework lock we'll use. */
- rv = apr_lock_create(&sms->sms_lock, APR_MUTEX, APR_LOCKALL,
+ rv = apr_lock_create(&sms->sms_lock, APR_MUTEX, APR_PROCESS_SHARED,
NULL, sms->pool);
#if APR_DEBUG_SHOW_FUNCTIONS
Index: srclib/apr/test/testlock.c
===================================================================
RCS file: /home/cvspublic/apr/test/testlock.c,v
retrieving revision 1.3
diff -u -r1.3 testlock.c
--- srclib/apr/test/testlock.c 2001/06/06 22:25:43 1.3
+++ srclib/apr/test/testlock.c 2001/07/02 17:56:10
@@ -142,7 +142,7 @@
printf("RW Lock Tests\n");
printf("%-60s", " Initializing the RW lock");
- s1 = apr_lock_create(&thread_rw_lock, APR_READWRITE, APR_INTRAPROCESS,
+ s1 = apr_lock_create(&thread_rw_lock, APR_READWRITE, APR_PROCESS_PRIVATE,
"lock.file", pool);
if (s1 != APR_SUCCESS) {
printf("Failed!\n");
@@ -190,7 +190,7 @@
printf("Exclusive lock test\n");
printf("%-60s", " Initializing the lock");
- s1 = apr_lock_create(&thread_lock, APR_MUTEX, APR_INTRAPROCESS,
+ s1 = apr_lock_create(&thread_lock, APR_MUTEX, APR_PROCESS_PRIVATE,
"lock.file", pool);
if (s1 != APR_SUCCESS) {
@@ -239,8 +239,8 @@
printf("Testing multiple locking\n");
printf("%-60s"," Creating the lock we'll use");
- if ((rv = apr_lock_create(&multi, APR_MUTEX, APR_LOCKALL,"multi.lock",
- pool)) != APR_SUCCESS) {
+ if ((rv = apr_lock_create(&multi, APR_MUTEX, APR_PROCESS_SHARED,
+ "multi.lock", pool)) != APR_SUCCESS) {
printf("Failed!\n");
return rv;
}
Index: srclib/apr/test/testthread.c
===================================================================
RCS file: /home/cvspublic/apr/test/testthread.c,v
retrieving revision 1.17
diff -u -r1.17 testthread.c
--- srclib/apr/test/testthread.c 2001/03/14 15:56:44 1.17
+++ srclib/apr/test/testthread.c 2001/07/02 17:56:11
@@ -148,7 +148,7 @@
fprintf(stdout, "OK\n");
fprintf(stdout, "Initializing the lock.......");
- s1 = apr_lock_create(&thread_lock, APR_MUTEX, APR_INTRAPROCESS,
"lock.file", context);
+ s1 = apr_lock_create(&thread_lock, APR_MUTEX, APR_PROCESS_PRIVATE,
"lock.file", context);
if (s1 != APR_SUCCESS) {
fprintf(stderr, "Could not create lock\n");
exit(-1);
Index: modules/aaa/mod_auth_digest.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/modules/aaa/mod_auth_digest.c,v
retrieving revision 1.48
diff -u -r1.48 mod_auth_digest.c
--- modules/aaa/mod_auth_digest.c 2001/05/22 01:31:03 1.48
+++ modules/aaa/mod_auth_digest.c 2001/07/02 17:59:34
@@ -363,7 +363,7 @@
client_list->num_entries = 0;
tmpnam(client_lock_name);
- sts = apr_lock_create(&client_lock, APR_READWRITE, APR_LOCKALL,
+ sts = apr_lock_create(&client_lock, APR_READWRITE, APR_PROCESS_SHARED,
client_lock_name, ctx);
if (sts != APR_SUCCESS) {
log_error_and_cleanup("failed to create lock", sts, s);
@@ -381,7 +381,7 @@
*opaque_cntr = 1UL;
tmpnam(opaque_lock_name);
- sts = apr_lock_create(&opaque_lock, APR_MUTEX, APR_LOCKALL,
+ sts = apr_lock_create(&opaque_lock, APR_MUTEX, APR_PROCESS_SHARED,
opaque_lock_name, ctx);
if (sts != APR_SUCCESS) {
log_error_and_cleanup("failed to create lock", sts, s);
Index: modules/mappers/mod_rewrite.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/modules/mappers/mod_rewrite.c,v
retrieving revision 1.77
diff -u -r1.77 mod_rewrite.c
--- modules/mappers/mod_rewrite.c 2001/05/18 18:38:41 1.77
+++ modules/mappers/mod_rewrite.c 2001/07/02 17:59:39
@@ -941,7 +941,7 @@
proxy_available = (ap_find_linked_module("mod_proxy.c") != NULL);
/* create the rewriting lockfiles in the parent */
- if ((rv = apr_lock_create (&rewrite_log_lock, APR_MUTEX, APR_LOCKALL,
+ if ((rv = apr_lock_create (&rewrite_log_lock, APR_MUTEX,
APR_PROCESS_SHARED,
NULL, p)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
"mod_rewrite: could not create rewrite_log_lock");
@@ -3263,7 +3263,7 @@
lockname = ap_server_root_relative(p, lockname);
/* create the lockfile */
- rc = apr_lock_create (&rewrite_mapr_lock_acquire, APR_MUTEX, APR_LOCKALL,
lockname, p);
+ rc = apr_lock_create (&rewrite_mapr_lock_acquire, APR_MUTEX,
APR_PROCESS_SHARED, lockname, p);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
"mod_rewrite: Parent could not create RewriteLock "
Index: modules/ssl/ssl_engine_mutex.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/modules/ssl/ssl_engine_mutex.c,v
retrieving revision 1.5
diff -u -r1.5 ssl_engine_mutex.c
--- modules/ssl/ssl_engine_mutex.c 2001/05/05 19:09:37 1.5
+++ modules/ssl/ssl_engine_mutex.c 2001/07/02 17:59:41
@@ -70,7 +70,7 @@
if (mc->nMutexMode == SSL_MUTEXMODE_NONE)
return TRUE;
- if (apr_lock_create(&mc->pMutex, APR_MUTEX, APR_LOCKALL,
+ if (apr_lock_create(&mc->pMutex, APR_MUTEX, APR_PROCESS_SHARED,
mc->szMutexFile, p) != APR_SUCCESS)
return FALSE;
return TRUE;
Index: server/mpm/beos/beos.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/beos/beos.c,v
retrieving revision 1.53
diff -u -r1.53 beos.c
--- server/mpm/beos/beos.c 2001/06/27 17:43:33 1.53
+++ server/mpm/beos/beos.c 2001/07/02 17:59:46
@@ -740,7 +740,7 @@
* used to lock around select so we only have one thread
* in select at a time
*/
- if ((rv = apr_lock_create(&accept_mutex, APR_MUTEX, APR_CROSS_PROCESS,
+ if ((rv = apr_lock_create(&accept_mutex, APR_MUTEX, APR_PROCESS_SHARED,
NULL, pconf)) != APR_SUCCESS) {
/* tsch tsch, can't have more than one thread in the accept loop
at a time so we need to fall on our sword... */
@@ -752,7 +752,7 @@
/* worker_thread_count_mutex
* locks the worker_thread_count so we have ana ccurate count...
*/
- if ((rv = apr_lock_create(&worker_thread_count_mutex, APR_MUTEX,
APR_CROSS_PROCESS,
+ if ((rv = apr_lock_create(&worker_thread_count_mutex, APR_MUTEX,
APR_PROCESS_SHARED,
NULL, pconf)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
"Couldn't create worker thread count lock");
Index: server/mpm/perchild/perchild.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/perchild/perchild.c,v
retrieving revision 1.69
diff -u -r1.69 perchild.c
--- server/mpm/perchild/perchild.c 2001/06/27 17:43:36 1.69
+++ server/mpm/perchild/perchild.c 2001/07/02 17:59:48
@@ -933,15 +933,15 @@
worker_thread_free_ids[i] = i;
}
apr_pool_create(&thread_pool_parent, pchild);
- apr_lock_create(&thread_pool_parent_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&thread_pool_parent_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
- apr_lock_create(&idle_thread_count_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&idle_thread_count_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
- apr_lock_create(&worker_thread_count_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&worker_thread_count_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
- apr_lock_create(&pipe_of_death_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&pipe_of_death_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
- apr_lock_create(&thread_accept_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&thread_accept_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
apr_threadattr_create(&worker_thread_attr, pchild);
@@ -1199,7 +1199,7 @@
ap_server_root_relative(_pconf, lock_fname),
my_pid);
rv = SAFE_ACCEPT(apr_lock_create_np(&process_accept_mutex, APR_MUTEX,
- APR_CROSS_PROCESS, accept_lock_mech,
+ APR_PROCESS_SHARED, accept_lock_mech,
lock_fname, _pconf));
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
Index: server/mpm/prefork/prefork.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/prefork/prefork.c,v
retrieving revision 1.188
diff -u -r1.188 prefork.c
--- server/mpm/prefork/prefork.c 2001/06/27 17:43:39 1.188
+++ server/mpm/prefork/prefork.c 2001/07/02 17:59:50
@@ -275,7 +275,7 @@
apr_status_t rv;
expand_lock_fname(p);
- rv = apr_lock_create_np(&accept_lock, APR_MUTEX, APR_CROSS_PROCESS,
+ rv = apr_lock_create_np(&accept_lock, APR_MUTEX, APR_PROCESS_SHARED,
accept_lock_mech, ap_lock_fname, p);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, NULL, "couldn't create accept
mutex");
Index: server/mpm/spmt_os2/spmt_os2.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/spmt_os2/spmt_os2.c,v
retrieving revision 1.96
diff -u -r1.96 spmt_os2.c
--- server/mpm/spmt_os2/spmt_os2.c 2001/06/27 17:43:43 1.96
+++ server/mpm/spmt_os2/spmt_os2.c 2001/07/02 17:59:52
@@ -173,7 +173,7 @@
*/
static void accept_mutex_init(apr_pool_t *p)
{
- apr_status_t rc = apr_lock_create(&accept_mutex, APR_MUTEX,
APR_INTRAPROCESS, NULL, p);
+ apr_status_t rc = apr_lock_create(&accept_mutex, APR_MUTEX,
APR_PROCESS_PRIVATE, NULL, p);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rc, ap_server_conf,
Index: server/mpm/threaded/threaded.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/threaded/threaded.c,v
retrieving revision 1.42
diff -u -r1.42 threaded.c
--- server/mpm/threaded/threaded.c 2001/07/01 22:49:31 1.42
+++ server/mpm/threaded/threaded.c 2001/07/02 17:59:55
@@ -797,9 +797,9 @@
clean_child_exit(APEXIT_CHILDFATAL);
}
worker_thread_count = 0;
- apr_lock_create(&worker_thread_count_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&worker_thread_count_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
- apr_lock_create(&pipe_of_death_mutex, APR_MUTEX, APR_INTRAPROCESS,
+ apr_lock_create(&pipe_of_death_mutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
ts = apr_palloc(pchild, sizeof(*ts));
@@ -1156,7 +1156,7 @@
lock_fname = apr_psprintf(_pconf, "%s.%" APR_OS_PROC_T_FMT,
ap_server_root_relative(_pconf, lock_fname),
ap_my_pid);
- rv = apr_lock_create_np(&accept_mutex, APR_MUTEX, APR_LOCKALL,
+ rv = apr_lock_create_np(&accept_mutex, APR_MUTEX, APR_PROCESS_SHARED,
accept_lock_mech, lock_fname, _pconf);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
Index: server/mpm/winnt/mpm_winnt.c
===================================================================
RCS file: /home/cvspublic/httpd-2.0/server/mpm/winnt/mpm_winnt.c,v
retrieving revision 1.160
diff -u -r1.160 mpm_winnt.c
--- server/mpm/winnt/mpm_winnt.c 2001/06/27 17:43:51 1.160
+++ server/mpm/winnt/mpm_winnt.c 2001/07/02 17:59:58
@@ -962,7 +962,7 @@
if (one_process) {
/* Single process mode */
- apr_lock_create(&start_mutex, APR_MUTEX, APR_CROSS_PROCESS,
+ apr_lock_create(&start_mutex, APR_MUTEX, APR_PROCESS_SHARED,
signal_name_prefix, pconf);
exit_event = CreateEvent(NULL, TRUE, FALSE, exit_event_name);
}
@@ -985,7 +985,7 @@
apr_pool_create(&pchild, pconf);
allowed_globals.jobsemaphore = CreateSemaphore(NULL, 0, 1000000, NULL);
- apr_lock_create(&allowed_globals.jobmutex, APR_MUTEX, APR_INTRAPROCESS,
NULL, pchild);
+ apr_lock_create(&allowed_globals.jobmutex, APR_MUTEX, APR_PROCESS_PRIVATE,
NULL, pchild);
/*
* Wait until we have permission to start accepting connections.
@@ -1012,7 +1012,7 @@
NULL,
0,
0); /* CONCURRENT ACTIVE
THREADS */
- apr_lock_create(&qlock, APR_MUTEX, APR_INTRAPROCESS, NULL, pchild);
+ apr_lock_create(&qlock, APR_MUTEX, APR_PROCESS_PRIVATE, NULL, pchild);
}
/*
@@ -1923,7 +1923,7 @@
* Ths start mutex is used during a restart to prevent more than
one
* child process from entering the accept loop at once.
*/
- apr_lock_create(&start_mutex,APR_MUTEX, APR_CROSS_PROCESS,
signal_name_prefix,
+ apr_lock_create(&start_mutex, APR_MUTEX, APR_PROCESS_SHARED,
signal_name_prefix,
server_conf->process->pool);
}
}
