[hcoop/debian/openafs.git] / src / afs / afs_lock.c

/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 *
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

/*******************************************************************\
* 								    *
* 	Information Technology Center				    *
* 	Carnegie-Mellon University				    *
* 								    *
* 								    *
* 								    *
\*******************************************************************/


/*
	Locking routines for Vice.

*/

#include <afsconfig.h>
#include "afs/param.h"


#include "afs/sysincludes.h"	/* Standard vendor system headers */
#include "afsincludes.h"	/* Afs-based standard headers */
#include "afs/afs_stats.h"	/* afs statistics */

/* probably needed if lock_trace is enabled - should ifdef */
int afs_trclock = 0;

void Lock_ReleaseR(struct afs_lock *lock);
void Lock_ReleaseW(struct afs_lock *lock);

void
Lock_Init(struct afs_lock *lock)
{

    AFS_STATCNT(Lock_Init);
    lock->readers_reading = 0;
    lock->excl_locked = 0;
    lock->wait_states = 0;
    lock->num_waiting = 0;
#if defined(INSTRUMENT_LOCKS)
    lock->pid_last_reader = 0;
    lock->pid_writer = 0;
    lock->src_indicator = 0;
#endif /* INSTRUMENT_LOCKS */
    lock->time_waiting.tv_sec = 0;
    lock->time_waiting.tv_usec = 0;
}

void
ObtainLock(struct afs_lock *lock, int how,
	   unsigned int src_indicator)
{
    switch (how) {
    case READ_LOCK:
	if (!((lock)->excl_locked & WRITE_LOCK))
	    (lock)->readers_reading++;
	else
	    Afs_Lock_Obtain(lock, READ_LOCK);
#if defined(INSTRUMENT_LOCKS)
	(lock)->pid_last_reader = MyPidxx;
#endif /* INSTRUMENT_LOCKS */
	break;
    case WRITE_LOCK:
	if (!(lock)->excl_locked && !(lock)->readers_reading)
	    (lock)->excl_locked = WRITE_LOCK;
	else
	    Afs_Lock_Obtain(lock, WRITE_LOCK);
#if defined(INSTRUMENT_LOCKS)
	(lock)->pid_writer = MyPidxx;
	(lock)->src_indicator = src_indicator;
#endif /* INSTRUMENT_LOCKS */
	break;
    case SHARED_LOCK:
	if (!(lock)->excl_locked)
	    (lock)->excl_locked = SHARED_LOCK;
	else
	    Afs_Lock_Obtain(lock, SHARED_LOCK);
#if defined(INSTRUMENT_LOCKS)
	(lock)->pid_writer = MyPidxx;
	(lock)->src_indicator = src_indicator;
#endif /* INSTRUMENT_LOCKS */
	break;
    }
}

void
ReleaseLock(struct afs_lock *lock, int how)
{
    if (how == READ_LOCK) {
	if (!--lock->readers_reading && lock->wait_states) {
#if defined(INSTRUMENT_LOCKS)
	    if (lock->pid_last_reader == MyPidxx)
		lock->pid_last_reader = 0;
#endif /* INSTRUMENT_LOCKS */
	    Afs_Lock_ReleaseW(lock);
	}
    } else if (how == WRITE_LOCK) {
	lock->excl_locked &= ~WRITE_LOCK;
#if defined(INSTRUMENT_LOCKS)
	lock->pid_writer = 0;
#endif /* INSTRUMENT_LOCKS */
	if (lock->wait_states)
	    Afs_Lock_ReleaseR(lock);
    } else if (how == SHARED_LOCK) {
	lock->excl_locked &= ~(SHARED_LOCK | WRITE_LOCK);
#if defined(INSTRUMENT_LOCKS)
	lock->pid_writer = 0;
#endif /* INSTRUMENT_LOCKS */
	if (lock->wait_states)
	    Afs_Lock_ReleaseR(lock);
    }
}

void
Afs_Lock_Obtain(struct afs_lock *lock, int how)
{
    osi_timeval_t tt1, tt2, et;
    afs_uint32 us;

    AFS_STATCNT(Lock_Obtain);

    AFS_ASSERT_GLOCK();
    osi_GetuTime(&tt1);

    switch (how) {

    case READ_LOCK:
	lock->num_waiting++;
	do {
	    lock->wait_states |= READ_LOCK;
	    afs_osi_Sleep(&lock->readers_reading);
	} 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;
	    afs_osi_Sleep(&lock->excl_locked);
	} 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;
	    afs_osi_Sleep(&lock->excl_locked);
	} 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;
	    afs_osi_Sleep(&lock->excl_locked);
	} while (lock->readers_reading);
	lock->num_waiting--;
	lock->excl_locked = WRITE_LOCK;
	break;

    default:
	osi_Panic("afs locktype");
    }

    osi_GetuTime(&tt2);
    afs_stats_GetDiff(et, tt1, tt2);
    afs_stats_AddTo((lock->time_waiting), et);
    us = (et.tv_sec << 20) + et.tv_usec;

    if (afs_trclock) {
	afs_Trace3(afs_iclSetp, CM_TRACE_LOCKSLEPT, ICL_TYPE_INT32, us,
		   ICL_TYPE_POINTER, lock, ICL_TYPE_INT32, how);
    }
}

/* release a lock, giving preference to new readers */
void
Afs_Lock_ReleaseR(struct afs_lock *lock)
{
    AFS_STATCNT(Lock_ReleaseR);
    AFS_ASSERT_GLOCK();
    if (lock->wait_states & READ_LOCK) {
	lock->wait_states &= ~READ_LOCK;
	afs_osi_Wakeup(&lock->readers_reading);
    } else {
	lock->wait_states &= ~EXCL_LOCKS;
	afs_osi_Wakeup(&lock->excl_locked);
    }
}

/* release a lock, giving preference to new writers */
void
Afs_Lock_ReleaseW(struct afs_lock *lock)
{
    AFS_STATCNT(Lock_ReleaseW);
    AFS_ASSERT_GLOCK();
    if (lock->wait_states & EXCL_LOCKS) {
	lock->wait_states &= ~EXCL_LOCKS;
	afs_osi_Wakeup(&lock->excl_locked);
    } else {
	lock->wait_states &= ~READ_LOCK;
	afs_osi_Wakeup(&lock->readers_reading);
    }
}

/*
Wait for some change in the lock status.
void Lock_Wait(struct afs_lock *lock)
{
    AFS_STATCNT(Lock_Wait);
    if (lock->readers_reading || lock->excl_locked) return 1;
    lock->wait_states |= READ_LOCK;
    afs_osi_Sleep(&lock->readers_reading);
    return 0;
}
*/

/* These next guys exist to provide an interface to drop a lock atomically with
 * blocking.  They're trivial to do in a non-preemptive LWP environment.
 */

/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepR(char *addr, struct afs_lock *alock)
{
    AFS_STATCNT(osi_SleepR);
    ReleaseReadLock(alock);
    afs_osi_Sleep(addr);
}

/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepW(char *addr, struct afs_lock *alock)
{
    AFS_STATCNT(osi_SleepW);
    ReleaseWriteLock(alock);
    afs_osi_Sleep(addr);
}

/* release a write lock and sleep on an address, atomically */
void
afs_osi_SleepS(char *addr, struct afs_lock *alock)
{
    AFS_STATCNT(osi_SleepS);
    ReleaseSharedLock(alock);
    afs_osi_Sleep(addr);
}

/* Not static - used conditionally if lock tracing is enabled */
int
Afs_Lock_Trace(int op, struct afs_lock *alock, int type, char *file, int line)
{
    int traceok;
    struct afs_icl_log *tlp;
    struct afs_icl_set *tsp;

    if (!afs_trclock)
	return 1;
    if ((alock) == &afs_icl_lock)
	return 1;

    ObtainReadLock(&afs_icl_lock);
    traceok = 1;
    for (tlp = afs_icl_allLogs; tlp; tlp = tlp->nextp)
	if ((alock) == &tlp->lock)
	    traceok = 0;
    for (tsp = afs_icl_allSets; tsp; tsp = tsp->nextp)
	if ((alock) == &tsp->lock)
	    traceok = 0;
    ReleaseReadLock(&afs_icl_lock);
    if (!traceok)
	return 1;

    afs_Trace4(afs_iclSetp, op, ICL_TYPE_STRING, (long)file, ICL_TYPE_INT32,
	       (long)line, ICL_TYPE_POINTER, (long)alock, ICL_TYPE_LONG,
	       (long)type);
    return 0;
}
Commit	Line	Data
805e021f CE	1	/*
	2	* Copyright 2000, International Business Machines Corporation and others.
	3	* All Rights Reserved.
	4	*
	5	* This software has been released under the terms of the IBM Public
	6	* License. For details, see the LICENSE file in the top-level source
	7	* directory or online at http://www.openafs.org/dl/license10.html
	8	*/
	9
	10	/*******************************************************************\
	11	* *
	12	* Information Technology Center *
	13	* Carnegie-Mellon University *
	14	* *
	15	* *
	16	* *
	17	\*******************************************************************/
	18
	19
	20	/*
	21	Locking routines for Vice.
	22
	23	*/
	24
	25	#include <afsconfig.h>
	26	#include "afs/param.h"
	27
	28
	29	#include "afs/sysincludes.h" /* Standard vendor system headers */
	30	#include "afsincludes.h" /* Afs-based standard headers */
	31	#include "afs/afs_stats.h" /* afs statistics */
	32
	33	/* probably needed if lock_trace is enabled - should ifdef */
	34	int afs_trclock = 0;
	35
	36	void Lock_ReleaseR(struct afs_lock *lock);
	37	void Lock_ReleaseW(struct afs_lock *lock);
	38
	39	void
	40	Lock_Init(struct afs_lock *lock)
	41	{
	42
	43	AFS_STATCNT(Lock_Init);
	44	lock->readers_reading = 0;
	45	lock->excl_locked = 0;
	46	lock->wait_states = 0;
	47	lock->num_waiting = 0;
	48	#if defined(INSTRUMENT_LOCKS)
	49	lock->pid_last_reader = 0;
	50	lock->pid_writer = 0;
	51	lock->src_indicator = 0;
	52	#endif /* INSTRUMENT_LOCKS */
	53	lock->time_waiting.tv_sec = 0;
	54	lock->time_waiting.tv_usec = 0;
	55	}
	56
	57	void
	58	ObtainLock(struct afs_lock *lock, int how,
	59	unsigned int src_indicator)
	60	{
	61	switch (how) {
	62	case READ_LOCK:
	63	if (!((lock)->excl_locked & WRITE_LOCK))
	64	(lock)->readers_reading++;
65	else
66	Afs_Lock_Obtain(lock, READ_LOCK);
67	#if defined(INSTRUMENT_LOCKS)
68	(lock)->pid_last_reader = MyPidxx;
69	#endif /* INSTRUMENT_LOCKS */
70	break;
71	case WRITE_LOCK:
72	if (!(lock)->excl_locked && !(lock)->readers_reading)
73	(lock)->excl_locked = WRITE_LOCK;
74	else
75	Afs_Lock_Obtain(lock, WRITE_LOCK);
76	#if defined(INSTRUMENT_LOCKS)
77	(lock)->pid_writer = MyPidxx;
78	(lock)->src_indicator = src_indicator;
79	#endif /* INSTRUMENT_LOCKS */
80	break;
81	case SHARED_LOCK:
82	if (!(lock)->excl_locked)
83	(lock)->excl_locked = SHARED_LOCK;
84	else
85	Afs_Lock_Obtain(lock, SHARED_LOCK);
86	#if defined(INSTRUMENT_LOCKS)
87	(lock)->pid_writer = MyPidxx;
88	(lock)->src_indicator = src_indicator;
89	#endif /* INSTRUMENT_LOCKS */
90	break;
91	}
92	}
93
94	void
95	ReleaseLock(struct afs_lock *lock, int how)
96	{
97	if (how == READ_LOCK) {
98	if (!--lock->readers_reading && lock->wait_states) {
99	#if defined(INSTRUMENT_LOCKS)
100	if (lock->pid_last_reader == MyPidxx)
101	lock->pid_last_reader = 0;
102	#endif /* INSTRUMENT_LOCKS */
103	Afs_Lock_ReleaseW(lock);
104	}
105	} else if (how == WRITE_LOCK) {
106	lock->excl_locked &= ~WRITE_LOCK;
107	#if defined(INSTRUMENT_LOCKS)
108	lock->pid_writer = 0;
109	#endif /* INSTRUMENT_LOCKS */
110	if (lock->wait_states)
111	Afs_Lock_ReleaseR(lock);
112	} else if (how == SHARED_LOCK) {
113	lock->excl_locked &= ~(SHARED_LOCK \| WRITE_LOCK);
114	#if defined(INSTRUMENT_LOCKS)
115	lock->pid_writer = 0;
116	#endif /* INSTRUMENT_LOCKS */
117	if (lock->wait_states)
118	Afs_Lock_ReleaseR(lock);
119	}
120	}
121
122	void
123	Afs_Lock_Obtain(struct afs_lock *lock, int how)
124	{
125	osi_timeval_t tt1, tt2, et;
126	afs_uint32 us;
127
128	AFS_STATCNT(Lock_Obtain);
129
130	AFS_ASSERT_GLOCK();
131	osi_GetuTime(&tt1);
132
133	switch (how) {
134
135	case READ_LOCK:
136	lock->num_waiting++;
137	do {
138	lock->wait_states \|= READ_LOCK;
139	afs_osi_Sleep(&lock->readers_reading);
140	} while (lock->excl_locked & WRITE_LOCK);
141	lock->num_waiting--;
142	lock->readers_reading++;
143	break;
144
145	case WRITE_LOCK:
146	lock->num_waiting++;
147	do {
148	lock->wait_states \|= WRITE_LOCK;
149	afs_osi_Sleep(&lock->excl_locked);
150	} while (lock->excl_locked \|\| lock->readers_reading);
151	lock->num_waiting--;
152	lock->excl_locked = WRITE_LOCK;
153	break;
154
155	case SHARED_LOCK:
156	lock->num_waiting++;
157	do {
158	lock->wait_states \|= SHARED_LOCK;
159	afs_osi_Sleep(&lock->excl_locked);
160	} while (lock->excl_locked);
161	lock->num_waiting--;
162	lock->excl_locked = SHARED_LOCK;
163	break;
164
165	case BOOSTED_LOCK:
166	lock->num_waiting++;
167	do {
168	lock->wait_states \|= WRITE_LOCK;
169	afs_osi_Sleep(&lock->excl_locked);
170	} while (lock->readers_reading);
171	lock->num_waiting--;
172	lock->excl_locked = WRITE_LOCK;
173	break;
174
175	default:
176	osi_Panic("afs locktype");
177	}
178
179	osi_GetuTime(&tt2);
180	afs_stats_GetDiff(et, tt1, tt2);
181	afs_stats_AddTo((lock->time_waiting), et);
182	us = (et.tv_sec << 20) + et.tv_usec;
183
184	if (afs_trclock) {
185	afs_Trace3(afs_iclSetp, CM_TRACE_LOCKSLEPT, ICL_TYPE_INT32, us,
186	ICL_TYPE_POINTER, lock, ICL_TYPE_INT32, how);
187	}
188	}
189
190	/* release a lock, giving preference to new readers */
191	void
192	Afs_Lock_ReleaseR(struct afs_lock *lock)
193	{
194	AFS_STATCNT(Lock_ReleaseR);
195	AFS_ASSERT_GLOCK();
196	if (lock->wait_states & READ_LOCK) {
197	lock->wait_states &= ~READ_LOCK;
198	afs_osi_Wakeup(&lock->readers_reading);
199	} else {
200	lock->wait_states &= ~EXCL_LOCKS;
201	afs_osi_Wakeup(&lock->excl_locked);
202	}
203	}
204
205	/* release a lock, giving preference to new writers */
206	void
207	Afs_Lock_ReleaseW(struct afs_lock *lock)
208	{
209	AFS_STATCNT(Lock_ReleaseW);
210	AFS_ASSERT_GLOCK();
211	if (lock->wait_states & EXCL_LOCKS) {
212	lock->wait_states &= ~EXCL_LOCKS;
213	afs_osi_Wakeup(&lock->excl_locked);
214	} else {
215	lock->wait_states &= ~READ_LOCK;
216	afs_osi_Wakeup(&lock->readers_reading);
217	}
218	}
219
220	/*
221	Wait for some change in the lock status.
222	void Lock_Wait(struct afs_lock *lock)
223	{
224	AFS_STATCNT(Lock_Wait);
225	if (lock->readers_reading \|\| lock->excl_locked) return 1;
226	lock->wait_states \|= READ_LOCK;
227	afs_osi_Sleep(&lock->readers_reading);
228	return 0;
229	}
230	*/
231
232	/* These next guys exist to provide an interface to drop a lock atomically with
233	* blocking. They're trivial to do in a non-preemptive LWP environment.
234	*/
235
236	/* release a write lock and sleep on an address, atomically */
237	void
238	afs_osi_SleepR(char addr, struct afs_lock alock)
239	{
240	AFS_STATCNT(osi_SleepR);
241	ReleaseReadLock(alock);
242	afs_osi_Sleep(addr);
243	}
244
245	/* release a write lock and sleep on an address, atomically */
246	void
247	afs_osi_SleepW(char addr, struct afs_lock alock)
248	{
249	AFS_STATCNT(osi_SleepW);
250	ReleaseWriteLock(alock);
251	afs_osi_Sleep(addr);
252	}
253
254	/* release a write lock and sleep on an address, atomically */
255	void
256	afs_osi_SleepS(char addr, struct afs_lock alock)
257	{
258	AFS_STATCNT(osi_SleepS);
259	ReleaseSharedLock(alock);
260	afs_osi_Sleep(addr);
261	}
262
263	/* Not static - used conditionally if lock tracing is enabled */
264	int
265	Afs_Lock_Trace(int op, struct afs_lock alock, int type, char file, int line)
266	{
267	int traceok;
268	struct afs_icl_log *tlp;
269	struct afs_icl_set *tsp;
270
271	if (!afs_trclock)
272	return 1;
273	if ((alock) == &afs_icl_lock)
274	return 1;
275
276	ObtainReadLock(&afs_icl_lock);
277	traceok = 1;
278	for (tlp = afs_icl_allLogs; tlp; tlp = tlp->nextp)
279	if ((alock) == &tlp->lock)
280	traceok = 0;
281	for (tsp = afs_icl_allSets; tsp; tsp = tsp->nextp)
282	if ((alock) == &tsp->lock)
283	traceok = 0;
284	ReleaseReadLock(&afs_icl_lock);
285	if (!traceok)
286	return 1;
287
288	afs_Trace4(afs_iclSetp, op, ICL_TYPE_STRING, (long)file, ICL_TYPE_INT32,
289	(long)line, ICL_TYPE_POINTER, (long)alock, ICL_TYPE_LONG,
290	(long)type);
291	return 0;
292	}