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 @@
*
* @param scope The scope of the lock to create, one of:
*
- * 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.
*
* @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 @@
*
* @param scope The scope of the lock to create, one of:
*
- * 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.
*
* @param mech The mechanism to use for the interprocess lock, if any; one of
*
@@ -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);