reindent-20030715

[openafs.git] / src / lwp / lock.c

diff --git a/src/lwp/lock.c b/src/lwp/lock.c
index b84fd7a..2ae040f 100644 (file)
--- a/src/lwp/lock.c
+++ b/src/lwp/lock.c
@@ -25,7 +25,8 @@
 #include <afsconfig.h>
 #include <afs/param.h>
 
-RCSID("$Header$");
+RCSID
+    ("$Header$");
 
 #ifdef AFS_PTHREAD_ENV
 #include <afs/assert.h>
@@ -39,20 +40,25 @@ RCSID("$Header$");
 #define FALSE  0
 #define TRUE   1
 
-void Lock_Init(struct Lock *lock)
+void
+Lock_Init(struct Lock *lock)
 {
-    lock -> readers_reading = 0;
-    lock -> excl_locked = 0;
-    lock -> wait_states = 0;
-    lock -> num_waiting = 0;
+    lock->readers_reading = 0;
+    lock->excl_locked = 0;
+    lock->wait_states = 0;
+    lock->num_waiting = 0;
 #ifdef AFS_PTHREAD_ENV
-    assert(pthread_mutex_init(&lock->mutex, (const pthread_mutexattr_t*)0)==0);
-    assert(pthread_cond_init(&lock->read_cv, (const pthread_condattr_t*)0)==0);
-    assert(pthread_cond_init(&lock->write_cv, (const pthread_condattr_t*)0)==0);
+    assert(pthread_mutex_init(&lock->mutex, (const pthread_mutexattr_t *)0) ==
+          0);
+    assert(pthread_cond_init(&lock->read_cv, (const pthread_condattr_t *)0) ==
+          0);
+    assert(pthread_cond_init(&lock->write_cv, (const pthread_condattr_t *)0)
+          == 0);
 #endif /* AFS_PTHRED_ENV */
 }
 
-void Lock_Destroy(struct Lock *lock)
+void
+Lock_Destroy(struct Lock *lock)
 {
 #ifdef AFS_PTHREAD_ENV
     assert(pthread_mutex_destroy(&lock->mutex) == 0);
@@ -61,73 +67,76 @@ void Lock_Destroy(struct Lock *lock)
 #endif /* AFS_PTHRED_ENV */
 }
 \f
-void Afs_Lock_Obtain(struct Lock * lock, int how)
+void
+Afs_Lock_Obtain(struct Lock *lock, int how)
 {
     switch (how) {
 
-       case READ_LOCK:         lock->num_waiting++;
-                               do {
-                                   lock -> wait_states |= READ_LOCK;
+    case READ_LOCK:
+       lock->num_waiting++;
+       do {
+           lock->wait_states |= READ_LOCK;
 #ifdef AFS_PTHREAD_ENV
-                                   assert(pthread_cond_wait(&lock->read_cv,
-                                               &lock->mutex) == 0);
+           assert(pthread_cond_wait(&lock->read_cv, &lock->mutex) == 0);
 #else /* AFS_PTHREAD_ENV */
-                                   LWP_WaitProcess(&lock->readers_reading);
+           LWP_WaitProcess(&lock->readers_reading);
 #endif /* AFS_PTHREAD_ENV */
-                               } while (lock->excl_locked & WRITE_LOCK);
-                               lock->num_waiting--;
-                               lock->readers_reading++;
-                               break;
-
-       case WRITE_LOCK:        lock->num_waiting++;
-                               do {
-                                   lock -> wait_states |= WRITE_LOCK;
+       } while (lock->excl_locked & WRITE_LOCK);
+       lock->num_waiting--;
+       lock->readers_reading++;
+       break;
+
+    case WRITE_LOCK:
+       lock->num_waiting++;
+       do {
+           lock->wait_states |= WRITE_LOCK;
 #ifdef AFS_PTHREAD_ENV
-                                   assert(pthread_cond_wait(&lock->write_cv,
-                                               &lock->mutex) == 0);
+           assert(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0);
 #else /* AFS_PTHREAD_ENV */
-                                   LWP_WaitProcess(&lock->excl_locked);
+           LWP_WaitProcess(&lock->excl_locked);
 #endif /* AFS_PTHREAD_ENV */
-                               } while (lock->excl_locked || lock->readers_reading);
-                               lock->num_waiting--;
-                               lock->excl_locked = WRITE_LOCK;
-                               break;
-
-       case SHARED_LOCK:       lock->num_waiting++;
-                               do {
-                                   lock->wait_states |= SHARED_LOCK;
+       } while (lock->excl_locked || lock->readers_reading);
+       lock->num_waiting--;
+       lock->excl_locked = WRITE_LOCK;
+       break;
+
+    case SHARED_LOCK:
+       lock->num_waiting++;
+       do {
+           lock->wait_states |= SHARED_LOCK;
 #ifdef AFS_PTHREAD_ENV
-                                   assert(pthread_cond_wait(&lock->write_cv,
-                                               &lock->mutex) == 0);
+           assert(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0);
 #else /* AFS_PTHREAD_ENV */
-                                   LWP_WaitProcess(&lock->excl_locked);
+           LWP_WaitProcess(&lock->excl_locked);
 #endif /* AFS_PTHREAD_ENV */
-                               } while (lock->excl_locked);
-                               lock->num_waiting--;
-                               lock->excl_locked = SHARED_LOCK;
-                               break;
-
-       case BOOSTED_LOCK:      lock->num_waiting++;
-                               do {
-                                   lock->wait_states |= WRITE_LOCK;
+       } while (lock->excl_locked);
+       lock->num_waiting--;
+       lock->excl_locked = SHARED_LOCK;
+       break;
+
+    case BOOSTED_LOCK:
+       lock->num_waiting++;
+       do {
+           lock->wait_states |= WRITE_LOCK;
 #ifdef AFS_PTHREAD_ENV
-                                   assert(pthread_cond_wait(&lock->write_cv,
-                                               &lock->mutex) == 0);
+           assert(pthread_cond_wait(&lock->write_cv, &lock->mutex) == 0);
 #else /* AFS_PTHREAD_ENV */
-                                   LWP_WaitProcess(&lock->excl_locked);
+           LWP_WaitProcess(&lock->excl_locked);
 #endif /* AFS_PTHREAD_ENV */
-                               } while (lock->readers_reading);
-                               lock->num_waiting--;
-                               lock->excl_locked = WRITE_LOCK;
-                               break;
-
-       default:                printf("Can't happen, bad LOCK type: %d\n", how);
-                               assert(0);
+       } while (lock->readers_reading);
+       lock->num_waiting--;
+       lock->excl_locked = WRITE_LOCK;
+       break;
+
+    default:
+       printf("Can't happen, bad LOCK type: %d\n", how);
+       assert(0);
     }
 }
 
 /* wake up readers waiting for this lock */
-void Afs_Lock_WakeupR(struct Lock *lock)
+void
+Afs_Lock_WakeupR(struct Lock *lock)
 {
     if (lock->wait_states & READ_LOCK) {
        lock->wait_states &= ~READ_LOCK;
@@ -140,7 +149,8 @@ void Afs_Lock_WakeupR(struct Lock *lock)
 }
 
 /* release a lock, giving preference to new readers */
-void Afs_Lock_ReleaseR(struct Lock *lock)
+void
+Afs_Lock_ReleaseR(struct Lock *lock)
 {
     if (lock->wait_states & READ_LOCK) {
        lock->wait_states &= ~READ_LOCK;
@@ -149,8 +159,7 @@ void Afs_Lock_ReleaseR(struct Lock *lock)
 #else /* AFS_PTHREAD_ENV */
        LWP_NoYieldSignal(&lock->readers_reading);
 #endif /* AFS_PTHREAD_ENV */
-    }
-    else {
+    } else {
        lock->wait_states &= ~EXCL_LOCKS;
 #ifdef AFS_PTHREAD_ENV
        assert(pthread_cond_broadcast(&lock->write_cv) == 0);
@@ -161,7 +170,8 @@ void Afs_Lock_ReleaseR(struct Lock *lock)
 }
 
 /* release a lock, giving preference to new writers */
-void Afs_Lock_ReleaseW(struct Lock * lock)
+void
+Afs_Lock_ReleaseW(struct Lock *lock)
 {
     if (lock->wait_states & EXCL_LOCKS) {
        lock->wait_states &= ~EXCL_LOCKS;
@@ -170,8 +180,7 @@ void Afs_Lock_ReleaseW(struct Lock * lock)
 #else /* AFS_PTHREAD_ENV */
        LWP_NoYieldSignal(&lock->excl_locked);
 #endif /* AFS_PTHREAD_ENV */
-    }
-    else {
+    } else {
        lock->wait_states &= ~READ_LOCK;
 #ifdef AFS_PTHREAD_ENV
        assert(pthread_cond_broadcast(&lock->read_cv) == 0);
@@ -187,25 +196,31 @@ void Afs_Lock_ReleaseW(struct Lock * lock)
  */
 
 /* release a write lock and sleep on an address, atomically */
-void LWP_WaitProcessR(addr, alock)
-register char *addr;
-register struct Lock *alock; {
+void
+LWP_WaitProcessR(addr, alock)
+     register char *addr;
+     register struct Lock *alock;
+{
     ReleaseReadLock(alock);
     LWP_WaitProcess(addr);
 }
 
 /* release a write lock and sleep on an address, atomically */
-void LWP_WaitProcessW(addr, alock)
-register char *addr;
-register struct Lock *alock; {
+void
+LWP_WaitProcessW(addr, alock)
+     register char *addr;
+     register struct Lock *alock;
+{
     ReleaseWriteLock(alock);
     LWP_WaitProcess(addr);
 }
 
 /* release a write lock and sleep on an address, atomically */
-void LWP_WaitProcessS(addr, alock)
-register char *addr;
-register struct Lock *alock; {
+void
+LWP_WaitProcessS(addr, alock)
+     register char *addr;
+     register struct Lock *alock;
+{
     ReleaseSharedLock(alock);
     LWP_WaitProcess(addr);
 }