From f5a643ad6dbcbf1785eac274f9dec79ef65928f3 Mon Sep 17 00:00:00 2001 From: Simon Wilkinson Date: Sat, 20 Oct 2012 23:14:41 +0100 Subject: [PATCH] Add opr/lock.h and tidy locking macros The MUTEX_* and CV_* macros leaked from RX a while ago - they mean that most of the pthreaded tree has a dependency on RX, as well as further confusing the difference between userspace and kernel. Tidy all of this up so that we have opr_mutex_* and opr_cv_* macros to handle portable locking, and use these throughout the userspace tree. Only kernel code should now use MUTEX_* and CV_*. Provide opr/lockstub.h as a header that can be used by non-pthreaded code to easily stub out these functions. Change-Id: I24be525c7667641134d50561ce7f1e2d752cdf1f Reviewed-on: http://gerrit.openafs.org/8280 Tested-by: BuildBot Reviewed-by: Derrick Brashear --- src/budb/db_dump.c | 16 +-- src/budb/dbs_dump.c | 24 +++-- src/lwp/lock.c | 30 +++--- src/lwp/lock.h | 6 +- src/opr/Makefile.in | 8 ++ src/opr/NTMakefile | 5 + src/opr/lockstub.h | 50 +++++++++ src/opr/opr_lock.h | 66 ++++++++++++ src/rx/rx_pthread.h | 70 +++---------- src/rxgen/rpc_main.c | 3 + src/ubik/beacon.c | 6 ++ src/ubik/disk.c | 10 +- src/ubik/lock.c | 3 + src/ubik/recovery.c | 16 ++- src/ubik/remote.c | 6 ++ src/ubik/ubik.c | 26 +++-- src/ubik/ubik.p.h | 24 ++--- src/ubik/ubikclient.c | 3 + src/ubik/vote.c | 5 + src/util/thread_pool.c | 48 ++++----- src/util/work_queue.c | 197 ++++++++++++++++++------------------ src/viced/afsfileprocs.c | 5 +- src/viced/callback.c | 7 +- src/viced/fsstats.c | 1 + src/viced/host.c | 12 +-- src/viced/host.h | 4 +- src/viced/serialize_state.c | 3 +- src/viced/viced.c | 20 ++-- src/viced/viced.h | 8 +- src/vol/fssync-client.c | 10 +- src/vol/fssync-debug.c | 2 +- src/vol/fssync-server.c | 7 +- src/vol/ihandle.c | 5 +- src/vol/ihandle.h | 4 +- src/vol/namei_ops.c | 7 +- src/vol/partition.c | 3 + src/vol/salvaged.c | 43 ++++---- src/vol/salvsync-client.c | 2 +- src/vol/salvsync-server.c | 2 +- src/vol/vg_cache.c | 2 +- src/vol/vg_scan.c | 2 +- src/vol/vnode.c | 3 + src/vol/vnode_inline.h | 4 +- src/vol/vol-salvage.c | 4 + src/vol/volume.c | 135 ++++++++++++------------ src/vol/volume.h | 20 ++-- src/vol/volume_inline.h | 4 +- src/vol/vutil.c | 46 +++++---- src/volser/volmain.c | 4 +- src/volser/volprocs.c | 4 + src/volser/volser.p.h | 8 +- src/volser/voltrans.c | 3 + 52 files changed, 589 insertions(+), 417 deletions(-) create mode 100644 src/opr/lockstub.h create mode 100644 src/opr/opr_lock.h diff --git a/src/budb/db_dump.c b/src/budb/db_dump.c index f44ef1e36..d4d1fcd45 100644 --- a/src/budb/db_dump.c +++ b/src/budb/db_dump.c @@ -19,8 +19,12 @@ #include #include + +#ifdef AFS_PTHREAD_ENV +# include +#endif + #include -#include #include #include "database.h" @@ -68,7 +72,7 @@ canWrite(int fid) if (dumpSyncPtr->ds_readerStatus == DS_WAITING) { dumpSyncPtr->ds_readerStatus = 0; #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dumpSyncPtr->ds_readerStatus_cond); + opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond); #else code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus); if (code) @@ -79,7 +83,7 @@ canWrite(int fid) ReleaseWriteLock(&dumpSyncPtr->ds_lock); #ifdef AFS_PTHREAD_ENV MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex); - CV_WAIT(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex); + opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex); MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex); #else LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus); @@ -109,7 +113,7 @@ haveWritten(afs_int32 nbytes) if (dumpSyncPtr->ds_readerStatus == DS_WAITING) { dumpSyncPtr->ds_readerStatus = 0; #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dumpSyncPtr->ds_readerStatus_cond); + opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond); #else code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus); if (code) @@ -139,7 +143,7 @@ doneWriting(afs_int32 error) ReleaseWriteLock(&dumpSyncPtr->ds_lock); #ifdef AFS_PTHREAD_ENV MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex); - CV_WAIT(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex); + opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex); MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex); #else LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus); @@ -156,7 +160,7 @@ doneWriting(afs_int32 error) dumpSyncPtr->ds_writerStatus = DS_DONE; dumpSyncPtr->ds_readerStatus = 0; #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dumpSyncPtr->ds_readerStatus_cond); + opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond); #else code = LWP_NoYieldSignal(&dumpSyncPtr->ds_readerStatus); if (code) diff --git a/src/budb/dbs_dump.c b/src/budb/dbs_dump.c index 280735fe7..b1e4003bf 100644 --- a/src/budb/dbs_dump.c +++ b/src/budb/dbs_dump.c @@ -14,7 +14,11 @@ #include #include -#include + +#ifdef AFS_PTHREAD_ENV +# include +#endif + #include #include #include @@ -147,10 +151,10 @@ DumpDB(struct rx_call *call, /* Initialize the condition variables and the mutexes we use * to signal and synchronize the reader and writer threads. */ - CV_INIT(&dumpSyncPtr->ds_readerStatus_cond, "reader cond", CV_DEFAULT, 0); - CV_INIT(&dumpSyncPtr->ds_writerStatus_cond, "writer cond", CV_DEFAULT, 0); - MUTEX_INIT(&dumpSyncPtr->ds_readerStatus_mutex, "reader", MUTEX_DEFAULT, 0); - MUTEX_INIT(&dumpSyncPtr->ds_writerStatus_mutex, "writer", MUTEX_DEFAULT, 0); + opr_cv_init(&dumpSyncPtr->ds_readerStatus_cond); + opr_cv_init(&dumpSyncPtr->ds_writerStatus_cond); + opr_mutex_init(&dumpSyncPtr->ds_readerStatus_mutex); + opr_mutex_init(&dumpSyncPtr->ds_writerStatus_mutex); /* Initialize the thread attributes and launch the thread */ @@ -205,7 +209,7 @@ DumpDB(struct rx_call *call, LogDebug(6, "wakup writer\n"); dumpSyncPtr->ds_writerStatus = 0; #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dumpSyncPtr->ds_writerStatus_cond); + opr_cv_broadcast(&dumpSyncPtr->ds_writerStatus_cond); #else code = LWP_SignalProcess(&dumpSyncPtr->ds_writerStatus); if (code) @@ -216,9 +220,9 @@ DumpDB(struct rx_call *call, dumpSyncPtr->ds_readerStatus = DS_WAITING; ReleaseWriteLock(&dumpSyncPtr->ds_lock); #ifdef AFS_PTHREAD_ENV - MUTEX_ENTER(&dumpSyncPtr->ds_readerStatus_mutex); - CV_WAIT(&dumpSyncPtr->ds_readerStatus_cond, &dumpSyncPtr->ds_readerStatus_mutex); - MUTEX_EXIT(&dumpSyncPtr->ds_readerStatus_mutex); + opr_mutex_enter(&dumpSyncPtr->ds_readerStatus_mutex); + opr_cv_wait(&dumpSyncPtr->ds_readerStatus_cond, &dumpSyncPtr->ds_readerStatus_mutex); + opr_mutex_exit(&dumpSyncPtr->ds_readerStatus_mutex); #else LWP_WaitProcess(&dumpSyncPtr->ds_readerStatus); #endif @@ -247,7 +251,7 @@ DumpDB(struct rx_call *call, if (dumpSyncPtr->ds_writerStatus == DS_WAITING) { dumpSyncPtr->ds_writerStatus = 0; #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dumpSyncPtr->ds_writerStatus_cond); + opr_cv_broadcast(&dumpSyncPtr->ds_writerStatus_cond); #else code = LWP_SignalProcess(&dumpSyncPtr->ds_writerStatus); if (code) diff --git a/src/lwp/lock.c b/src/lwp/lock.c index ed5062634..824ed170e 100644 --- a/src/lwp/lock.c +++ b/src/lwp/lock.c @@ -42,9 +42,9 @@ Lock_Init(struct Lock *lock) lock->wait_states = 0; lock->num_waiting = 0; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_mutex_init(&lock->mutex, NULL) == 0); - opr_Verify(pthread_cond_init(&lock->read_cv, NULL) == 0); - opr_Verify(pthread_cond_init(&lock->write_cv, NULL) == 0); + opr_mutex_init(&lock->mutex); + opr_cv_init(&lock->read_cv); + opr_cv_init(&lock->write_cv); #endif /* AFS_PTHREAD_ENV */ } @@ -52,9 +52,9 @@ void Lock_Destroy(struct Lock *lock) { #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_mutex_destroy(&lock->mutex) == 0); - opr_Verify(pthread_cond_destroy(&lock->read_cv) == 0); - opr_Verify(pthread_cond_destroy(&lock->write_cv) == 0); + opr_mutex_destroy(&lock->mutex); + opr_cv_destroy(&lock->read_cv); + opr_cv_destroy(&lock->write_cv); #endif /* AFS_PTHREAD_ENV */ } @@ -68,7 +68,7 @@ Afs_Lock_Obtain(struct Lock *lock, int how) do { lock->wait_states |= READ_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_wait(&lock->read_cv, &lock->mutex) == 0); + opr_cv_wait(&lock->read_cv, &lock->mutex); #else /* AFS_PTHREAD_ENV */ LWP_WaitProcess(&lock->readers_reading); #endif /* AFS_PTHREAD_ENV */ @@ -82,7 +82,7 @@ Afs_Lock_Obtain(struct Lock *lock, int how) do { lock->wait_states |= WRITE_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0); + opr_cv_wait(&lock->write_cv, &lock->mutex); #else /* AFS_PTHREAD_ENV */ LWP_WaitProcess(&lock->excl_locked); #endif /* AFS_PTHREAD_ENV */ @@ -96,7 +96,7 @@ Afs_Lock_Obtain(struct Lock *lock, int how) do { lock->wait_states |= SHARED_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0); + opr_cv_wait(&lock->write_cv, &lock->mutex); #else /* AFS_PTHREAD_ENV */ LWP_WaitProcess(&lock->excl_locked); #endif /* AFS_PTHREAD_ENV */ @@ -110,7 +110,7 @@ Afs_Lock_Obtain(struct Lock *lock, int how) do { lock->wait_states |= WRITE_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0); + opr_cv_wait(&lock->write_cv, &lock->mutex); #else /* AFS_PTHREAD_ENV */ LWP_WaitProcess(&lock->excl_locked); #endif /* AFS_PTHREAD_ENV */ @@ -132,7 +132,7 @@ Afs_Lock_WakeupR(struct Lock *lock) if (lock->wait_states & READ_LOCK) { lock->wait_states &= ~READ_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_broadcast(&lock->read_cv) == 0); + opr_cv_broadcast(&lock->read_cv); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(&lock->readers_reading); #endif /* AFS_PTHREAD_ENV */ @@ -146,14 +146,14 @@ Afs_Lock_ReleaseR(struct Lock *lock) if (lock->wait_states & READ_LOCK) { lock->wait_states &= ~READ_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_broadcast(&lock->read_cv) == 0); + opr_cv_broadcast(&lock->read_cv); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(&lock->readers_reading); #endif /* AFS_PTHREAD_ENV */ } else { lock->wait_states &= ~EXCL_LOCKS; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_broadcast(&lock->write_cv) == 0); + opr_cv_broadcast(&lock->write_cv); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(&lock->excl_locked); #endif /* AFS_PTHREAD_ENV */ @@ -167,14 +167,14 @@ Afs_Lock_ReleaseW(struct Lock *lock) if (lock->wait_states & EXCL_LOCKS) { lock->wait_states &= ~EXCL_LOCKS; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_broadcast(&lock->write_cv) == 0); + opr_cv_broadcast(&lock->write_cv); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(&lock->excl_locked); #endif /* AFS_PTHREAD_ENV */ } else { lock->wait_states &= ~READ_LOCK; #ifdef AFS_PTHREAD_ENV - opr_Verify(pthread_cond_broadcast(&lock->read_cv) == 0); + opr_cv_broadcast(&lock->read_cv); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(&lock->readers_reading); #endif /* AFS_PTHREAD_ENV */ diff --git a/src/lwp/lock.h b/src/lwp/lock.h index c960a3127..a3233f880 100644 --- a/src/lwp/lock.h +++ b/src/lwp/lock.h @@ -43,10 +43,10 @@ #define ENDMAC } while (0) #ifdef AFS_PTHREAD_ENV -#include #include -#define LOCK_LOCK(A) opr_Verify(pthread_mutex_lock(&(A)->mutex) == 0); -#define LOCK_UNLOCK(A) opr_Verify(pthread_mutex_unlock(&(A)->mutex) == 0); +#include +#define LOCK_LOCK(A) opr_mutex_enter(&(A)->mutex); +#define LOCK_UNLOCK(A) opr_mutex_exit(&(A)->mutex); #else /* AFS_PTHREAD_ENV */ #define LOCK_LOCK(A) #define LOCK_UNLOCK(A) diff --git a/src/opr/Makefile.in b/src/opr/Makefile.in index 6414697f5..6d2d7fce0 100644 --- a/src/opr/Makefile.in +++ b/src/opr/Makefile.in @@ -9,6 +9,8 @@ LT_libs = $(LIB_hcrypto) $(LIB_roken) HEADERS = $(TOP_INCDIR)/afs/opr.h \ $(TOP_INCDIR)/afs/opr_assert.h \ $(TOP_INCDIR)/opr/jhash.h \ + $(TOP_INCDIR)/opr/lock.h \ + $(TOP_INCDIR)/opr/lockstub.h \ $(TOP_INCDIR)/opr/queue.h \ $(TOP_INCDIR)/opr/rbtree.h \ $(TOP_INCDIR)/opr/time.h \ @@ -41,12 +43,18 @@ $(TOP_INCDIR)/afs/opr_assert.h: ${srcdir}/opr_assert.h $(TOP_INCDIR)/opr/jhash.h: ${srcdir}/jhash.h $(INSTALL_DATA) $? $@ +$(TOP_INCDIR)/opr/lockstub.h: ${srcdir}/lockstub.h + $(INSTALL_DATA) $? $@ + $(TOP_INCDIR)/opr/queue.h: ${srcdir}/queue.h $(INSTALL_DATA) $? $@ $(TOP_INCDIR)/opr/rbtree.h: ${srcdir}/rbtree.h $(INSTALL_DATA) $? $@ +$(TOP_INCDIR)/opr/lock.h: ${srcdir}/opr_lock.h + $(INSTALL_DATA) $? $@ + $(TOP_INCDIR)/opr/time.h: ${srcdir}/opr_time.h $(INSTALL_DATA) $? $@ diff --git a/src/opr/NTMakefile b/src/opr/NTMakefile index aec589a11..150568dbe 100644 --- a/src/opr/NTMakefile +++ b/src/opr/NTMakefile @@ -17,11 +17,16 @@ INCFILES = \ $(DESTDIR)\include\opr\queue.h \ $(DESTDIR)\include\opr\rbtree.h \ $(DESTDIR)\include\opr\time.h \ + $(DESTDIR)\include\opr\lock.h \ + $(DESTDIR)\include\opr\lockstub.h \ $(DESTDIR)\include\opr\uuid.h $(DESTDIR)\include\opr\time.h: opr_time.h $(COPY) $** $@ +$(DESTDIR)\include\opr\lock.h: opr_lock.h + $(COPY) $** $@ + LIBFILE = $(DESTDIR)\lib\opr.lib LIBOBJS = \ diff --git a/src/opr/lockstub.h b/src/opr/lockstub.h new file mode 100644 index 000000000..2db610b3c --- /dev/null +++ b/src/opr/lockstub.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2012 Your File System Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/*! + * This is a set of stub defines that can be included by LWP processes to + * disable the pthread locking macros, and typedefs + */ + +#ifndef OPENAFS_OPR_LOCKSTUB_H +#define OPENAFS_OPR_LOCKSTUB_H 1 + +# ifdef AFS_PTHREAD_ENV +# error "Do not use the opr/lockstub.h header with pthreaded code" +# endif + +typedef int opr_cv_t; + +# define opr_mutex_init(mutex) +# define opr_mutex_destroy(mutex) +# define opr_mutex_enter(mutex) +# define opr_mutex_exit(mutex) +# define opr_mutex_tryenter(mutex) (1) +# define opr_cv_init(condvar) +# define opr_cv_destroy(condvar) +# define opr_cv_wait(condvar, mutex) +# define opr_cv_timedwait(condvar, mutex, timeout) +# define opr_cv_signal(condvar) +# define opr_cv_broadcast(condvar) +#endif diff --git a/src/opr/opr_lock.h b/src/opr/opr_lock.h new file mode 100644 index 000000000..0d524e480 --- /dev/null +++ b/src/opr/opr_lock.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2012 Your File System Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef OPENAFS_OPR_LOCK_H +#define OPENAFS_OPR_LOCK_H 1 + +#include + +typedef pthread_mutex_t opr_mutex_t; + +# define opr_mutex_init(mutex) \ + opr_Verify(pthread_mutex_init(mutex, NULL) == 0) + +# define opr_mutex_destroy(mutex) \ + opr_Verify(pthread_mutex_destroy(mutex) == 0) + +# define opr_mutex_enter(mutex) \ + opr_Verify(pthread_mutex_lock(mutex) == 0) + +# define opr_mutex_exit(mutex) \ + opr_Verify(pthread_mutex_unlock(mutex) == 0) + +# define opr_mutex_tryenter(mutex) \ + (pthread_mutex_trylock(mutex) ? 0: 1) + +typedef pthread_cond_t opr_cv_t; + +# define opr_cv_init(condvar) \ + opr_Verify(pthread_cond_init(condvar, NULL) == 0) + +# define opr_cv_destroy(condvar) \ + opr_Verify(pthread_cond_destroy(condvar) == 0) + +# define opr_cv_wait(condvar, mutex) \ + opr_Verify(pthread_cond_wait(condvar, mutex) == 0) + +# define opr_cv_timedwait(condvar, mutex, timeout) \ + pthread_cond_timedwait(condvar, mutex, timeout) + +# define opr_cv_signal(condvar) \ + opr_Verify(pthread_cond_signal(condvar) == 0) + +# define opr_cv_broadcast(condvar) \ + opr_Verify(pthread_cond_broadcast(condvar) == 0) + +#endif /* OPENAFS_OPR_LOCK_H */ diff --git a/src/rx/rx_pthread.h b/src/rx/rx_pthread.h index 9d98fa733..1eec91da4 100644 --- a/src/rx/rx_pthread.h +++ b/src/rx/rx_pthread.h @@ -21,6 +21,7 @@ /* Block signals to child threads. */ #include #include +#include #ifdef AFS_NT40_ENV #include @@ -69,63 +70,16 @@ typedef pthread_cond_t afs_kcondvar_t; extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg); -#ifdef AFS_PTHREAD_ENV -#ifdef MUTEX_INIT -#undef MUTEX_INIT -#endif -#define MUTEX_INIT(a, b, c, d) opr_Verify(pthread_mutex_init(a, NULL) == 0) - -#ifdef MUTEX_DESTROY -#undef MUTEX_DESTROY -#endif -#define MUTEX_DESTROY(l) opr_Verify(pthread_mutex_destroy(l) == 0) - -#ifdef MUTEX_ENTER -#undef MUTEX_ENTER -#endif -#define MUTEX_ENTER(l) opr_Verify(pthread_mutex_lock(l) == 0) - -#ifdef MUTEX_TRYENTER -#undef MUTEX_TRYENTER -#endif -#define MUTEX_TRYENTER(l) pthread_mutex_trylock(l) ? 0 : 1 - -#ifdef MUTEX_EXIT -#undef MUTEX_EXIT -#endif -#define MUTEX_EXIT(l) opr_Verify(pthread_mutex_unlock(l) == 0) - -#ifdef CV_INIT -#undef CV_INIT -#endif -#define CV_INIT(cv, a, b, c) opr_Verify(pthread_cond_init(cv, NULL) == 0) - -#ifdef CV_DESTROY -#undef CV_DESTROY -#endif -#define CV_DESTROY(cv) opr_Verify(pthread_cond_destroy(cv) == 0) - -#ifdef CV_WAIT -#undef CV_WAIT -#endif -#define CV_WAIT(cv, l) opr_Verify(pthread_cond_wait(cv, l) == 0) - -#ifdef CV_TIMEDWAIT -#undef CV_TIMEDWAIT -#endif -#define CV_TIMEDWAIT(cv, l, t) pthread_cond_timedwait(cv, l, t) - -#ifdef CV_SIGNAL -#undef CV_SIGNAL -#endif -#define CV_SIGNAL(cv) opr_Verify(pthread_cond_signal(cv) == 0) - -#ifdef CV_BROADCAST -#undef CV_BROADCAST -#endif -#define CV_BROADCAST(cv) opr_Verify(pthread_cond_broadcast(cv) == 0) - -#endif /* AFS_PTHREAD_ENV */ - +#define MUTEX_INIT(a, b, c, d) opr_mutex_init(a) +#define MUTEX_DESTROY(l) opr_mutex_destroy(l) +#define MUTEX_ENTER(l) opr_mutex_enter(l) +#define MUTEX_TRYENTER(l) opr_mutex_tryenter(l) +#define MUTEX_EXIT(l) opr_mutex_exit(l) +#define CV_INIT(cv, a, b, c) opr_cv_init(cv) +#define CV_DESTROY(cv) opr_cv_destroy(cv) +#define CV_WAIT(cv, l) opr_cv_wait(cv, l) +#define CV_TIMEDWAIT(cv, l, t) opr_cv_timedwait(cv, l, t) +#define CV_SIGNAL(cv) opr_cv_signal(cv) +#define CV_BROADCAST(cv) opr_cv_broadcast(cv) #endif /* RX_PTHREAD_H */ diff --git a/src/rxgen/rpc_main.c b/src/rxgen/rpc_main.c index d0e167ac6..01009e69b 100644 --- a/src/rxgen/rpc_main.c +++ b/src/rxgen/rpc_main.c @@ -664,6 +664,9 @@ C_output(char *infile, char *define, int extend, char *outfile, int append) f_print(fout, "#include \n"); f_print(fout, "#include \n"); f_print(fout, "#include \n"); + f_print(fout, "#ifdef AFS_PTHREAD_ENV\n"); + f_print(fout, "# include \n"); + f_print(fout, "#endif\n"); f_print(fout, "#include \"%s\"\n\n", include); } free(include); diff --git a/src/ubik/beacon.c b/src/ubik/beacon.c index 186c3073e..8026de202 100644 --- a/src/ubik/beacon.c +++ b/src/ubik/beacon.c @@ -13,6 +13,12 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include #include diff --git a/src/ubik/disk.c b/src/ubik/disk.c index 2cff7ffd1..acf007700 100644 --- a/src/ubik/disk.c +++ b/src/ubik/disk.c @@ -13,7 +13,11 @@ #include #include -#include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif #define UBIK_INTERNALS #include "ubik.h" @@ -896,7 +900,7 @@ udisk_commit(struct ubik_trans *atrans) UBIK_VERSION_LOCK; dbase->version.counter++; /* bump commit count */ #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dbase->version_cond); + opr_cv_broadcast(&dbase->version_cond); #else LWP_NoYieldSignal(&dbase->version); #endif @@ -1010,7 +1014,7 @@ udisk_end(struct ubik_trans *atrans) /* Wakeup any writers waiting in BeginTrans() */ #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&dbase->flags_cond); + opr_cv_broadcast(&dbase->flags_cond); #else LWP_NoYieldSignal(&dbase->flags); #endif diff --git a/src/ubik/lock.c b/src/ubik/lock.c index 91dbd27d0..ba368937f 100644 --- a/src/ubik/lock.c +++ b/src/ubik/lock.c @@ -13,6 +13,9 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #include #define UBIK_INTERNALS 1 diff --git a/src/ubik/recovery.c b/src/ubik/recovery.c index 41012fb08..a6534ae59 100644 --- a/src/ubik/recovery.c +++ b/src/ubik/recovery.c @@ -13,12 +13,18 @@ #include #include -#include -#include + +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include #include + #define UBIK_INTERNALS #include "ubik.h" #include "ubik_int.h" @@ -377,7 +383,7 @@ InitializeDB(struct ubik_dbase *adbase) (*adbase->setlabel) (adbase, 0, &adbase->version); } #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&adbase->version_cond); + opr_cv_broadcast(&adbase->version_cond); #else LWP_NoYieldSignal(&adbase->version); #endif @@ -714,7 +720,7 @@ urecovery_Interact(void *dummy) } udisk_Invalidate(ubik_dbase, 0); /* data has changed */ #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&ubik_dbase->version_cond); + opr_cv_broadcast(&ubik_dbase->version_cond); #else LWP_NoYieldSignal(&ubik_dbase->version); #endif @@ -740,7 +746,7 @@ urecovery_Interact(void *dummy) UBIK_VERSION_UNLOCK; udisk_Invalidate(ubik_dbase, 0); /* data may have changed */ #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&ubik_dbase->version_cond); + opr_cv_broadcast(&ubik_dbase->version_cond); #else LWP_NoYieldSignal(&ubik_dbase->version); #endif diff --git a/src/ubik/remote.c b/src/ubik/remote.c index 05611e9e2..bdd18dc13 100644 --- a/src/ubik/remote.c +++ b/src/ubik/remote.c @@ -15,6 +15,12 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include #include diff --git a/src/ubik/ubik.c b/src/ubik/ubik.c index b42bf4c34..ecb7a1a7c 100644 --- a/src/ubik/ubik.c +++ b/src/ubik/ubik.c @@ -12,11 +12,19 @@ #include + #include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include #include + #define UBIK_INTERNALS #include "ubik.h" #include "ubik_int.h" @@ -410,11 +418,11 @@ ubik_ServerInitCommon(afs_uint32 myHost, short myPort, memset(&tdb->version, 0, sizeof(struct ubik_version)); memset(&tdb->cachedVersion, 0, sizeof(struct ubik_version)); #ifdef AFS_PTHREAD_ENV - MUTEX_INIT(&tdb->versionLock, "version lock", MUTEX_DEFAULT, 0); - MUTEX_INIT(&beacon_globals.beacon_lock, "beacon lock", MUTEX_DEFAULT, 0); - MUTEX_INIT(&vote_globals.vote_lock, "vote lock", MUTEX_DEFAULT, 0); - MUTEX_INIT(&addr_globals.addr_lock, "address lock", MUTEX_DEFAULT, 0); - MUTEX_INIT(&version_globals.version_lock, "version lock", MUTEX_DEFAULT, 0); + opr_mutex_init(&tdb->versionLock); + opr_mutex_init(&beacon_globals.beacon_lock); + opr_mutex_init(&vote_globals.vote_lock); + opr_mutex_init(&addr_globals.addr_lock); + opr_mutex_init(&version_globals.version_lock); #else Lock_Init(&tdb->versionLock); #endif @@ -435,8 +443,8 @@ ubik_ServerInitCommon(afs_uint32 myHost, short myPort, ubik_dbase = tdb; /* for now, only one db per server; can fix later when we have names for the other dbases */ #ifdef AFS_PTHREAD_ENV - CV_INIT(&tdb->version_cond, "version", CV_DEFAULT, 0); - CV_INIT(&tdb->flags_cond, "flags", CV_DEFAULT, 0); + opr_cv_init(&tdb->version_cond); + opr_cv_init(&tdb->flags_cond); #endif /* AFS_PTHREAD_ENV */ /* initialize RX */ @@ -624,7 +632,7 @@ BeginTrans(struct ubik_dbase *dbase, afs_int32 transMode, /* if we're writing already, wait */ while (dbase->flags & DBWRITING) { #ifdef AFS_PTHREAD_ENV - CV_WAIT(&dbase->flags_cond, &dbase->versionLock); + opr_cv_wait(&dbase->flags_cond, &dbase->versionLock); #else DBRELE(dbase); LWP_WaitProcess(&dbase->flags); @@ -1255,7 +1263,7 @@ ubik_WaitVersion(struct ubik_dbase *adatabase, return 0; } #ifdef AFS_PTHREAD_ENV - CV_WAIT(&adatabase->version_cond, &adatabase->versionLock); + opr_cv_wait(&adatabase->version_cond, &adatabase->versionLock); #else DBRELE(adatabase); LWP_WaitProcess(&adatabase->version); /* same vers, just wait */ diff --git a/src/ubik/ubik.p.h b/src/ubik/ubik.p.h index 7a9f916fb..23a6a0dd1 100644 --- a/src/ubik/ubik.p.h +++ b/src/ubik/ubik.p.h @@ -69,8 +69,8 @@ struct ubik_client { }; #ifdef AFS_PTHREAD_ENV -#define LOCK_UBIK_CLIENT(client) MUTEX_ENTER(&client->cm) -#define UNLOCK_UBIK_CLIENT(client) MUTEX_EXIT(&client->cm) +#define LOCK_UBIK_CLIENT(client) opr_mutex_enter(&client->cm) +#define UNLOCK_UBIK_CLIENT(client) opr_mutex_exit(&client->cm) #else #define LOCK_UBIK_CLIENT(client) #define UNLOCK_UBIK_CLIENT(client) @@ -304,8 +304,8 @@ struct ubik_server { /*! \name hold and release functions on a database */ #ifdef AFS_PTHREAD_ENV -# define DBHOLD(a) MUTEX_ENTER(&((a)->versionLock)) -# define DBRELE(a) MUTEX_EXIT(&((a)->versionLock)) +# define DBHOLD(a) opr_mutex_enter(&((a)->versionLock)) +# define DBRELE(a) opr_mutex_exit(&((a)->versionLock)) #else /* !AFS_PTHREAD_ENV */ # define DBHOLD(a) ObtainWriteLock(&((a)->versionLock)) # define DBRELE(a) ReleaseWriteLock(&((a)->versionLock)) @@ -374,8 +374,8 @@ struct beacon_data { afs_int32 syncSiteUntil; /*!< valid only if amSyncSite */ }; -#define UBIK_BEACON_LOCK MUTEX_ENTER(&beacon_globals.beacon_lock) -#define UBIK_BEACON_UNLOCK MUTEX_EXIT(&beacon_globals.beacon_lock) +#define UBIK_BEACON_LOCK opr_mutex_enter(&beacon_globals.beacon_lock) +#define UBIK_BEACON_UNLOCK opr_mutex_exit(&beacon_globals.beacon_lock) /*! * \brief Global vote data. All values are protected by vote_lock @@ -399,8 +399,8 @@ struct vote_data { afs_int32 syncHost; }; -#define UBIK_VOTE_LOCK MUTEX_ENTER(&vote_globals.vote_lock) -#define UBIK_VOTE_UNLOCK MUTEX_EXIT(&vote_globals.vote_lock) +#define UBIK_VOTE_LOCK opr_mutex_enter(&vote_globals.vote_lock) +#define UBIK_VOTE_UNLOCK opr_mutex_exit(&vote_globals.vote_lock) /*! * \brief Server address data. All values are protected by addr_lock @@ -417,8 +417,8 @@ struct addr_data { struct rx_securityClass *ubikSecClass; }; -#define UBIK_ADDR_LOCK MUTEX_ENTER(&addr_globals.addr_lock) -#define UBIK_ADDR_UNLOCK MUTEX_EXIT(&addr_globals.addr_lock) +#define UBIK_ADDR_LOCK opr_mutex_enter(&addr_globals.addr_lock) +#define UBIK_ADDR_UNLOCK opr_mutex_exit(&addr_globals.addr_lock) /*! * \brief The version lock protects the structure member, as well as @@ -431,8 +431,8 @@ struct version_data { afs_int32 ubik_epochTime; /* time when this site started */ }; -#define UBIK_VERSION_LOCK MUTEX_ENTER(&version_globals.version_lock) -#define UBIK_VERSION_UNLOCK MUTEX_EXIT(&version_globals.version_lock) +#define UBIK_VERSION_LOCK opr_mutex_enter(&version_globals.version_lock) +#define UBIK_VERSION_UNLOCK opr_mutex_exit(&version_globals.version_lock) /* phys.c */ extern int uphys_stat(struct ubik_dbase *adbase, afs_int32 afid, diff --git a/src/ubik/ubikclient.c b/src/ubik/ubikclient.c index 7a607b471..d8747cbe5 100644 --- a/src/ubik/ubikclient.c +++ b/src/ubik/ubikclient.c @@ -13,6 +13,9 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #ifdef IGNORE_SOME_GCC_WARNINGS # pragma GCC diagnostic warning "-Wstrict-prototypes" diff --git a/src/ubik/vote.c b/src/ubik/vote.c index b0a55bd9f..ce44b6230 100644 --- a/src/ubik/vote.c +++ b/src/ubik/vote.c @@ -13,6 +13,11 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif #include #include #include diff --git a/src/util/thread_pool.c b/src/util/thread_pool.c index 7138bcb6e..246a509f4 100644 --- a/src/util/thread_pool.c +++ b/src/util/thread_pool.c @@ -139,24 +139,24 @@ _afs_tp_worker_run(void * rock) struct afs_thread_pool * pool = worker->pool; /* register worker with pool */ - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); queue_Append(&pool->thread_list, worker); pool->nthreads++; - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); /* call high-level entry point */ worker->ret = (*pool->entry)(pool, worker, pool->work_queue, pool->rock); /* adjust pool live thread count */ - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); opr_Assert(pool->nthreads); queue_Remove(worker); pool->nthreads--; if (!pool->nthreads) { - CV_BROADCAST(&pool->shutdown_cv); + opr_cv_broadcast(&pool->shutdown_cv); pool->state = AFS_TP_STATE_STOPPED; } - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); _afs_tp_worker_free(worker); @@ -241,8 +241,8 @@ afs_tp_create(struct afs_thread_pool ** pool_out, } pool = *pool_out; - MUTEX_INIT(&pool->lock, "pool", MUTEX_DEFAULT, 0); - CV_INIT(&pool->shutdown_cv, "pool shutdown", CV_DEFAULT, 0); + opr_mutex_init(&pool->lock); + opr_cv_init(&pool->shutdown_cv); queue_Init(&pool->thread_list); pool->work_queue = queue; pool->entry = &_afs_tp_worker_default; @@ -269,7 +269,7 @@ afs_tp_destroy(struct afs_thread_pool * pool) { int ret = 0; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); switch (pool->state) { case AFS_TP_STATE_INIT: case AFS_TP_STATE_STOPPED: @@ -278,7 +278,7 @@ afs_tp_destroy(struct afs_thread_pool * pool) default: ret = AFS_TP_ERROR; - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); } return ret; @@ -300,13 +300,13 @@ afs_tp_set_threads(struct afs_thread_pool *pool, { int ret = 0; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); if (pool->state != AFS_TP_STATE_INIT) { ret = AFS_TP_ERROR; } else { pool->max_threads = threads; } - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); return ret; } @@ -329,14 +329,14 @@ afs_tp_set_entry(struct afs_thread_pool * pool, { int ret = 0; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); if (pool->state != AFS_TP_STATE_INIT) { ret = AFS_TP_ERROR; } else { pool->entry = entry; pool->rock = rock; } - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); return ret; } @@ -357,13 +357,13 @@ afs_tp_start(struct afs_thread_pool * pool) struct afs_thread_pool_worker * worker; afs_uint32 i; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); if (pool->state != AFS_TP_STATE_INIT) { ret = AFS_TP_ERROR; goto done_sync; } pool->state = AFS_TP_STATE_STARTING; - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); for (i = 0; i < pool->max_threads; i++) { code = _afs_tp_worker_start(pool, &worker); @@ -372,10 +372,10 @@ afs_tp_start(struct afs_thread_pool * pool) } } - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); pool->state = AFS_TP_STATE_RUNNING; done_sync: - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); return ret; } @@ -396,7 +396,7 @@ afs_tp_shutdown(struct afs_thread_pool * pool, int ret = 0; struct afs_thread_pool_worker * worker, *nn; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); if (pool->state == AFS_TP_STATE_STOPPED || pool->state == AFS_TP_STATE_STOPPING) { goto done_stopped; @@ -414,22 +414,22 @@ afs_tp_shutdown(struct afs_thread_pool * pool, pool->state = AFS_TP_STATE_STOPPED; } /* need to drop lock to get a membar here */ - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); ret = afs_wq_shutdown(pool->work_queue); if (ret) { goto error; } - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); done_stopped: if (block) { while (pool->nthreads) { - CV_WAIT(&pool->shutdown_cv, &pool->lock); + opr_cv_wait(&pool->shutdown_cv, &pool->lock); } } done_sync: - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); error: return ret; @@ -449,9 +449,9 @@ afs_tp_is_online(struct afs_thread_pool * pool) { int ret; - MUTEX_ENTER(&pool->lock); + opr_mutex_enter(&pool->lock); ret = (pool->state == AFS_TP_STATE_RUNNING); - MUTEX_EXIT(&pool->lock); + opr_mutex_exit(&pool->lock); return ret; } diff --git a/src/util/work_queue.c b/src/util/work_queue.c index 41343b188..0b7f9fffd 100644 --- a/src/util/work_queue.c +++ b/src/util/work_queue.c @@ -12,11 +12,10 @@ #include #include +#include #include -#include - #define __AFS_WORK_QUEUE_IMPL 1 #include "work_queue.h" #include "work_queue_impl.h" @@ -97,7 +96,7 @@ _afs_wq_node_state_change(struct afs_work_queue_node * node, old_state = node->state; node->state = new_state; - CV_BROADCAST(&node->state_cv); + opr_cv_broadcast(&node->state_cv); return old_state; } @@ -118,7 +117,7 @@ static int _afs_wq_node_state_wait_busy(struct afs_work_queue_node * node) { while (node->state == AFS_WQ_NODE_STATE_BUSY) { - CV_WAIT(&node->state_cv, &node->lock); + opr_cv_wait(&node->state_cv, &node->lock); } return 0; @@ -185,14 +184,14 @@ _afs_wq_node_multilock(struct afs_work_queue_node_multilock * ml) } } - code = MUTEX_TRYENTER(&ml->nodes[1].node->lock); + code = opr_mutex_tryenter(&ml->nodes[1].node->lock); if (code) { /* success */ goto done; } /* setup for main loop */ - MUTEX_EXIT(&ml->nodes[0].node->lock); + opr_mutex_exit(&ml->nodes[0].node->lock); } /* @@ -204,16 +203,16 @@ _afs_wq_node_multilock(struct afs_work_queue_node_multilock * ml) delay.tv_nsec = 500 + rand() % 500; while (1) { - MUTEX_ENTER(&ml->nodes[first].node->lock); + opr_mutex_enter(&ml->nodes[first].node->lock); if ((first != 0) || !ml->nodes[0].busy_held) { ret = _afs_wq_node_state_wait_busy(ml->nodes[first].node); if (ret) { /* cleanup */ if (!ml->nodes[0].lock_held || first) { - MUTEX_EXIT(&ml->nodes[first].node->lock); + opr_mutex_exit(&ml->nodes[first].node->lock); if (ml->nodes[0].lock_held) { /* on error, return with locks in same state as before call */ - MUTEX_ENTER(&ml->nodes[0].node->lock); + opr_mutex_enter(&ml->nodes[0].node->lock); } } goto error; @@ -225,14 +224,14 @@ _afs_wq_node_multilock(struct afs_work_queue_node_multilock * ml) * a non-blocking state check. if we meet any contention, * we must drop back and start again. */ - code = MUTEX_TRYENTER(&ml->nodes[second].node->lock); + code = opr_mutex_tryenter(&ml->nodes[second].node->lock); if (code) { if (((second == 0) && (ml->nodes[0].busy_held)) || !_afs_wq_node_state_is_busy(ml->nodes[second].node)) { /* success */ break; } else { - MUTEX_EXIT(&ml->nodes[second].node->lock); + opr_mutex_exit(&ml->nodes[second].node->lock); } } @@ -242,7 +241,7 @@ _afs_wq_node_multilock(struct afs_work_queue_node_multilock * ml) * drop locks, use exponential backoff, * try acquiring in the opposite order */ - MUTEX_EXIT(&ml->nodes[first].node->lock); + opr_mutex_exit(&ml->nodes[first].node->lock); nanosleep(&delay, NULL); if (delay.tv_nsec <= 65536000) { /* max backoff delay of ~131ms */ delay.tv_nsec <<= 1; @@ -273,8 +272,8 @@ _afs_wq_node_list_init(struct afs_work_queue_node_list * list, afs_wq_node_list_id_t id) { queue_Init(&list->list); - MUTEX_INIT(&list->lock, "list", MUTEX_DEFAULT, 0); - CV_INIT(&list->cv, "list", CV_DEFAULT, 0); + opr_mutex_init(&list->lock); + opr_cv_init(&list->cv); list->qidx = id; list->shutdown = 0; @@ -302,8 +301,8 @@ _afs_wq_node_list_destroy(struct afs_work_queue_node_list * list) goto error; } - MUTEX_DESTROY(&list->lock); - CV_DESTROY(&list->cv); + opr_mutex_destroy(&list->lock); + opr_cv_destroy(&list->cv); error: return ret; @@ -325,7 +324,7 @@ _afs_wq_node_list_shutdown(struct afs_work_queue_node_list * list) int ret = 0; struct afs_work_queue_node *node, *nnode; - MUTEX_ENTER(&list->lock); + opr_mutex_enter(&list->lock); list->shutdown = 1; for (queue_Scan(&list->list, node, nnode, afs_work_queue_node)) { @@ -343,8 +342,8 @@ _afs_wq_node_list_shutdown(struct afs_work_queue_node_list * list) } } - CV_BROADCAST(&list->cv); - MUTEX_EXIT(&list->lock); + opr_cv_broadcast(&list->cv); + opr_mutex_exit(&list->lock); return ret; } @@ -385,13 +384,13 @@ _afs_wq_node_list_enqueue(struct afs_work_queue_node_list * list, } /* deal with lock inversion */ - code = MUTEX_TRYENTER(&list->lock); + code = opr_mutex_tryenter(&list->lock); if (!code) { /* contended */ _afs_wq_node_state_change(node, AFS_WQ_NODE_STATE_BUSY); - MUTEX_EXIT(&node->lock); - MUTEX_ENTER(&list->lock); - MUTEX_ENTER(&node->lock); + opr_mutex_exit(&node->lock); + opr_mutex_enter(&list->lock); + opr_mutex_enter(&node->lock); /* assert state of the world (we set busy, so this should never happen) */ opr_Assert(queue_IsNotOnQueue(node)); @@ -405,15 +404,15 @@ _afs_wq_node_list_enqueue(struct afs_work_queue_node_list * list, opr_Assert(node->qidx == AFS_WQ_NODE_LIST_NONE); if (queue_IsEmpty(&list->list)) { /* wakeup a dequeue thread */ - CV_SIGNAL(&list->cv); + opr_cv_signal(&list->cv); } queue_Append(&list->list, node); node->qidx = list->qidx; _afs_wq_node_state_change(node, state); error_unlock: - MUTEX_EXIT(&node->lock); - MUTEX_EXIT(&list->lock); + opr_mutex_exit(&node->lock); + opr_mutex_exit(&list->lock); error: return ret; @@ -445,7 +444,7 @@ _afs_wq_node_list_dequeue(struct afs_work_queue_node_list * list, int ret = 0; struct afs_work_queue_node * node; - MUTEX_ENTER(&list->lock); + opr_mutex_enter(&list->lock); if (list->shutdown) { *node_out = NULL; @@ -465,18 +464,18 @@ _afs_wq_node_list_dequeue(struct afs_work_queue_node_list * list, ret = EINTR; goto done_sync; } - CV_WAIT(&list->cv, &list->lock); + opr_cv_wait(&list->cv, &list->lock); } *node_out = node = queue_First(&list->list, afs_work_queue_node); - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); queue_Remove(node); node->qidx = AFS_WQ_NODE_LIST_NONE; _afs_wq_node_state_change(node, state); done_sync: - MUTEX_EXIT(&list->lock); + opr_mutex_exit(&list->lock); return ret; } @@ -533,14 +532,14 @@ _afs_wq_node_list_remove(struct afs_work_queue_node * node, } if (list) { - code = MUTEX_TRYENTER(&list->lock); + code = opr_mutex_tryenter(&list->lock); if (!code) { /* contended */ _afs_wq_node_state_change(node, AFS_WQ_NODE_STATE_BUSY); - MUTEX_EXIT(&node->lock); - MUTEX_ENTER(&list->lock); - MUTEX_ENTER(&node->lock); + opr_mutex_exit(&node->lock); + opr_mutex_enter(&list->lock); + opr_mutex_enter(&node->lock); if (node->qidx == AFS_WQ_NODE_LIST_NONE) { /* raced */ @@ -554,7 +553,7 @@ _afs_wq_node_list_remove(struct afs_work_queue_node * node, _afs_wq_node_state_change(node, next_state); done_sync: - MUTEX_EXIT(&list->lock); + opr_mutex_exit(&list->lock); } error: @@ -692,7 +691,7 @@ _afs_wq_node_free_deps(struct afs_work_queue_node *parent) nd, afs_work_queue_dep_node)) { - MUTEX_ENTER(&dep->child->lock); + opr_mutex_enter(&dep->child->lock); node_unlock = dep->child; /* We need to get a ref on child here, since _afs_wq_dep_unlink_r may @@ -711,7 +710,7 @@ _afs_wq_node_free_deps(struct afs_work_queue_node *parent) if (node_put) { _afs_wq_node_put_r(node_put, 1); } else if (node_unlock) { - MUTEX_EXIT(&node_unlock->lock); + opr_mutex_exit(&node_unlock->lock); } node_put = node_unlock = NULL; @@ -795,7 +794,7 @@ _afs_wq_dep_propagate(struct afs_work_queue_node * parent, /* skip unscheduled nodes */ if (dep->child->queue == NULL) { - MUTEX_EXIT(&dep->child->lock); + opr_mutex_exit(&dep->child->lock); continue; } @@ -822,7 +821,7 @@ _afs_wq_dep_propagate(struct afs_work_queue_node * parent, ret = _afs_wq_node_list_remove(dep->child, AFS_WQ_NODE_STATE_BUSY); if (ret) { - MUTEX_EXIT(&dep->child->lock); + opr_mutex_exit(&dep->child->lock); goto error; } @@ -830,11 +829,11 @@ _afs_wq_dep_propagate(struct afs_work_queue_node * parent, dep->child, cns); if (ret) { - MUTEX_EXIT(&dep->child->lock); + opr_mutex_exit(&dep->child->lock); goto error; } } - MUTEX_EXIT(&dep->child->lock); + opr_mutex_exit(&dep->child->lock); } error: @@ -851,14 +850,14 @@ _afs_wq_dep_propagate(struct afs_work_queue_node * parent, static void _afs_wq_dec_running_count(struct afs_work_queue *queue) { - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); queue->running_count--; if (queue->shutdown && queue->running_count == 0) { /* if we've shut down, someone may be waiting for the running count * to drop to 0 */ - CV_BROADCAST(&queue->running_cv); + opr_cv_broadcast(&queue->running_cv); } - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); } /** @@ -893,13 +892,13 @@ _afs_wq_do(struct afs_work_queue * queue, * _afs_wq_node_list_dequeue should return immediately with EINTR, * in which case we'll dec running_count, so it's as if we never inc'd it * in the first place. */ - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); if (queue->shutdown) { - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); return EINTR; } queue->running_count++; - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); ret = _afs_wq_node_list_dequeue(&queue->ready_list, &node, @@ -915,9 +914,9 @@ _afs_wq_do(struct afs_work_queue * queue, detached = node->detached; if (cbf != NULL) { - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); code = (*cbf)(queue, node, queue->rock, node_rock, rock); - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); if (code == 0) { next_state = AFS_WQ_NODE_STATE_DONE; ql = &queue->done_list; @@ -949,23 +948,23 @@ _afs_wq_do(struct afs_work_queue * queue, if ((next_state == AFS_WQ_NODE_STATE_DONE) || (next_state == AFS_WQ_NODE_STATE_ERROR)) { - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); if (queue->drain && queue->pend_count == queue->opts.pend_lothresh) { /* signal other threads if we're about to below the low * pending-tasks threshold */ queue->drain = 0; - CV_SIGNAL(&queue->pend_cv); + opr_cv_signal(&queue->pend_cv); } if (queue->pend_count == 1) { /* signal other threads if we're about to become 'empty' */ - CV_BROADCAST(&queue->empty_cv); + opr_cv_broadcast(&queue->empty_cv); } queue->pend_count--; - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); } ret = _afs_wq_node_state_wait_busy(node); @@ -1076,10 +1075,10 @@ afs_wq_create(struct afs_work_queue ** queue_out, queue->pend_count = 0; queue->running_count = 0; - MUTEX_INIT(&queue->lock, "queue", MUTEX_DEFAULT, 0); - CV_INIT(&queue->pend_cv, "queue pending", CV_DEFAULT, 0); - CV_INIT(&queue->empty_cv, "queue empty", CV_DEFAULT, 0); - CV_INIT(&queue->running_cv, "queue running", CV_DEFAULT, 0); + opr_mutex_init(&queue->lock); + opr_cv_init(&queue->pend_cv); + opr_cv_init(&queue->empty_cv); + opr_cv_init(&queue->running_cv); error: return ret; @@ -1133,10 +1132,10 @@ afs_wq_shutdown(struct afs_work_queue * queue) { int ret = 0; - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); if (queue->shutdown) { /* already shutdown, do nothing */ - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); goto error; } queue->shutdown = 1; @@ -1159,9 +1158,9 @@ afs_wq_shutdown(struct afs_work_queue * queue) /* signal everyone that could be waiting, since these conditions will * generally fail to signal on their own if we're shutdown, since no * progress is being made */ - CV_BROADCAST(&queue->pend_cv); - CV_BROADCAST(&queue->empty_cv); - MUTEX_EXIT(&queue->lock); + opr_cv_broadcast(&queue->pend_cv); + opr_cv_broadcast(&queue->empty_cv); + opr_mutex_exit(&queue->lock); error: return ret; @@ -1195,8 +1194,8 @@ afs_wq_node_alloc(struct afs_work_queue_node ** node_out) node->refcount = 1; node->block_count = 0; node->error_count = 0; - MUTEX_INIT(&node->lock, "node", MUTEX_DEFAULT, 0); - CV_INIT(&node->state_cv, "node state", CV_DEFAULT, 0); + opr_mutex_init(&node->lock); + opr_cv_init(&node->state_cv); node->state = AFS_WQ_NODE_STATE_INIT; queue_Init(&node->dep_children); @@ -1232,8 +1231,8 @@ _afs_wq_node_free(struct afs_work_queue_node * node) goto error; } - MUTEX_DESTROY(&node->lock); - CV_DESTROY(&node->state_cv); + opr_mutex_destroy(&node->lock); + opr_cv_destory(&node->state_cv); if (node->rock_dtor) { (*node->rock_dtor) (node->rock); @@ -1256,9 +1255,9 @@ _afs_wq_node_free(struct afs_work_queue_node * node) int afs_wq_node_get(struct afs_work_queue_node * node) { - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); node->refcount++; - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return 0; } @@ -1287,7 +1286,7 @@ _afs_wq_node_put_r(struct afs_work_queue_node * node, opr_Assert(node->refcount > 0); refc = --node->refcount; if (drop) { - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); } if (!refc) { opr_Assert(node->qidx == AFS_WQ_NODE_LIST_NONE); @@ -1310,7 +1309,7 @@ _afs_wq_node_put_r(struct afs_work_queue_node * node, int afs_wq_node_put(struct afs_work_queue_node * node) { - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); return _afs_wq_node_put_r(node, 1); } @@ -1330,11 +1329,11 @@ afs_wq_node_set_callback(struct afs_work_queue_node * node, afs_wq_callback_func_t * cbf, void * rock, afs_wq_callback_dtor_t *dtor) { - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); node->cbf = cbf; node->rock = rock; node->rock_dtor = dtor; - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return 0; } @@ -1350,9 +1349,9 @@ afs_wq_node_set_callback(struct afs_work_queue_node * node, int afs_wq_node_set_detached(struct afs_work_queue_node * node) { - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); node->detached = 1; - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return 0; } @@ -1478,8 +1477,8 @@ afs_wq_node_dep_add(struct afs_work_queue_node * child, done: if (held) { - MUTEX_EXIT(&child->lock); - MUTEX_EXIT(&parent->lock); + opr_mutex_exit(&child->lock); + opr_mutex_exit(&parent->lock); } return ret; @@ -1552,8 +1551,8 @@ afs_wq_node_dep_del(struct afs_work_queue_node * child, error: if (held) { - MUTEX_EXIT(&child->lock); - MUTEX_EXIT(&parent->lock); + opr_mutex_exit(&child->lock); + opr_mutex_exit(&parent->lock); } return ret; } @@ -1576,7 +1575,7 @@ afs_wq_node_block(struct afs_work_queue_node * node) int ret = 0; int start; - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); ret = _afs_wq_node_state_wait_busy(node); if (ret) { goto error_sync; @@ -1599,7 +1598,7 @@ afs_wq_node_block(struct afs_work_queue_node * node) } error_sync: - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return ret; } @@ -1622,7 +1621,7 @@ afs_wq_node_unblock(struct afs_work_queue_node * node) int ret = 0; int end; - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); ret = _afs_wq_node_state_wait_busy(node); if (ret) { goto error_sync; @@ -1645,7 +1644,7 @@ afs_wq_node_unblock(struct afs_work_queue_node * node) } error_sync: - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return ret; } @@ -1698,7 +1697,7 @@ afs_wq_add(struct afs_work_queue *queue, force = opts->force; retry: - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); ret = _afs_wq_node_state_wait_busy(node); if (ret) { @@ -1718,12 +1717,12 @@ afs_wq_add(struct afs_work_queue *queue, ret = 0; - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); if (queue->shutdown) { ret = EINTR; - MUTEX_EXIT(&queue->lock); - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&queue->lock); + opr_mutex_exit(&node->lock); goto error; } @@ -1737,13 +1736,13 @@ afs_wq_add(struct afs_work_queue *queue, if (queue->drain) { if (block) { - MUTEX_EXIT(&node->lock); - CV_WAIT(&queue->pend_cv, &queue->lock); + opr_mutex_exit(&node->lock); + opr_cv_wait(&queue->pend_cv, &queue->lock); if (queue->shutdown) { ret = EINTR; } else { - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); waited_for_drain = 1; @@ -1760,10 +1759,10 @@ afs_wq_add(struct afs_work_queue *queue, } if (waited_for_drain) { /* signal another thread that may have been waiting for drain */ - CV_SIGNAL(&queue->pend_cv); + opr_cv_signal(&queue->pend_cv); } - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); if (ret) { goto error; @@ -1845,10 +1844,10 @@ afs_wq_wait_all(struct afs_work_queue *queue) { int ret = 0; - MUTEX_ENTER(&queue->lock); + opr_mutex_enter(&queue->lock); while (queue->pend_count > 0 && !queue->shutdown) { - CV_WAIT(&queue->empty_cv, &queue->lock); + opr_cv_wait(&queue->empty_cv, &queue->lock); } if (queue->shutdown) { @@ -1856,14 +1855,14 @@ afs_wq_wait_all(struct afs_work_queue *queue) * running e.g. in the middle of their callback. ensure they have * stopped before we return. */ while (queue->running_count > 0) { - CV_WAIT(&queue->running_cv, &queue->lock); + opr_cv_wait(&queue->running_cv, &queue->lock); } ret = EINTR; goto done; } done: - MUTEX_EXIT(&queue->lock); + opr_mutex_exit(&queue->lock); /* technically this doesn't really guarantee that the work queue is empty * after we return, but we do guarantee that it was empty at some point */ @@ -1888,7 +1887,7 @@ afs_wq_node_wait(struct afs_work_queue_node * node, { int ret = 0; - MUTEX_ENTER(&node->lock); + opr_mutex_enter(&node->lock); if (node->state == AFS_WQ_NODE_STATE_INIT) { /* not sure what to do in this case */ goto done_sync; @@ -1896,9 +1895,9 @@ afs_wq_node_wait(struct afs_work_queue_node * node, while ((node->state != AFS_WQ_NODE_STATE_DONE) && (node->state != AFS_WQ_NODE_STATE_ERROR)) { - CV_WAIT(&node->state_cv, &node->lock); + opr_cv_wait(&node->state_cv, &node->lock); } - if (retcode) { + if (retcowait{ *retcode = node->retcode; } @@ -1911,7 +1910,7 @@ afs_wq_node_wait(struct afs_work_queue_node * node, AFS_WQ_NODE_STATE_INIT); done_sync: - MUTEX_EXIT(&node->lock); + opr_mutex_exit(&node->lock); return ret; } diff --git a/src/viced/afsfileprocs.c b/src/viced/afsfileprocs.c index 1b46f0519..0bb0ea359 100644 --- a/src/viced/afsfileprocs.c +++ b/src/viced/afsfileprocs.c @@ -75,9 +75,8 @@ #include #include +#include #include -#include -#include #include #include #include @@ -734,7 +733,7 @@ GetRights(struct client *client, struct acl_accessList *ACL, H_LOCK; while (client->host->hostFlags & HCPS_INPROGRESS) { client->host->hostFlags |= HCPS_WAITING; /* I am waiting */ - CV_WAIT(&client->host->cond, &host_glock_mutex); + opr_cv_wait(&client->host->cond, &host_glock_mutex); } if (!client->host->hcps.prlist_len || !client->host->hcps.prlist_val) { diff --git a/src/viced/callback.c b/src/viced/callback.c index 56db76b02..fae956883 100644 --- a/src/viced/callback.c +++ b/src/viced/callback.c @@ -92,16 +92,13 @@ #endif #include +#include #include /* yuck. This is an abomination. */ -#include #include #include #include #include -#include #include -#include -#include #include "viced_prototypes.h" #include "viced.h" @@ -1230,7 +1227,7 @@ BreakVolumeCallBacksLater(afs_uint32 volume) ViceLog(25, ("Fsync thread wakeup\n")); FSYNC_LOCK; - CV_BROADCAST(&fsync_cond); + opr_cv_broadcast(&fsync_cond); FSYNC_UNLOCK; return 0; } diff --git a/src/viced/fsstats.c b/src/viced/fsstats.c index 97532fad9..3fb6d3e79 100644 --- a/src/viced/fsstats.c +++ b/src/viced/fsstats.c @@ -16,6 +16,7 @@ #include #include +#include #include #include #include diff --git a/src/viced/host.c b/src/viced/host.c index 695abc908..27aa92e32 100644 --- a/src/viced/host.c +++ b/src/viced/host.c @@ -15,14 +15,12 @@ #include #include +#include #ifdef HAVE_SYS_FILE_H #include #endif -#include -#include -#include #include #define FSINT_COMMON_XG #include @@ -211,7 +209,7 @@ GetHTBlock(void) ShutDownAndCore(PANIC); } for (i = 0; i < (h_HTSPERBLOCK); i++) - CV_INIT(&block->entry[i].cond, "block entry", CV_DEFAULT, 0); + opr_cv_init(&block->entry[i].cond); for (i = 0; i < (h_HTSPERBLOCK); i++) Lock_Init(&block->entry[i].lock); for (i = 0; i < (h_HTSPERBLOCK - 1); i++) @@ -564,7 +562,7 @@ h_gethostcps_r(struct host *host, afs_int32 now) while (host->hostFlags & HCPS_INPROGRESS) { slept = 1; /* I did sleep */ host->hostFlags |= HCPS_WAITING; /* I am sleeping now */ - CV_WAIT(&host->cond, &host_glock_mutex); + opr_cv_wait(&host->cond, &host_glock_mutex); } @@ -620,7 +618,7 @@ h_gethostcps_r(struct host *host, afs_int32 now) /* signal all who are waiting */ if (host->hostFlags & HCPS_WAITING) { /* somebody is waiting */ host->hostFlags &= ~HCPS_WAITING; - CV_BROADCAST(&host->cond); + opr_cv_broadcast(&host->cond); } } @@ -2192,7 +2190,7 @@ h_InitHostPackage(void) memset(&nulluuid, 0, sizeof(afsUUID)); rxcon_ident_key = rx_KeyCreate((rx_destructor_t) free); rxcon_client_key = rx_KeyCreate((rx_destructor_t) 0); - MUTEX_INIT(&host_glock_mutex, "host glock", MUTEX_DEFAULT, 0); + opr_mutex_init(&host_glock_mutex); } static int diff --git a/src/viced/host.h b/src/viced/host.h index 5b810784c..ceded26b9 100644 --- a/src/viced/host.h +++ b/src/viced/host.h @@ -24,8 +24,8 @@ #include #include extern pthread_mutex_t host_glock_mutex; -#define H_LOCK MUTEX_ENTER(&host_glock_mutex); -#define H_UNLOCK MUTEX_EXIT(&host_glock_mutex); +#define H_LOCK opr_mutex_enter(&host_glock_mutex); +#define H_UNLOCK opr_mutex_exit(&host_glock_mutex); extern pthread_key_t viced_uclient_key; #define h_MAXHOSTTABLEENTRIES 1000 diff --git a/src/viced/serialize_state.c b/src/viced/serialize_state.c index c07430415..154dcc78b 100644 --- a/src/viced/serialize_state.c +++ b/src/viced/serialize_state.c @@ -20,8 +20,7 @@ #include #include -#include -#include +#include #include #include #include diff --git a/src/viced/viced.c b/src/viced/viced.c index f67036671..457fdec44 100644 --- a/src/viced/viced.c +++ b/src/viced/viced.c @@ -44,7 +44,7 @@ #include #include #include -#include +#include #include #include #include @@ -228,7 +228,7 @@ static int fs_stateInit(void) fs_state.options.fs_state_verify_before_save = 1; fs_state.options.fs_state_verify_after_restore = 1; - CV_INIT(&fs_state.worker_done_cv, "worker done", CV_DEFAULT, 0); + opr_cv_init(&fs_state.worker_done_cv, "worker done"); opr_Verify(pthread_rwlock_init(&fs_state.state_lock, NULL) == 0); } # endif /* AFS_NT40_ENV */ @@ -448,7 +448,7 @@ FiveMinuteCheckLWP(void *unused) #ifdef AFS_DEMAND_ATTACH_FS fs_state.FiveMinuteLWP_tranquil = 1; FS_LOCK; - CV_BROADCAST(&fs_state.worker_done_cv); + opr_cv_broadcast(&fs_state.worker_done_cv); FS_UNLOCK; FS_STATE_UNLOCK; #endif @@ -496,7 +496,7 @@ HostCheckLWP(void *unused) #ifdef AFS_DEMAND_ATTACH_FS fs_state.HostCheckLWP_tranquil = 1; FS_LOCK; - CV_BROADCAST(&fs_state.worker_done_cv); + opr_cv_broadcast(&fs_state.worker_done_cv); FS_UNLOCK; FS_STATE_UNLOCK; #endif @@ -529,7 +529,7 @@ FsyncCheckLWP(void *unused) fsync_next.tv_nsec = 0; fsync_next.tv_sec = time(0) + fiveminutes; - code = CV_TIMEDWAIT(&fsync_cond, &fsync_glock_mutex, + code = opr_cv_timedwait(&fsync_cond, &fsync_glock_mutex, &fsync_next); if (code != 0 && code != ETIMEDOUT) ViceLog(0, ("pthread_cond_timedwait returned %d\n", code)); @@ -555,7 +555,7 @@ FsyncCheckLWP(void *unused) #ifdef AFS_DEMAND_ATTACH_FS fs_state.FsyncCheckLWP_tranquil = 1; FS_LOCK; - CV_BROADCAST(&fs_state.worker_done_cv); + opr_cv_broadcast(&fs_state.worker_done_cv); FS_UNLOCK; FS_STATE_UNLOCK; #endif /* AFS_DEMAND_ATTACH_FS */ @@ -786,7 +786,7 @@ ShutDownAndCore(int dopanic) FS_LOCK; FS_STATE_UNLOCK; ViceLog(0, ("waiting for background host/callback threads to quiesce before saving fileserver state...\n")); - CV_WAIT(&fs_state.worker_done_cv, &fileproc_glock_mutex); + opr_cv_wait(&fs_state.worker_done_cv, &fileproc_glock_mutex); FS_UNLOCK; FS_STATE_RDLOCK; } @@ -1835,7 +1835,7 @@ main(int argc, char *argv[]) if (ParseArgs(argc, argv)) { exit(-1); } - MUTEX_INIT(&fileproc_glock_mutex, "fileproc", MUTEX_DEFAULT, 0); + opr_mutex_init(&fileproc_glock_mutex); #ifdef AFS_SGI_VNODE_GLUE if (afs_init_kernel_config(-1) < 0) { @@ -2054,8 +2054,8 @@ main(int argc, char *argv[]) /* allow super users to manage RX statistics */ rx_SetRxStatUserOk(viced_SuperUser); - CV_INIT(&fsync_cond, "fsync", CV_DEFAULT, 0); - MUTEX_INIT(&fsync_glock_mutex, "fsync", MUTEX_DEFAULT, 0); + opr_cv_init(&fsync_cond); + opr_mutex_init(&fsync_glock_mutex); #if !defined(AFS_DEMAND_ATTACH_FS) /* diff --git a/src/viced/viced.h b/src/viced/viced.h index 29e8bda86..3ff05342d 100644 --- a/src/viced/viced.h +++ b/src/viced/viced.h @@ -195,11 +195,11 @@ extern int saneacls; * HostCheck, Signal, min 2 for RXSTATS */ #include extern pthread_mutex_t fileproc_glock_mutex; -#define FS_LOCK MUTEX_ENTER(&fileproc_glock_mutex); -#define FS_UNLOCK MUTEX_EXIT(&fileproc_glock_mutex); +#define FS_LOCK opr_mutex_enter(&fileproc_glock_mutex); +#define FS_UNLOCK opr_mutex_exit(&fileproc_glock_mutex); extern pthread_mutex_t fsync_glock_mutex; -#define FSYNC_LOCK MUTEX_ENTER(&fsync_glock_mutex); -#define FSYNC_UNLOCK MUTEX_EXIT(&fsync_glock_mutex); +#define FSYNC_LOCK opr_mutex_enter(&fsync_glock_mutex); +#define FSYNC_UNLOCK opr_mutex_exit(&fsync_glock_mutex); #ifdef AFS_DEMAND_ATTACH_FS diff --git a/src/vol/fssync-client.c b/src/vol/fssync-client.c index 65ef327ff..46b44deb9 100644 --- a/src/vol/fssync-client.c +++ b/src/vol/fssync-client.c @@ -38,6 +38,10 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif + #include #include #include @@ -70,8 +74,8 @@ static SYNC_client_state fssync_state = #ifdef AFS_PTHREAD_ENV static pthread_mutex_t vol_fsync_mutex; static volatile int vol_fsync_mutex_init = 0; -#define VFSYNC_LOCK MUTEX_ENTER(&vol_fsync_mutex) -#define VFSYNC_UNLOCK MUTEX_EXIT(&vol_fsync_mutex) +#define VFSYNC_LOCK opr_mutex_enter(&vol_fsync_mutex) +#define VFSYNC_UNLOCK opr_mutex_exit(&vol_fsync_mutex) #else #define VFSYNC_LOCK #define VFSYNC_UNLOCK @@ -83,7 +87,7 @@ FSYNC_clientInit(void) #ifdef AFS_PTHREAD_ENV /* this is safe since it gets called with VOL_LOCK held, or before we go multithreaded */ if (!vol_fsync_mutex_init) { - MUTEX_INIT(&vol_fsync_mutex, "vol fsync", MUTEX_DEFAULT, 0); + opr_mutex_init(&vol_fsync_mutex); vol_fsync_mutex_init = 1; } #endif diff --git a/src/vol/fssync-debug.c b/src/vol/fssync-debug.c index 998197120..c65fc5174 100644 --- a/src/vol/fssync-debug.c +++ b/src/vol/fssync-debug.c @@ -25,6 +25,7 @@ #endif #include +#include #include #ifndef AFS_NT40_ENV @@ -38,7 +39,6 @@ #include #include "nfs.h" -#include "lwp.h" #include "lock.h" #include "ihandle.h" #include "vnode.h" diff --git a/src/vol/fssync-server.c b/src/vol/fssync-server.c index e8f169279..536aa0dc1 100644 --- a/src/vol/fssync-server.c +++ b/src/vol/fssync-server.c @@ -46,6 +46,9 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #include #include #include "nfs.h" @@ -211,7 +214,7 @@ FSYNC_fsInit(void) #ifdef AFS_DEMAND_ATTACH_FS queue_Init(&fsync_salv.head); - CV_INIT(&fsync_salv.cv, "fsync salv", CV_DEFAULT, 0); + opr_cv_init(&fsync_salv.cv); opr_Verify(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0); #endif /* AFS_DEMAND_ATTACH_FS */ } @@ -413,7 +416,7 @@ FSYNC_backgroundSalvage(Volume *vp) } queue_Append(&fsync_salv.head, node); - CV_BROADCAST(&fsync_salv.cv); + opr_cv_broadcast(&fsync_salv.cv); } #endif /* AFS_DEMAND_ATTACH_FS */ diff --git a/src/vol/ihandle.c b/src/vol/ihandle.c index 1522af11a..178d6b035 100644 --- a/src/vol/ihandle.c +++ b/src/vol/ihandle.c @@ -23,6 +23,9 @@ #endif #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #include #include #include @@ -102,7 +105,7 @@ void ih_PkgDefaults(void) void ih_glock_init(void) { - MUTEX_INIT(&ih_glock_mutex, "ih glock", MUTEX_DEFAULT, 0); + opr_mutex_init(&ih_glock_mutex); } #endif /* AFS_PTHREAD_ENV */ diff --git a/src/vol/ihandle.h b/src/vol/ihandle.h index bfec30b32..7c368770f 100644 --- a/src/vol/ihandle.h +++ b/src/vol/ihandle.h @@ -77,9 +77,9 @@ extern pthread_mutex_t ih_glock_mutex; extern void ih_glock_init(void); #define IH_LOCK \ do { opr_Verify(pthread_once(&ih_glock_once, ih_glock_init) == 0); \ - MUTEX_ENTER(&ih_glock_mutex); \ + opr_mutex_enter(&ih_glock_mutex); \ } while (0) -#define IH_UNLOCK MUTEX_EXIT(&ih_glock_mutex) +#define IH_UNLOCK opr_mutex_exit(&ih_glock_mutex) #else /* AFS_PTHREAD_ENV */ #define IH_LOCK #define IH_UNLOCK diff --git a/src/vol/namei_ops.c b/src/vol/namei_ops.c index 2823d04ef..53622a690 100644 --- a/src/vol/namei_ops.c +++ b/src/vol/namei_ops.c @@ -31,6 +31,9 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #include #include #include @@ -1453,8 +1456,8 @@ namei_GetLCOffsetAndIndexFromIno(Inode ino, afs_foff_t * offset, int *index) #ifdef AFS_PTHREAD_ENV /* XXX do static initializers work for WINNT/pthread? */ pthread_mutex_t _namei_glc_lock = PTHREAD_MUTEX_INITIALIZER; -#define NAMEI_GLC_LOCK MUTEX_ENTER(&_namei_glc_lock) -#define NAMEI_GLC_UNLOCK MUTEX_EXIT(&_namei_glc_lock) +#define NAMEI_GLC_LOCK opr_mutex_enter(&_namei_glc_lock) +#define NAMEI_GLC_UNLOCK opr_mutex_exit(&_namei_glc_lock) #else /* !AFS_PTHREAD_ENV */ #define NAMEI_GLC_LOCK #define NAMEI_GLC_UNLOCK diff --git a/src/vol/partition.c b/src/vol/partition.c index 0dc0d72a2..272ada35d 100644 --- a/src/vol/partition.c +++ b/src/vol/partition.c @@ -97,6 +97,9 @@ #endif #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #include #include #include "nfs.h" diff --git a/src/vol/salvaged.c b/src/vol/salvaged.c index 8ca71df33..e053e625a 100644 --- a/src/vol/salvaged.c +++ b/src/vol/salvaged.c @@ -33,6 +33,7 @@ #endif #include +#include #include #include @@ -516,9 +517,9 @@ SalvageServer(int argc, char **argv) DInit(10); queue_Init(&pending_q); queue_Init(&log_cleanup_queue); - MUTEX_INIT(&worker_lock, "worker", MUTEX_DEFAULT, 0); - CV_INIT(&worker_cv, "worker", CV_DEFAULT, 0); - CV_INIT(&log_cleanup_queue.queue_change_cv, "queuechange", CV_DEFAULT, 0); + opr_mutex_init(&worker_lock); + opr_cv_init(&worker_cv); + opr_cv_init(&log_cleanup_queue.queue_change_cv); opr_Verify(pthread_attr_init(&attrs) == 0); /* start up the reaper and log cleaner threads */ @@ -562,17 +563,17 @@ SalvageServer(int argc, char **argv) node->pid = pid; VOL_UNLOCK; - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); current_workers++; /* let the reaper thread know another worker was spawned */ - CV_BROADCAST(&worker_cv); + opr_cv_broadcast(&worker_cv); /* if we're overquota, wait for the reaper */ while (current_workers >= Parallel) { - CV_WAIT(&worker_cv, &worker_lock); + opr_cv_wait(&worker_cv, &worker_lock); } - MUTEX_EXIT(&worker_lock); + opr_mutex_exit(&worker_lock); } } } @@ -630,17 +631,17 @@ SalvageChildReaperThread(void * args) int slot, pid, status; struct log_cleanup_node * cleanup; - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); /* loop reaping our children */ while (1) { /* wait() won't block unless we have children, so * block on the cond var if we're childless */ while (current_workers == 0) { - CV_WAIT(&worker_cv, &worker_lock); + opr_cv_wait(&worker_cv, &worker_lock); } - MUTEX_EXIT(&worker_lock); + opr_mutex_exit(&worker_lock); cleanup = malloc(sizeof(struct log_cleanup_node)); @@ -660,17 +661,17 @@ SalvageChildReaperThread(void * args) SALVSYNC_doneWorkByPid(pid, status); - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); if (cleanup) { cleanup->pid = pid; queue_Append(&log_cleanup_queue, cleanup); - CV_SIGNAL(&log_cleanup_queue.queue_change_cv); + opr_cv_signal(&log_cleanup_queue.queue_change_cv); } /* ok, we've reaped a child */ current_workers--; - CV_BROADCAST(&worker_cv); + opr_cv_broadcast(&worker_cv); } return NULL; @@ -705,24 +706,24 @@ SalvageLogCleanupThread(void * arg) { struct log_cleanup_node * cleanup; - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); while (1) { while (queue_IsEmpty(&log_cleanup_queue)) { - CV_WAIT(&log_cleanup_queue.queue_change_cv, &worker_lock); + opr_cv_wait(&log_cleanup_queue.queue_change_cv, &worker_lock); } while (queue_IsNotEmpty(&log_cleanup_queue)) { cleanup = queue_First(&log_cleanup_queue, log_cleanup_node); queue_Remove(cleanup); - MUTEX_EXIT(&worker_lock); + opr_mutex_exit(&worker_lock); SalvageLogCleanup(cleanup->pid); free(cleanup); - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); } } - MUTEX_EXIT(&worker_lock); + opr_mutex_exit(&worker_lock); return NULL; } @@ -849,7 +850,7 @@ ScanLogs(struct rx_queue *log_watch_queue) { struct log_cleanup_node *cleanup, *next; - MUTEX_ENTER(&worker_lock); + opr_mutex_enter(&worker_lock); for (queue_Scan(log_watch_queue, cleanup, next, log_cleanup_node)) { /* if a process is still running, assume it's the salvage process @@ -857,9 +858,9 @@ ScanLogs(struct rx_queue *log_watch_queue) if (kill(cleanup->pid, 0) < 0 && errno == ESRCH) { queue_Remove(cleanup); queue_Append(&log_cleanup_queue, cleanup); - CV_SIGNAL(&log_cleanup_queue.queue_change_cv); + opr_cv_signal(&log_cleanup_queue.queue_change_cv); } } - MUTEX_EXIT(&worker_lock); + opr_mutex_exit(&worker_lock); } diff --git a/src/vol/salvsync-client.c b/src/vol/salvsync-client.c index 691e18da9..641f2414c 100644 --- a/src/vol/salvsync-client.c +++ b/src/vol/salvsync-client.c @@ -20,12 +20,12 @@ #include #include +#include #include #include #include "nfs.h" #include #include "salvsync.h" -#include "lwp.h" #include "lock.h" #include #include "ihandle.h" diff --git a/src/vol/salvsync-server.c b/src/vol/salvsync-server.c index 25a33ecd5..5cfdd9f10 100644 --- a/src/vol/salvsync-server.c +++ b/src/vol/salvsync-server.c @@ -32,13 +32,13 @@ #include #include +#include #include #include #include "nfs.h" #include #include "salvsync.h" -#include "lwp.h" #include "lock.h" #include #include "ihandle.h" diff --git a/src/vol/vg_cache.c b/src/vol/vg_cache.c index b0e460949..307b358b2 100644 --- a/src/vol/vg_cache.c +++ b/src/vol/vg_cache.c @@ -25,9 +25,9 @@ #include #include +#include #include #include -#include #include "nfs.h" #include #include "ihandle.h" diff --git a/src/vol/vg_scan.c b/src/vol/vg_scan.c index 4c9e6c604..509eadefc 100644 --- a/src/vol/vg_scan.c +++ b/src/vol/vg_scan.c @@ -26,9 +26,9 @@ #include #include +#include #include #include -#include #include "nfs.h" #include #include "ihandle.h" diff --git a/src/vol/vnode.c b/src/vol/vnode.c index 53eba8890..f7026c2ad 100644 --- a/src/vol/vnode.c +++ b/src/vol/vnode.c @@ -27,6 +27,9 @@ #endif #include +#ifdef AFS_PTHREAD_ENV +#include +#endif #include "rx/rx_queue.h" #include #include "nfs.h" diff --git a/src/vol/vnode_inline.h b/src/vol/vnode_inline.h index 31fc4f5af..67ccb6b52 100644 --- a/src/vol/vnode_inline.h +++ b/src/vol/vnode_inline.h @@ -168,7 +168,7 @@ VnChangeState_r(Vnode * vnp, VnState new_state) VnState old_state = Vn_state(vnp); Vn_state(vnp) = new_state; - CV_BROADCAST(&Vn_stateCV(vnp)); + opr_cv_broadcast(&Vn_stateCV(vnp)); return old_state; } @@ -359,7 +359,7 @@ VnEndRead_r(Vnode * vnp) opr_Assert(Vn_readers(vnp) > 0); Vn_readers(vnp)--; if (!Vn_readers(vnp)) { - CV_BROADCAST(&Vn_stateCV(vnp)); + opr_cv_broadcast(&Vn_stateCV(vnp)); VnChangeState_r(vnp, VN_STATE_ONLINE); } } diff --git a/src/vol/vol-salvage.c b/src/vol/vol-salvage.c index 23cd098d1..78ac9544e 100644 --- a/src/vol/vol-salvage.c +++ b/src/vol/vol-salvage.c @@ -100,6 +100,10 @@ Vnodes with 0 inode pointers in RW volumes are now deleted. #define WCOREDUMP(x) ((x) & 0200) #endif #include +#ifdef AFS_PTHREAD_ENV +# include +#endif + #include #if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV) #if defined(AFS_VFSINCL_ENV) diff --git a/src/vol/volume.c b/src/vol/volume.c index 7df070590..c02c1e1e5 100644 --- a/src/vol/volume.c +++ b/src/vol/volume.c @@ -31,7 +31,12 @@ #include #endif -#include +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include @@ -529,7 +534,7 @@ static void VSetVInit_r(int value) { VInit = value; - CV_BROADCAST(&vol_vinit_cond); + opr_cv_broadcast(&vol_vinit_cond); } static_inline void @@ -581,12 +586,12 @@ VInitVolumePackage2(ProgramType pt, VolumePackageOptions * opts) opr_Verify(pthread_key_create(&VThread_key, NULL) == 0); #endif - MUTEX_INIT(&vol_glock_mutex, "vol glock", MUTEX_DEFAULT, 0); - MUTEX_INIT(&vol_trans_mutex, "vol trans", MUTEX_DEFAULT, 0); - CV_INIT(&vol_put_volume_cond, "vol put", CV_DEFAULT, 0); - CV_INIT(&vol_sleep_cond, "vol sleep", CV_DEFAULT, 0); - CV_INIT(&vol_init_attach_cond, "vol init attach", CV_DEFAULT, 0); - CV_INIT(&vol_vinit_cond, "vol init", CV_DEFAULT, 0); + opr_mutex_init(&vol_glock_mutex); + opr_mutex_init(&vol_trans_mutex); + opr_cv_init(&vol_put_volume_cond); + opr_cv_init(&vol_sleep_cond); + opr_cv_init(&vol_init_attach_cond); + opr_cv_init(&vol_vinit_cond); #ifndef AFS_PTHREAD_ENV IOMGR_Initialize(); #endif /* AFS_PTHREAD_ENV */ @@ -595,7 +600,7 @@ VInitVolumePackage2(ProgramType pt, VolumePackageOptions * opts) srandom(time(0)); /* For VGetVolumeInfo */ #ifdef AFS_DEMAND_ATTACH_FS - MUTEX_INIT(&vol_salvsync_mutex, "salvsync", MUTEX_DEFAULT, 0); + opr_mutex_init(&vol_salvsync_mutex); #endif /* AFS_DEMAND_ATTACH_FS */ /* Ok, we have done enough initialization that fileserver can @@ -713,7 +718,7 @@ VInitAttachVolumes(ProgramType pt) pthread_t tid; pthread_attr_t attrs; - CV_INIT(¶ms.thread_done_cv, "thread done", CV_DEFAULT, 0); + opr_cv_init(¶ms.thread_done_cv); queue_Init(¶ms); params.n_threads_complete = 0; @@ -764,11 +769,11 @@ VInitAttachVolumes(ProgramType pt) VInitVolumePackageThread(¶ms); } - CV_DESTROY(¶ms.thread_done_cv); + opr_cv_destroy(¶ms.thread_done_cv); } VOL_LOCK; VSetVInit_r(2); /* Initialized, and all volumes have been attached */ - CV_BROADCAST(&vol_init_attach_cond); + opr_cv_broadcast(&vol_init_attach_cond); VOL_UNLOCK; return 0; } @@ -807,7 +812,7 @@ VInitVolumePackageThread(void * args) { done: params->n_threads_complete++; - CV_SIGNAL(¶ms->thread_done_cv); + opr_cv_signal(¶ms->thread_done_cv); VOL_UNLOCK; return NULL; } @@ -840,8 +845,8 @@ VInitAttachVolumes(ProgramType pt) /* create partition work queue */ queue_Init(&pq); - CV_INIT(&(pq.cv), "partq", CV_DEFAULT, 0); - MUTEX_INIT(&(pq.mutex), "partq", MUTEX_DEFAULT, 0); + opr_cv_init(&pq.cv); + opr_mutex_init(&pq.mutex); for (parts = 0, diskP = DiskPartitionList; diskP; diskP = diskP->next, parts++) { struct diskpartition_queue_t *dp; dp = malloc(sizeof(struct diskpartition_queue_t)); @@ -855,8 +860,8 @@ VInitAttachVolumes(ProgramType pt) /* create volume work queue */ queue_Init(&vq); - CV_INIT(&(vq.cv), "volq", CV_DEFAULT, 0); - MUTEX_INIT(&(vq.mutex), "volq", MUTEX_DEFAULT, 0); + opr_cv_init(&vq.cv); + opr_mutex_init(&vq.mutex); opr_Verify(pthread_attr_init(&attrs) == 0); opr_Verify(pthread_attr_setdetachstate(&attrs, @@ -888,15 +893,15 @@ VInitAttachVolumes(ProgramType pt) VInitPreAttachVolumes(threads, &vq); opr_Verify(pthread_attr_destroy(&attrs) == 0); - CV_DESTROY(&pq.cv); - MUTEX_DESTROY(&pq.mutex); - CV_DESTROY(&vq.cv); - MUTEX_DESTROY(&vq.mutex); + opr_cv_destroy(&pq.cv); + opr_mutex_destroy(&pq.mutex); + opr_cv_destroy(&vq.cv); + opr_mutex_destroy(&vq.mutex); } VOL_LOCK; VSetVInit_r(2); /* Initialized, and all volumes have been attached */ - CV_BROADCAST(&vol_init_attach_cond); + opr_cv_broadcast(&vol_init_attach_cond); VOL_UNLOCK; return 0; @@ -949,14 +954,14 @@ VInitVolumePackageThread(void *args) vp->hashid = vid; queue_Init(&vp->vnode_list); queue_Init(&vp->rx_call_list); - CV_INIT(&V_attachCV(vp), "partattach", CV_DEFAULT, 0); + opr_cv_init(&V_attachCV(vp)); vb->batch[vb->size++] = vp; if (vb->size == VINIT_BATCH_MAX_SIZE) { - MUTEX_ENTER(&vq->mutex); + opr_mutex_enter(&vq->mutex); queue_Append(vq, vb); - CV_BROADCAST(&vq->cv); - MUTEX_EXIT(&vq->mutex); + opr_cv_broadcast(&vq->cv); + opr_mutex_exit(&vq->mutex); vb = malloc(sizeof(struct volume_init_batch)); opr_Assert(vb); @@ -969,10 +974,10 @@ VInitVolumePackageThread(void *args) } vb->last = 1; - MUTEX_ENTER(&vq->mutex); + opr_mutex_enter(&vq->mutex); queue_Append(vq, vb); - CV_BROADCAST(&vq->cv); - MUTEX_EXIT(&vq->mutex); + opr_cv_broadcast(&vq->cv); + opr_mutex_exit(&vq->mutex); Log("Partition scan thread %d of %d ended\n", params->thread, params->nthreads); free(params); @@ -994,14 +999,14 @@ VInitNextPartition(struct partition_queue *pq) } /* get next partition to scan */ - MUTEX_ENTER(&pq->mutex); + opr_mutex_enter(&pq->mutex); if (queue_IsEmpty(pq)) { - MUTEX_EXIT(&pq->mutex); + opr_mutex_exit(&pq->mutex); return NULL; } dp = queue_First(pq, diskpartition_queue_t); queue_Remove(dp); - MUTEX_EXIT(&pq->mutex); + opr_mutex_exit(&pq->mutex); opr_Assert(dp); opr_Assert(dp->diskP); @@ -1049,13 +1054,13 @@ VInitPreAttachVolumes(int nthreads, struct volume_init_queue *vq) while (nthreads) { /* dequeue next volume */ - MUTEX_ENTER(&vq->mutex); + opr_mutex_enter(&vq->mutex); if (queue_IsEmpty(vq)) { - CV_WAIT(&vq->cv, &vq->mutex); + opr_cv_wait(&vq->cv, &vq->mutex); } vb = queue_First(vq, volume_init_batch); queue_Remove(vb); - MUTEX_EXIT(&vq->mutex); + opr_mutex_exit(&vq->mutex); if (vb->size) { VOL_LOCK; @@ -1234,9 +1239,9 @@ VShutdown_r(void) if (vol_attach_threads > 1) { /* prepare for parallel shutdown */ params.n_threads = vol_attach_threads; - MUTEX_INIT(¶ms.lock, "params", MUTEX_DEFAULT, 0); - CV_INIT(¶ms.cv, "params", CV_DEFAULT, 0); - CV_INIT(¶ms.master_cv, "params master", CV_DEFAULT, 0); + opr_mutex_init(¶ms.lock); + opr_cv_init(¶ms.cv); + opr_cv_init(¶ms.master_cv); opr_Verify(pthread_attr_init(&attrs) == 0); opr_Verify(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0); @@ -1277,7 +1282,7 @@ VShutdown_r(void) vol_attach_threads, params.n_parts, params.n_parts > 1 ? "s" : "" ); /* do pass 0 shutdown */ - MUTEX_ENTER(¶ms.lock); + opr_mutex_enter(¶ms.lock); for (i=0; i < params.n_threads; i++) { opr_Verify(pthread_create(&tid, &attrs, &VShutdownThread, ¶ms) == 0); @@ -1289,8 +1294,8 @@ VShutdown_r(void) } params.n_threads_complete = 0; params.pass = 1; - CV_BROADCAST(¶ms.cv); - MUTEX_EXIT(¶ms.lock); + opr_cv_broadcast(¶ms.cv); + opr_mutex_exit(¶ms.lock); Log("VShutdown: pass 0 completed using the 1 thread per partition algorithm\n"); Log("VShutdown: starting passes 1 through 3 using finely-granular mp-fast algorithm\n"); @@ -1304,9 +1309,9 @@ VShutdown_r(void) } opr_Verify(pthread_attr_destroy(&attrs) == 0); - CV_DESTROY(¶ms.cv); - CV_DESTROY(¶ms.master_cv); - MUTEX_DESTROY(¶ms.lock); + opr_cv_destroy(¶ms.cv); + opr_cv_destroy(¶ms.master_cv); + opr_mutex_destroy(¶ms.lock); /* drop the VByPList exclusive reservations */ for (diskP = DiskPartitionList; diskP; diskP = diskP->next) { @@ -1583,14 +1588,14 @@ VShutdownThread(void * args) params = (vshutdown_thread_t *) args; /* acquire the shutdown pass 0 lock */ - MUTEX_ENTER(¶ms->lock); + opr_mutex_enter(¶ms->lock); /* if there's still pass 0 work to be done, * get a work entry, and do a pass 0 shutdown */ if (queue_IsNotEmpty(params)) { dpq = queue_First(params, diskpartition_queue_t); queue_Remove(dpq); - MUTEX_EXIT(¶ms->lock); + opr_mutex_exit(¶ms->lock); diskP = dpq->diskP; free(dpq); id = diskP->index; @@ -1599,20 +1604,20 @@ VShutdownThread(void * args) while (ShutdownVolumeWalk_r(diskP, 0, ¶ms->part_pass_head[id])) count++; params->stats[0][diskP->index] = count; - MUTEX_ENTER(¶ms->lock); + opr_mutex_enter(¶ms->lock); } params->n_threads_complete++; if (params->n_threads_complete == params->n_threads) { /* notify control thread that all workers have completed pass 0 */ - CV_SIGNAL(¶ms->master_cv); + opr_cv_signal(¶ms->master_cv); } while (params->pass == 0) { - CV_WAIT(¶ms->cv, ¶ms->lock); + opr_cv_wait(¶ms->cv, ¶ms->lock); } /* switch locks */ - MUTEX_EXIT(¶ms->lock); + opr_mutex_exit(¶ms->lock); VOL_LOCK; pass = params->pass; @@ -1696,7 +1701,7 @@ VShutdownThread(void * args) ShutdownCreateSchedule(params); /* wake up all the workers */ - CV_BROADCAST(¶ms->cv); + opr_cv_broadcast(¶ms->cv); VOL_UNLOCK; Log("VShutdown: pass %d completed using %d threads on %d partitions\n", @@ -2235,7 +2240,7 @@ VPreAttachVolumeByVp_r(Error * ec, opr_Assert(vp != NULL); queue_Init(&vp->vnode_list); queue_Init(&vp->rx_call_list); - CV_INIT(&V_attachCV(vp), "vp attach", CV_DEFAULT, 0); + opr_cv_init(&V_attachCV(vp)); } /* link the volume with its associated vice partition */ @@ -2466,7 +2471,7 @@ VAttachVolumeByName_r(Error * ec, char *partition, char *name, int mode) queue_Init(&vp->vnode_list); queue_Init(&vp->rx_call_list); #ifdef AFS_DEMAND_ATTACH_FS - CV_INIT(&V_attachCV(vp), "vp attach", CV_DEFAULT, 0); + opr_cv_init(&V_attachCV(vp)); #endif /* AFS_DEMAND_ATTACH_FS */ } @@ -4389,7 +4394,7 @@ VForceOffline_r(Volume * vp, int flags) #endif /* AFS_DEMAND_ATTACH_FS */ #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&vol_put_volume_cond); + opr_cv_broadcast(&vol_put_volume_cond); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(VPutVolume); #endif /* AFS_PTHREAD_ENV */ @@ -5041,7 +5046,7 @@ VCheckDetach(Volume * vp) VCheckSalvage(vp); ReallyFreeVolume(vp); if (programType == fileServer) { - CV_BROADCAST(&vol_put_volume_cond); + opr_cv_broadcast(&vol_put_volume_cond); } } return ret; @@ -5075,7 +5080,7 @@ VCheckDetach(Volume * vp) ReallyFreeVolume(vp); if (programType == fileServer) { #if defined(AFS_PTHREAD_ENV) - CV_BROADCAST(&vol_put_volume_cond); + opr_cv_broadcast(&vol_put_volume_cond); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(VPutVolume); #endif /* AFS_PTHREAD_ENV */ @@ -5175,7 +5180,7 @@ VCheckOffline(Volume * vp) } FreeVolumeHeader(vp); #ifdef AFS_PTHREAD_ENV - CV_BROADCAST(&vol_put_volume_cond); + opr_cv_broadcast(&vol_put_volume_cond); #else /* AFS_PTHREAD_ENV */ LWP_NoYieldSignal(VPutVolume); #endif /* AFS_PTHREAD_ENV */ @@ -7131,7 +7136,7 @@ VInitVLRU(void) queue_Init(&volume_LRU.q[i]); volume_LRU.q[i].len = 0; volume_LRU.q[i].busy = 0; - CV_INIT(&volume_LRU.q[i].cv, "vol lru", CV_DEFAULT, 0); + opr_cv_init(&volume_LRU.q[i].cv); } /* setup the timing constants */ @@ -7149,7 +7154,7 @@ VInitVLRU(void) /* start up the VLRU scanner */ volume_LRU.scanner_state = VLRU_SCANNER_STATE_OFFLINE; if (programType == fileServer) { - CV_INIT(&volume_LRU.cv, "vol lru", CV_DEFAULT, 0); + opr_cv_init(&volume_LRU.cv); opr_Verify(pthread_attr_init(&attrs) == 0); opr_Verify(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0); @@ -7457,7 +7462,7 @@ VLRU_ScannerThread(void * args) /* check to see if we've been asked to pause */ if (volume_LRU.scanner_state == VLRU_SCANNER_STATE_PAUSING) { volume_LRU.scanner_state = VLRU_SCANNER_STATE_PAUSED; - CV_BROADCAST(&volume_LRU.cv); + opr_cv_broadcast(&volume_LRU.cv); do { VOL_CV_WAIT(&volume_LRU.cv); } while (volume_LRU.scanner_state == VLRU_SCANNER_STATE_PAUSED); @@ -7533,7 +7538,7 @@ VLRU_ScannerThread(void * args) /* signal that scanner is down */ volume_LRU.scanner_state = VLRU_SCANNER_STATE_OFFLINE; - CV_BROADCAST(&volume_LRU.cv); + opr_cv_broadcast(&volume_LRU.cv); VOL_UNLOCK; return NULL; } @@ -7856,7 +7861,7 @@ VLRU_EndExclusive_r(struct VLRU_q * q) { opr_Assert(q->busy); q->busy = 0; - CV_BROADCAST(&q->cv); + opr_cv_broadcast(&q->cv); } /* wait for another thread to end exclusive access on VLRU */ @@ -8372,7 +8377,7 @@ VInitVolumeHash(void) for (i=0; i < VolumeHashTable.Size; i++) { queue_Init(&VolumeHashTable.Table[i]); #ifdef AFS_DEMAND_ATTACH_FS - CV_INIT(&VolumeHashTable.Table[i].chain_busy_cv, "vhash busy", CV_DEFAULT, 0); + opr_cv_init(&VolumeHashTable.Table[i].chain_busy_cv); #endif /* AFS_DEMAND_ATTACH_FS */ } } @@ -8667,7 +8672,7 @@ VHashEndExclusive_r(VolumeHashChainHead * head) { opr_Assert(head->busy); head->busy = 0; - CV_BROADCAST(&head->chain_busy_cv); + opr_cv_broadcast(&head->chain_busy_cv); } /** @@ -8831,7 +8836,7 @@ VVByPListEndExclusive_r(struct DiskPartition64 * dp) { opr_Assert(dp->vol_list.busy); dp->vol_list.busy = 0; - CV_BROADCAST(&dp->vol_list.cv); + opr_cv_broadcast(&dp->vol_list.cv); } /** diff --git a/src/vol/volume.h b/src/vol/volume.h index 3072318db..66eaa9348 100644 --- a/src/vol/volume.h +++ b/src/vol/volume.h @@ -74,7 +74,7 @@ extern int vol_attach_threads; extern pthread_t vol_glock_holder; #define VOL_LOCK \ do { \ - MUTEX_ENTER(&vol_glock_mutex); \ + opr_mutex_enter(&vol_glock_mutex); \ VOL_LOCK_ASSERT_UNHELD; \ _VOL_LOCK_SET_HELD; \ } while (0) @@ -82,24 +82,24 @@ extern pthread_t vol_glock_holder; do { \ VOL_LOCK_ASSERT_HELD; \ _VOL_LOCK_SET_UNHELD; \ - MUTEX_EXIT(&vol_glock_mutex); \ + opr_mutex_exit(&vol_glock_mutex); \ } while (0) #define VOL_CV_WAIT(cv) \ do { \ VOL_LOCK_DBG_CV_WAIT_BEGIN; \ - CV_WAIT((cv), &vol_glock_mutex); \ + opr_cv_wait((cv), &vol_glock_mutex); \ VOL_LOCK_DBG_CV_WAIT_END; \ } while (0) #else /* !VOL_LOCK_DEBUG */ -#define VOL_LOCK MUTEX_ENTER(&vol_glock_mutex) -#define VOL_UNLOCK MUTEX_EXIT(&vol_glock_mutex) -#define VOL_CV_WAIT(cv) CV_WAIT((cv), &vol_glock_mutex) +#define VOL_LOCK opr_mutex_enter(&vol_glock_mutex) +#define VOL_UNLOCK opr_mutex_exit(&vol_glock_mutex) +#define VOL_CV_WAIT(cv) opr_cv_wait((cv), &vol_glock_mutex) #endif /* !VOL_LOCK_DEBUG */ -#define VSALVSYNC_LOCK MUTEX_ENTER(&vol_salvsync_mutex) -#define VSALVSYNC_UNLOCK MUTEX_EXIT(&vol_salvsync_mutex) -#define VTRANS_LOCK MUTEX_ENTER(&vol_trans_mutex) -#define VTRANS_UNLOCK MUTEX_EXIT(&vol_trans_mutex) +#define VSALVSYNC_LOCK opr_mutex_enter(&vol_salvsync_mutex) +#define VSALVSYNC_UNLOCK opr_mutex_exit(&vol_salvsync_mutex) +#define VTRANS_LOCK opr_mutex_enter(&vol_trans_mutex) +#define VTRANS_UNLOCK opr_mutex_exit(&vol_trans_mutex) #else /* AFS_PTHREAD_ENV */ #define VOL_LOCK #define VOL_UNLOCK diff --git a/src/vol/volume_inline.h b/src/vol/volume_inline.h index 58ac91b39..37073571d 100644 --- a/src/vol/volume_inline.h +++ b/src/vol/volume_inline.h @@ -40,7 +40,7 @@ VOL_CV_TIMEDWAIT(pthread_cond_t *cv, const struct timespec *ts, int *timedout) return; } VOL_LOCK_DBG_CV_WAIT_BEGIN; - code = CV_TIMEDWAIT(cv, &vol_glock_mutex, ts); + code = opr_cv_timedwait(cv, &vol_glock_mutex, ts); VOL_LOCK_DBG_CV_WAIT_END; if (code == ETIMEDOUT) { code = 0; @@ -547,7 +547,7 @@ VChangeState_r(Volume * vp, VolState new_state) VStats.state_levels[new_state]++; V_attachState(vp) = new_state; - CV_BROADCAST(&V_attachCV(vp)); + opr_cv_broadcast(&V_attachCV(vp)); return old_state; } diff --git a/src/vol/vutil.c b/src/vol/vutil.c index 3c7d395f8..9db42a467 100644 --- a/src/vol/vutil.c +++ b/src/vol/vutil.c @@ -27,6 +27,12 @@ #include #endif +#ifdef AFS_PTHREAD_ENV +# include +#else +# include +#endif + #include #include #include @@ -891,7 +897,7 @@ VLockFileInit(struct VLockFile *lf, const char *path) memset(lf, 0, sizeof(*lf)); lf->path = strdup(path); lf->fd = INVALID_FD; - MUTEX_INIT(&lf->mutex, "vlockfile", MUTEX_DEFAULT, 0); + opr_mutex_init(&lf->mutex); } #ifdef AFS_NT40_ENV @@ -1092,7 +1098,7 @@ _VUnlockFd(FD_t fd, afs_uint32 offset) void VLockFileReinit(struct VLockFile *lf) { - MUTEX_ENTER(&lf->mutex); + opr_mutex_enter(&lf->mutex); if (lf->fd != INVALID_FD) { _VCloseFd(lf->fd); @@ -1101,7 +1107,7 @@ VLockFileReinit(struct VLockFile *lf) lf->refcount = 0; - MUTEX_EXIT(&lf->mutex); + opr_mutex_exit(&lf->mutex); } /** @@ -1133,29 +1139,29 @@ VLockFileLock(struct VLockFile *lf, afs_uint32 offset, int locktype, int nonbloc opr_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK); - MUTEX_ENTER(&lf->mutex); + opr_mutex_enter(&lf->mutex); if (lf->fd == INVALID_FD) { lf->fd = _VOpenPath(lf->path); if (lf->fd == INVALID_FD) { - MUTEX_EXIT(&lf->mutex); + opr_mutex_exit(&lf->mutex); return EIO; } } lf->refcount++; - MUTEX_EXIT(&lf->mutex); + opr_mutex_exit(&lf->mutex); code = _VLockFd(lf->fd, offset, locktype, nonblock); if (code) { - MUTEX_ENTER(&lf->mutex); + opr_mutex_enter(&lf->mutex); if (--lf->refcount < 1) { _VCloseFd(lf->fd); lf->fd = INVALID_FD; } - MUTEX_EXIT(&lf->mutex); + opr_mutex_exit(&lf->mutex); } return code; @@ -1164,7 +1170,7 @@ VLockFileLock(struct VLockFile *lf, afs_uint32 offset, int locktype, int nonbloc void VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset) { - MUTEX_ENTER(&lf->mutex); + opr_mutex_enter(&lf->mutex); opr_Assert(lf->fd != INVALID_FD); @@ -1175,7 +1181,7 @@ VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset) _VUnlockFd(lf->fd, offset); } - MUTEX_EXIT(&lf->mutex); + opr_mutex_exit(&lf->mutex); } #ifdef AFS_DEMAND_ATTACH_FS @@ -1192,8 +1198,8 @@ VDiskLockInit(struct VDiskLock *dl, struct VLockFile *lf, afs_uint32 offset) opr_Assert(lf); memset(dl, 0, sizeof(*dl)); Lock_Init(&dl->rwlock); - MUTEX_INIT(&dl->mutex, "disklock", MUTEX_DEFAULT, 0); - CV_INIT(&dl->cv, "disklock cv", CV_DEFAULT, 0); + opr_mutex_init(&dl->mutex); + opr_cv_init(&dl->cv); dl->lockfile = lf; dl->offset = offset; } @@ -1243,7 +1249,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock) ObtainWriteLock(&dl->rwlock); } - MUTEX_ENTER(&dl->mutex); + opr_mutex_enter(&dl->mutex); if ((dl->flags & VDISKLOCK_ACQUIRING)) { /* Some other thread is waiting to acquire an fs lock. If nonblock=1, @@ -1254,7 +1260,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock) code = EBUSY; } else { while ((dl->flags & VDISKLOCK_ACQUIRING)) { - CV_WAIT(&dl->cv, &dl->mutex); + opr_cv_wait(&dl->cv, &dl->mutex); } } } @@ -1271,9 +1277,9 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock) /* mark that we are waiting on the fs lock */ dl->flags |= VDISKLOCK_ACQUIRING; - MUTEX_EXIT(&dl->mutex); + opr_mutex_exit(&dl->mutex); code = VLockFileLock(dl->lockfile, dl->offset, locktype, nonblock); - MUTEX_ENTER(&dl->mutex); + opr_mutex_enter(&dl->mutex); dl->flags &= ~VDISKLOCK_ACQUIRING; @@ -1281,7 +1287,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock) dl->flags |= VDISKLOCK_ACQUIRED; } - CV_BROADCAST(&dl->cv); + opr_cv_broadcast(&dl->cv); } } @@ -1297,7 +1303,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock) ++dl->lockers; } - MUTEX_EXIT(&dl->mutex); + opr_mutex_exit(&dl->mutex); return code; } @@ -1317,7 +1323,7 @@ VReleaseDiskLock(struct VDiskLock *dl, int locktype) { opr_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK); - MUTEX_ENTER(&dl->mutex); + opr_mutex_enter(&dl->mutex); opr_Assert(dl->lockers > 0); if (--dl->lockers < 1) { @@ -1327,7 +1333,7 @@ VReleaseDiskLock(struct VDiskLock *dl, int locktype) dl->flags &= ~VDISKLOCK_ACQUIRED; } - MUTEX_EXIT(&dl->mutex); + opr_mutex_exit(&dl->mutex); if (locktype == READ_LOCK) { ReleaseReadLock(&dl->rwlock); diff --git a/src/volser/volmain.c b/src/volser/volmain.c index 7ac31c20c..e6a418580 100644 --- a/src/volser/volmain.c +++ b/src/volser/volmain.c @@ -12,13 +12,15 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #ifdef AFS_NT40_ENV #include #include #endif -#include #include #include #include diff --git a/src/volser/volprocs.c b/src/volser/volprocs.c index f85944486..dd3eb7bc8 100644 --- a/src/volser/volprocs.c +++ b/src/volser/volprocs.c @@ -15,6 +15,10 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif + #include #include #include diff --git a/src/volser/volser.p.h b/src/volser/volser.p.h index 8d2b3ed90..ce6933144 100644 --- a/src/volser/volser.p.h +++ b/src/volser/volser.p.h @@ -71,13 +71,13 @@ struct volser_trans { #ifdef AFS_PTHREAD_ENV #define VTRANS_OBJ_LOCK_INIT(tt) \ - MUTEX_INIT(&((tt)->lock), "vtrans obj", MUTEX_DEFAULT, 0); + opr_mutex_init(&((tt)->lock)); #define VTRANS_OBJ_LOCK_DESTROY(tt) \ - MUTEX_DESTROY(&((tt)->lock)) + opr_mutex_destroy(&((tt)->lock)) #define VTRANS_OBJ_LOCK(tt) \ - MUTEX_ENTER(&((tt)->lock)) + opr_mutex_enter(&((tt)->lock)) #define VTRANS_OBJ_UNLOCK(tt) \ - MUTEX_EXIT(&((tt)->lock)) + opr_mutex_exit(&((tt)->lock)) #else #define VTRANS_OBJ_LOCK_INIT(tt) #define VTRANS_OBJ_LOCK_DESTROY(tt) diff --git a/src/volser/voltrans.c b/src/volser/voltrans.c index cefe6d143..41b4b4571 100644 --- a/src/volser/voltrans.c +++ b/src/volser/voltrans.c @@ -20,6 +20,9 @@ #include #include +#ifdef AFS_PTHREAD_ENV +# include +#endif #ifdef AFS_NT40_ENV #include -- 2.39.5