Return to rwlock.h CVS log

Up to [local] / sys / sys

Annotation of sys/sys/rwlock.h, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: rwlock.h,v 1.11 2007/05/29 00:17:32 thib Exp $        */
                      2: /*
                      3:  * Copyright (c) 2002 Artur Grabowski <art@openbsd.org>
                      4:  * All rights reserved.
                      5:  *
                      6:  * Redistribution and use in source and binary forms, with or without
                      7:  * modification, are permitted provided that the following conditions
                      8:  * are met:
                      9:  *
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. The name of the author may not be used to endorse or promote products
                     13:  *    derived from this software without specific prior written permission.
                     14:  *
                     15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
                     16:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
                     17:  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
                     18:  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
                     19:  * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
                     20:  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
                     21:  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
                     22:  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
                     23:  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
                     24:  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                     25:  */
                     26:
                     27: /*
                     28:  * Multiple readers, single writer lock.
                     29:  *
                     30:  * Simplistic implementation modelled after rw locks in Solaris.
                     31:  *
                     32:  * The rwl_owner has the following layout:
                     33:  * [ owner or count of readers | wrlock | wrwant | wait ]
                     34:  *
                     35:  * When the WAIT bit is set (bit 0), the lock has waiters sleeping on it.
                     36:  * When the WRWANT bit is set (bit 1), at least one waiter wants a write lock.
                     37:  * When the WRLOCK bit is set (bit 2) the lock is currently write-locked.
                     38:  *
                     39:  * When write locked, the upper bits contain the struct proc * pointer to
                     40:  * the writer, otherwise they count the number of readers.
                     41:  *
                     42:  * We provide a simple machine independent implementation that can be
                     43:  * optimized by machine dependent code when __HAVE_MD_RWLOCK is defined.
                     44:  *
                     45:  * MD code that defines __HAVE_MD_RWLOCK and implement four functions:
                     46:  *
                     47:  * void rw_enter_read(struct rwlock *)
                     48:  *  atomically test for RWLOCK_WRLOCK and if not set, increment the lock
                     49:  *  by RWLOCK_READ_INCR. While RWLOCK_WRLOCK is set, loop into rw_enter_wait.
                     50:  *
                     51:  * void rw_enter_write(struct rwlock *);
                     52:  *  atomically test for the lock being 0 (it's not possible to have
                     53:  *  owner/read count unset and waiter bits set) and if 0 set the owner to
                     54:  *  the proc and RWLOCK_WRLOCK. While not zero, loop into rw_enter_wait.
                     55:  *
                     56:  * void rw_exit_read(struct rwlock *);
                     57:  *  atomically decrement lock by RWLOCK_READ_INCR and unset RWLOCK_WAIT and
                     58:  *  RWLOCK_WRWANT remembering the old value of lock and if RWLOCK_WAIT was set,
                     59:  *  call rw_exit_waiters with the old contents of the lock.
                     60:  *
                     61:  * void rw_exit_write(struct rwlock *);
                     62:  *  atomically swap the contents of the lock with 0 and if RWLOCK_WAIT was
                     63:  *  set, call rw_exit_waiters with the old contents of the lock.
                     64:  *
                     65:  * (XXX - the rest of the API for this is not invented yet).
                     66:  */
                     67:
                     68: #ifndef SYS_RWLOCK_H
                     69: #define SYS_RWLOCK_H
                     70:
                     71:
                     72: struct proc;
                     73:
                     74: struct rwlock {
                     75:        __volatile unsigned long rwl_owner;
                     76:        const char *rwl_name;
                     77: };
                     78:
                     79: #define RWLOCK_INITIALIZER(name)       { 0, name }
                     80:
                     81: #define RWLOCK_WAIT            0x01UL
                     82: #define RWLOCK_WRWANT          0x02UL
                     83: #define RWLOCK_WRLOCK          0x04UL
                     84: #define RWLOCK_MASK            0x07UL
                     85:
                     86: #define RWLOCK_OWNER(rwl)      ((struct proc *)((rwl)->rwl_owner & ~RWLOCK_MASK))
                     87:
                     88: #define RWLOCK_READER_SHIFT    3UL
                     89: #define RWLOCK_READ_INCR       (1UL << RWLOCK_READER_SHIFT)
                     90:
                     91: void rw_init(struct rwlock *, const char *);
                     92:
                     93: void rw_enter_read(struct rwlock *);
                     94: void rw_enter_write(struct rwlock *);
                     95: void rw_exit_read(struct rwlock *);
                     96: void rw_exit_write(struct rwlock *);
                     97:
                     98: int rw_enter(struct rwlock *, int);
                     99: void rw_exit(struct rwlock *);
                    100: #define RW_WRITE       0x00UL          /* exclusive lock */
                    101: #define RW_READ                0x01UL          /* shared lock */
                    102: #define RW_DOWNGRADE   0x02UL          /* downgrade exclusive to shared */
                    103: #define RW_OPMASK      0x03UL
                    104:
                    105: #define RW_INTR                0x10UL          /* interruptible sleep */
                    106: #define RW_SLEEPFAIL   0x20UL          /* fail if we slept for the lock */
                    107: #define RW_NOSLEEP     0x40UL          /* don't wait for the lock */
                    108:
                    109: #ifndef rw_cas
                    110: int rw_cas(volatile unsigned long *, unsigned long, unsigned long);
                    111: #endif
                    112:
                    113: #endif