Annotation of embedaddon/ntp/lib/isc/rwlock.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2004, 2005, 2007, 2009 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 1998-2001, 2003 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: rwlock.c,v 1.44.332.2 2009/01/18 23:47:41 tbox Exp $ */
19:
20: /*! \file */
21:
22: #include <config.h>
23:
24: #include <stddef.h>
25:
26: #include <isc/atomic.h>
27: #include <isc/magic.h>
28: #include <isc/msgs.h>
29: #include <isc/platform.h>
30: #include <isc/rwlock.h>
31: #include <isc/util.h>
32:
33: #define RWLOCK_MAGIC ISC_MAGIC('R', 'W', 'L', 'k')
34: #define VALID_RWLOCK(rwl) ISC_MAGIC_VALID(rwl, RWLOCK_MAGIC)
35:
36: #ifdef ISC_PLATFORM_USETHREADS
37:
38: #ifndef RWLOCK_DEFAULT_READ_QUOTA
39: #define RWLOCK_DEFAULT_READ_QUOTA 4
40: #endif
41:
42: #ifndef RWLOCK_DEFAULT_WRITE_QUOTA
43: #define RWLOCK_DEFAULT_WRITE_QUOTA 4
44: #endif
45:
46: #ifdef ISC_RWLOCK_TRACE
47: #include <stdio.h> /* Required for fprintf/stderr. */
48: #include <isc/thread.h> /* Required for isc_thread_self(). */
49:
50: static void
51: print_lock(const char *operation, isc_rwlock_t *rwl, isc_rwlocktype_t type) {
52: fprintf(stderr,
53: isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
54: ISC_MSG_PRINTLOCK,
55: "rwlock %p thread %lu %s(%s): %s, %u active, "
56: "%u granted, %u rwaiting, %u wwaiting\n"),
57: rwl, isc_thread_self(), operation,
58: (type == isc_rwlocktype_read ?
59: isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
60: ISC_MSG_READ, "read") :
61: isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
62: ISC_MSG_WRITE, "write")),
63: (rwl->type == isc_rwlocktype_read ?
64: isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
65: ISC_MSG_READING, "reading") :
66: isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
67: ISC_MSG_WRITING, "writing")),
68: rwl->active, rwl->granted, rwl->readers_waiting,
69: rwl->writers_waiting);
70: }
71: #endif
72:
73: isc_result_t
74: isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
75: unsigned int write_quota)
76: {
77: isc_result_t result;
78:
79: REQUIRE(rwl != NULL);
80:
81: /*
82: * In case there's trouble initializing, we zero magic now. If all
83: * goes well, we'll set it to RWLOCK_MAGIC.
84: */
85: rwl->magic = 0;
86:
87: #if defined(ISC_PLATFORM_HAVEXADD) && defined(ISC_PLATFORM_HAVECMPXCHG)
88: rwl->write_requests = 0;
89: rwl->write_completions = 0;
90: rwl->cnt_and_flag = 0;
91: rwl->readers_waiting = 0;
92: rwl->write_granted = 0;
93: if (read_quota != 0) {
94: UNEXPECTED_ERROR(__FILE__, __LINE__,
95: "read quota is not supported");
96: }
97: if (write_quota == 0)
98: write_quota = RWLOCK_DEFAULT_WRITE_QUOTA;
99: rwl->write_quota = write_quota;
100: #else
101: rwl->type = isc_rwlocktype_read;
102: rwl->original = isc_rwlocktype_none;
103: rwl->active = 0;
104: rwl->granted = 0;
105: rwl->readers_waiting = 0;
106: rwl->writers_waiting = 0;
107: if (read_quota == 0)
108: read_quota = RWLOCK_DEFAULT_READ_QUOTA;
109: rwl->read_quota = read_quota;
110: if (write_quota == 0)
111: write_quota = RWLOCK_DEFAULT_WRITE_QUOTA;
112: rwl->write_quota = write_quota;
113: #endif
114:
115: result = isc_mutex_init(&rwl->lock);
116: if (result != ISC_R_SUCCESS)
117: return (result);
118:
119: result = isc_condition_init(&rwl->readable);
120: if (result != ISC_R_SUCCESS) {
121: UNEXPECTED_ERROR(__FILE__, __LINE__,
122: "isc_condition_init(readable) %s: %s",
123: isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
124: ISC_MSG_FAILED, "failed"),
125: isc_result_totext(result));
126: result = ISC_R_UNEXPECTED;
127: goto destroy_lock;
128: }
129: result = isc_condition_init(&rwl->writeable);
130: if (result != ISC_R_SUCCESS) {
131: UNEXPECTED_ERROR(__FILE__, __LINE__,
132: "isc_condition_init(writeable) %s: %s",
133: isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
134: ISC_MSG_FAILED, "failed"),
135: isc_result_totext(result));
136: result = ISC_R_UNEXPECTED;
137: goto destroy_rcond;
138: }
139:
140: rwl->magic = RWLOCK_MAGIC;
141:
142: return (ISC_R_SUCCESS);
143:
144: destroy_rcond:
145: (void)isc_condition_destroy(&rwl->readable);
146: destroy_lock:
147: DESTROYLOCK(&rwl->lock);
148:
149: return (result);
150: }
151:
152: void
153: isc_rwlock_destroy(isc_rwlock_t *rwl) {
154: REQUIRE(VALID_RWLOCK(rwl));
155:
156: #if defined(ISC_PLATFORM_HAVEXADD) && defined(ISC_PLATFORM_HAVECMPXCHG)
157: REQUIRE(rwl->write_requests == rwl->write_completions &&
158: rwl->cnt_and_flag == 0 && rwl->readers_waiting == 0);
159: #else
160: LOCK(&rwl->lock);
161: REQUIRE(rwl->active == 0 &&
162: rwl->readers_waiting == 0 &&
163: rwl->writers_waiting == 0);
164: UNLOCK(&rwl->lock);
165: #endif
166:
167: rwl->magic = 0;
168: (void)isc_condition_destroy(&rwl->readable);
169: (void)isc_condition_destroy(&rwl->writeable);
170: DESTROYLOCK(&rwl->lock);
171: }
172:
173: #if defined(ISC_PLATFORM_HAVEXADD) && defined(ISC_PLATFORM_HAVECMPXCHG)
174:
175: /*
176: * When some architecture-dependent atomic operations are available,
177: * rwlock can be more efficient than the generic algorithm defined below.
178: * The basic algorithm is described in the following URL:
179: * http://www.cs.rochester.edu/u/scott/synchronization/pseudocode/rw.html
180: *
181: * The key is to use the following integer variables modified atomically:
182: * write_requests, write_completions, and cnt_and_flag.
183: *
184: * write_requests and write_completions act as a waiting queue for writers
185: * in order to ensure the FIFO order. Both variables begin with the initial
186: * value of 0. When a new writer tries to get a write lock, it increments
187: * write_requests and gets the previous value of the variable as a "ticket".
188: * When write_completions reaches the ticket number, the new writer can start
189: * writing. When the writer completes its work, it increments
190: * write_completions so that another new writer can start working. If the
191: * write_requests is not equal to write_completions, it means a writer is now
192: * working or waiting. In this case, a new readers cannot start reading, or
193: * in other words, this algorithm basically prefers writers.
194: *
195: * cnt_and_flag is a "lock" shared by all readers and writers. This integer
196: * variable is a kind of structure with two members: writer_flag (1 bit) and
197: * reader_count (31 bits). The writer_flag shows whether a writer is working,
198: * and the reader_count shows the number of readers currently working or almost
199: * ready for working. A writer who has the current "ticket" tries to get the
200: * lock by exclusively setting the writer_flag to 1, provided that the whole
201: * 32-bit is 0 (meaning no readers or writers working). On the other hand,
202: * a new reader tries to increment the "reader_count" field provided that
203: * the writer_flag is 0 (meaning there is no writer working).
204: *
205: * If some of the above operations fail, the reader or the writer sleeps
206: * until the related condition changes. When a working reader or writer
207: * completes its work, some readers or writers are sleeping, and the condition
208: * that suspended the reader or writer has changed, it wakes up the sleeping
209: * readers or writers.
210: *
211: * As already noted, this algorithm basically prefers writers. In order to
212: * prevent readers from starving, however, the algorithm also introduces the
213: * "writer quota" (Q). When Q consecutive writers have completed their work,
214: * suspending readers, the last writer will wake up the readers, even if a new
215: * writer is waiting.
216: *
217: * Implementation specific note: due to the combination of atomic operations
218: * and a mutex lock, ordering between the atomic operation and locks can be
219: * very sensitive in some cases. In particular, it is generally very important
220: * to check the atomic variable that requires a reader or writer to sleep after
221: * locking the mutex and before actually sleeping; otherwise, it could be very
222: * likely to cause a deadlock. For example, assume "var" is a variable
223: * atomically modified, then the corresponding code would be:
224: * if (var == need_sleep) {
225: * LOCK(lock);
226: * if (var == need_sleep)
227: * WAIT(cond, lock);
228: * UNLOCK(lock);
229: * }
230: * The second check is important, since "var" is protected by the atomic
231: * operation, not by the mutex, and can be changed just before sleeping.
232: * (The first "if" could be omitted, but this is also important in order to
233: * make the code efficient by avoiding the use of the mutex unless it is
234: * really necessary.)
235: */
236:
237: #define WRITER_ACTIVE 0x1
238: #define READER_INCR 0x2
239:
240: isc_result_t
241: isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
242: isc_int32_t cntflag;
243:
244: REQUIRE(VALID_RWLOCK(rwl));
245:
246: #ifdef ISC_RWLOCK_TRACE
247: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
248: ISC_MSG_PRELOCK, "prelock"), rwl, type);
249: #endif
250:
251: if (type == isc_rwlocktype_read) {
252: if (rwl->write_requests != rwl->write_completions) {
253: /* there is a waiting or active writer */
254: LOCK(&rwl->lock);
255: if (rwl->write_requests != rwl->write_completions) {
256: rwl->readers_waiting++;
257: WAIT(&rwl->readable, &rwl->lock);
258: rwl->readers_waiting--;
259: }
260: UNLOCK(&rwl->lock);
261: }
262:
263: cntflag = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
264: while (1) {
265: if ((rwl->cnt_and_flag & WRITER_ACTIVE) == 0)
266: break;
267:
268: /* A writer is still working */
269: LOCK(&rwl->lock);
270: rwl->readers_waiting++;
271: if ((rwl->cnt_and_flag & WRITER_ACTIVE) != 0)
272: WAIT(&rwl->readable, &rwl->lock);
273: rwl->readers_waiting--;
274: UNLOCK(&rwl->lock);
275:
276: /*
277: * Typically, the reader should be able to get a lock
278: * at this stage:
279: * (1) there should have been no pending writer when
280: * the reader was trying to increment the
281: * counter; otherwise, the writer should be in
282: * the waiting queue, preventing the reader from
283: * proceeding to this point.
284: * (2) once the reader increments the counter, no
285: * more writer can get a lock.
286: * Still, it is possible another writer can work at
287: * this point, e.g. in the following scenario:
288: * A previous writer unlocks the writer lock.
289: * This reader proceeds to point (1).
290: * A new writer appears, and gets a new lock before
291: * the reader increments the counter.
292: * The reader then increments the counter.
293: * The previous writer notices there is a waiting
294: * reader who is almost ready, and wakes it up.
295: * So, the reader needs to confirm whether it can now
296: * read explicitly (thus we loop). Note that this is
297: * not an infinite process, since the reader has
298: * incremented the counter at this point.
299: */
300: }
301:
302: /*
303: * If we are temporarily preferred to writers due to the writer
304: * quota, reset the condition (race among readers doesn't
305: * matter).
306: */
307: rwl->write_granted = 0;
308: } else {
309: isc_int32_t prev_writer;
310:
311: /* enter the waiting queue, and wait for our turn */
312: prev_writer = isc_atomic_xadd(&rwl->write_requests, 1);
313: while (rwl->write_completions != prev_writer) {
314: LOCK(&rwl->lock);
315: if (rwl->write_completions != prev_writer) {
316: WAIT(&rwl->writeable, &rwl->lock);
317: UNLOCK(&rwl->lock);
318: continue;
319: }
320: UNLOCK(&rwl->lock);
321: break;
322: }
323:
324: while (1) {
325: cntflag = isc_atomic_cmpxchg(&rwl->cnt_and_flag, 0,
326: WRITER_ACTIVE);
327: if (cntflag == 0)
328: break;
329:
330: /* Another active reader or writer is working. */
331: LOCK(&rwl->lock);
332: if (rwl->cnt_and_flag != 0)
333: WAIT(&rwl->writeable, &rwl->lock);
334: UNLOCK(&rwl->lock);
335: }
336:
337: INSIST((rwl->cnt_and_flag & WRITER_ACTIVE) != 0);
338: rwl->write_granted++;
339: }
340:
341: #ifdef ISC_RWLOCK_TRACE
342: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
343: ISC_MSG_POSTLOCK, "postlock"), rwl, type);
344: #endif
345:
346: return (ISC_R_SUCCESS);
347: }
348:
349: isc_result_t
350: isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
351: isc_int32_t cntflag;
352:
353: REQUIRE(VALID_RWLOCK(rwl));
354:
355: #ifdef ISC_RWLOCK_TRACE
356: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
357: ISC_MSG_PRELOCK, "prelock"), rwl, type);
358: #endif
359:
360: if (type == isc_rwlocktype_read) {
361: /* If a writer is waiting or working, we fail. */
362: if (rwl->write_requests != rwl->write_completions)
363: return (ISC_R_LOCKBUSY);
364:
365: /* Otherwise, be ready for reading. */
366: cntflag = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
367: if ((cntflag & WRITER_ACTIVE) != 0) {
368: /*
369: * A writer is working. We lose, and cancel the read
370: * request.
371: */
372: cntflag = isc_atomic_xadd(&rwl->cnt_and_flag,
373: -READER_INCR);
374: /*
375: * If no other readers are waiting and we've suspended
376: * new writers in this short period, wake them up.
377: */
378: if (cntflag == READER_INCR &&
379: rwl->write_completions != rwl->write_requests) {
380: LOCK(&rwl->lock);
381: BROADCAST(&rwl->writeable);
382: UNLOCK(&rwl->lock);
383: }
384:
385: return (ISC_R_LOCKBUSY);
386: }
387: } else {
388: /* Try locking without entering the waiting queue. */
389: cntflag = isc_atomic_cmpxchg(&rwl->cnt_and_flag, 0,
390: WRITER_ACTIVE);
391: if (cntflag != 0)
392: return (ISC_R_LOCKBUSY);
393:
394: /*
395: * XXXJT: jump into the queue, possibly breaking the writer
396: * order.
397: */
398: (void)isc_atomic_xadd(&rwl->write_completions, -1);
399:
400: rwl->write_granted++;
401: }
402:
403: #ifdef ISC_RWLOCK_TRACE
404: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
405: ISC_MSG_POSTLOCK, "postlock"), rwl, type);
406: #endif
407:
408: return (ISC_R_SUCCESS);
409: }
410:
411: isc_result_t
412: isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
413: isc_int32_t prevcnt;
414:
415: REQUIRE(VALID_RWLOCK(rwl));
416:
417: /* Try to acquire write access. */
418: prevcnt = isc_atomic_cmpxchg(&rwl->cnt_and_flag,
419: READER_INCR, WRITER_ACTIVE);
420: /*
421: * There must have been no writer, and there must have been at least
422: * one reader.
423: */
424: INSIST((prevcnt & WRITER_ACTIVE) == 0 &&
425: (prevcnt & ~WRITER_ACTIVE) != 0);
426:
427: if (prevcnt == READER_INCR) {
428: /*
429: * We are the only reader and have been upgraded.
430: * Now jump into the head of the writer waiting queue.
431: */
432: (void)isc_atomic_xadd(&rwl->write_completions, -1);
433: } else
434: return (ISC_R_LOCKBUSY);
435:
436: return (ISC_R_SUCCESS);
437:
438: }
439:
440: void
441: isc_rwlock_downgrade(isc_rwlock_t *rwl) {
442: isc_int32_t prev_readers;
443:
444: REQUIRE(VALID_RWLOCK(rwl));
445:
446: /* Become an active reader. */
447: prev_readers = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
448: /* We must have been a writer. */
449: INSIST((prev_readers & WRITER_ACTIVE) != 0);
450:
451: /* Complete write */
452: (void)isc_atomic_xadd(&rwl->cnt_and_flag, -WRITER_ACTIVE);
453: (void)isc_atomic_xadd(&rwl->write_completions, 1);
454:
455: /* Resume other readers */
456: LOCK(&rwl->lock);
457: if (rwl->readers_waiting > 0)
458: BROADCAST(&rwl->readable);
459: UNLOCK(&rwl->lock);
460: }
461:
462: isc_result_t
463: isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
464: isc_int32_t prev_cnt;
465:
466: REQUIRE(VALID_RWLOCK(rwl));
467:
468: #ifdef ISC_RWLOCK_TRACE
469: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
470: ISC_MSG_PREUNLOCK, "preunlock"), rwl, type);
471: #endif
472:
473: if (type == isc_rwlocktype_read) {
474: prev_cnt = isc_atomic_xadd(&rwl->cnt_and_flag, -READER_INCR);
475:
476: /*
477: * If we're the last reader and any writers are waiting, wake
478: * them up. We need to wake up all of them to ensure the
479: * FIFO order.
480: */
481: if (prev_cnt == READER_INCR &&
482: rwl->write_completions != rwl->write_requests) {
483: LOCK(&rwl->lock);
484: BROADCAST(&rwl->writeable);
485: UNLOCK(&rwl->lock);
486: }
487: } else {
488: isc_boolean_t wakeup_writers = ISC_TRUE;
489:
490: /*
491: * Reset the flag, and (implicitly) tell other writers
492: * we are done.
493: */
494: (void)isc_atomic_xadd(&rwl->cnt_and_flag, -WRITER_ACTIVE);
495: (void)isc_atomic_xadd(&rwl->write_completions, 1);
496:
497: if (rwl->write_granted >= rwl->write_quota ||
498: rwl->write_requests == rwl->write_completions ||
499: (rwl->cnt_and_flag & ~WRITER_ACTIVE) != 0) {
500: /*
501: * We have passed the write quota, no writer is
502: * waiting, or some readers are almost ready, pending
503: * possible writers. Note that the last case can
504: * happen even if write_requests != write_completions
505: * (which means a new writer in the queue), so we need
506: * to catch the case explicitly.
507: */
508: LOCK(&rwl->lock);
509: if (rwl->readers_waiting > 0) {
510: wakeup_writers = ISC_FALSE;
511: BROADCAST(&rwl->readable);
512: }
513: UNLOCK(&rwl->lock);
514: }
515:
516: if (rwl->write_requests != rwl->write_completions &&
517: wakeup_writers) {
518: LOCK(&rwl->lock);
519: BROADCAST(&rwl->writeable);
520: UNLOCK(&rwl->lock);
521: }
522: }
523:
524: #ifdef ISC_RWLOCK_TRACE
525: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
526: ISC_MSG_POSTUNLOCK, "postunlock"),
527: rwl, type);
528: #endif
529:
530: return (ISC_R_SUCCESS);
531: }
532:
533: #else /* ISC_PLATFORM_HAVEXADD && ISC_PLATFORM_HAVECMPXCHG */
534:
535: static isc_result_t
536: doit(isc_rwlock_t *rwl, isc_rwlocktype_t type, isc_boolean_t nonblock) {
537: isc_boolean_t skip = ISC_FALSE;
538: isc_boolean_t done = ISC_FALSE;
539: isc_result_t result = ISC_R_SUCCESS;
540:
541: REQUIRE(VALID_RWLOCK(rwl));
542:
543: LOCK(&rwl->lock);
544:
545: #ifdef ISC_RWLOCK_TRACE
546: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
547: ISC_MSG_PRELOCK, "prelock"), rwl, type);
548: #endif
549:
550: if (type == isc_rwlocktype_read) {
551: if (rwl->readers_waiting != 0)
552: skip = ISC_TRUE;
553: while (!done) {
554: if (!skip &&
555: ((rwl->active == 0 ||
556: (rwl->type == isc_rwlocktype_read &&
557: (rwl->writers_waiting == 0 ||
558: rwl->granted < rwl->read_quota)))))
559: {
560: rwl->type = isc_rwlocktype_read;
561: rwl->active++;
562: rwl->granted++;
563: done = ISC_TRUE;
564: } else if (nonblock) {
565: result = ISC_R_LOCKBUSY;
566: done = ISC_TRUE;
567: } else {
568: skip = ISC_FALSE;
569: rwl->readers_waiting++;
570: WAIT(&rwl->readable, &rwl->lock);
571: rwl->readers_waiting--;
572: }
573: }
574: } else {
575: if (rwl->writers_waiting != 0)
576: skip = ISC_TRUE;
577: while (!done) {
578: if (!skip && rwl->active == 0) {
579: rwl->type = isc_rwlocktype_write;
580: rwl->active = 1;
581: rwl->granted++;
582: done = ISC_TRUE;
583: } else if (nonblock) {
584: result = ISC_R_LOCKBUSY;
585: done = ISC_TRUE;
586: } else {
587: skip = ISC_FALSE;
588: rwl->writers_waiting++;
589: WAIT(&rwl->writeable, &rwl->lock);
590: rwl->writers_waiting--;
591: }
592: }
593: }
594:
595: #ifdef ISC_RWLOCK_TRACE
596: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
597: ISC_MSG_POSTLOCK, "postlock"), rwl, type);
598: #endif
599:
600: UNLOCK(&rwl->lock);
601:
602: return (result);
603: }
604:
605: isc_result_t
606: isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
607: return (doit(rwl, type, ISC_FALSE));
608: }
609:
610: isc_result_t
611: isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
612: return (doit(rwl, type, ISC_TRUE));
613: }
614:
615: isc_result_t
616: isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
617: isc_result_t result = ISC_R_SUCCESS;
618:
619: REQUIRE(VALID_RWLOCK(rwl));
620: LOCK(&rwl->lock);
621: REQUIRE(rwl->type == isc_rwlocktype_read);
622: REQUIRE(rwl->active != 0);
623:
624: /* If we are the only reader then succeed. */
625: if (rwl->active == 1) {
626: rwl->original = (rwl->original == isc_rwlocktype_none) ?
627: isc_rwlocktype_read : isc_rwlocktype_none;
628: rwl->type = isc_rwlocktype_write;
629: } else
630: result = ISC_R_LOCKBUSY;
631:
632: UNLOCK(&rwl->lock);
633: return (result);
634: }
635:
636: void
637: isc_rwlock_downgrade(isc_rwlock_t *rwl) {
638:
639: REQUIRE(VALID_RWLOCK(rwl));
640: LOCK(&rwl->lock);
641: REQUIRE(rwl->type == isc_rwlocktype_write);
642: REQUIRE(rwl->active == 1);
643:
644: rwl->type = isc_rwlocktype_read;
645: rwl->original = (rwl->original == isc_rwlocktype_none) ?
646: isc_rwlocktype_write : isc_rwlocktype_none;
647: /*
648: * Resume processing any read request that were blocked when
649: * we upgraded.
650: */
651: if (rwl->original == isc_rwlocktype_none &&
652: (rwl->writers_waiting == 0 || rwl->granted < rwl->read_quota) &&
653: rwl->readers_waiting > 0)
654: BROADCAST(&rwl->readable);
655:
656: UNLOCK(&rwl->lock);
657: }
658:
659: isc_result_t
660: isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
661:
662: REQUIRE(VALID_RWLOCK(rwl));
663: LOCK(&rwl->lock);
664: REQUIRE(rwl->type == type);
665:
666: UNUSED(type);
667:
668: #ifdef ISC_RWLOCK_TRACE
669: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
670: ISC_MSG_PREUNLOCK, "preunlock"), rwl, type);
671: #endif
672:
673: INSIST(rwl->active > 0);
674: rwl->active--;
675: if (rwl->active == 0) {
676: if (rwl->original != isc_rwlocktype_none) {
677: rwl->type = rwl->original;
678: rwl->original = isc_rwlocktype_none;
679: }
680: if (rwl->type == isc_rwlocktype_read) {
681: rwl->granted = 0;
682: if (rwl->writers_waiting > 0) {
683: rwl->type = isc_rwlocktype_write;
684: SIGNAL(&rwl->writeable);
685: } else if (rwl->readers_waiting > 0) {
686: /* Does this case ever happen? */
687: BROADCAST(&rwl->readable);
688: }
689: } else {
690: if (rwl->readers_waiting > 0) {
691: if (rwl->writers_waiting > 0 &&
692: rwl->granted < rwl->write_quota) {
693: SIGNAL(&rwl->writeable);
694: } else {
695: rwl->granted = 0;
696: rwl->type = isc_rwlocktype_read;
697: BROADCAST(&rwl->readable);
698: }
699: } else if (rwl->writers_waiting > 0) {
700: rwl->granted = 0;
701: SIGNAL(&rwl->writeable);
702: } else {
703: rwl->granted = 0;
704: }
705: }
706: }
707: INSIST(rwl->original == isc_rwlocktype_none);
708:
709: #ifdef ISC_RWLOCK_TRACE
710: print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
711: ISC_MSG_POSTUNLOCK, "postunlock"),
712: rwl, type);
713: #endif
714:
715: UNLOCK(&rwl->lock);
716:
717: return (ISC_R_SUCCESS);
718: }
719:
720: #endif /* ISC_PLATFORM_HAVEXADD && ISC_PLATFORM_HAVECMPXCHG */
721: #else /* ISC_PLATFORM_USETHREADS */
722:
723: isc_result_t
724: isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
725: unsigned int write_quota)
726: {
727: REQUIRE(rwl != NULL);
728:
729: UNUSED(read_quota);
730: UNUSED(write_quota);
731:
732: rwl->type = isc_rwlocktype_read;
733: rwl->active = 0;
734: rwl->magic = RWLOCK_MAGIC;
735:
736: return (ISC_R_SUCCESS);
737: }
738:
739: isc_result_t
740: isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
741: REQUIRE(VALID_RWLOCK(rwl));
742:
743: if (type == isc_rwlocktype_read) {
744: if (rwl->type != isc_rwlocktype_read && rwl->active != 0)
745: return (ISC_R_LOCKBUSY);
746: rwl->type = isc_rwlocktype_read;
747: rwl->active++;
748: } else {
749: if (rwl->active != 0)
750: return (ISC_R_LOCKBUSY);
751: rwl->type = isc_rwlocktype_write;
752: rwl->active = 1;
753: }
754: return (ISC_R_SUCCESS);
755: }
756:
757: isc_result_t
758: isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
759: return (isc_rwlock_lock(rwl, type));
760: }
761:
762: isc_result_t
763: isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
764: isc_result_t result = ISC_R_SUCCESS;
765:
766: REQUIRE(VALID_RWLOCK(rwl));
767: REQUIRE(rwl->type == isc_rwlocktype_read);
768: REQUIRE(rwl->active != 0);
769:
770: /* If we are the only reader then succeed. */
771: if (rwl->active == 1)
772: rwl->type = isc_rwlocktype_write;
773: else
774: result = ISC_R_LOCKBUSY;
775: return (result);
776: }
777:
778: void
779: isc_rwlock_downgrade(isc_rwlock_t *rwl) {
780:
781: REQUIRE(VALID_RWLOCK(rwl));
782: REQUIRE(rwl->type == isc_rwlocktype_write);
783: REQUIRE(rwl->active == 1);
784:
785: rwl->type = isc_rwlocktype_read;
786: }
787:
788: isc_result_t
789: isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
790: REQUIRE(VALID_RWLOCK(rwl));
791: REQUIRE(rwl->type == type);
792:
793: UNUSED(type);
794:
795: INSIST(rwl->active > 0);
796: rwl->active--;
797:
798: return (ISC_R_SUCCESS);
799: }
800:
801: void
802: isc_rwlock_destroy(isc_rwlock_t *rwl) {
803: REQUIRE(rwl != NULL);
804: REQUIRE(rwl->active == 0);
805: rwl->magic = 0;
806: }
807:
808: #endif /* ISC_PLATFORM_USETHREADS */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rwlock.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc