|RWLOCK(9F)||Kernel Functions for Drivers||RWLOCK(9F)|
#include <sys/ksynch.h> void rw_init(krwlock_t *rwlp, char *name, krw_type_t type, void *arg);
void rw_destroy(krwlock_t *rwlp);
void rw_enter(krwlock_t *rwlp, krw_t enter_type);
void rw_exit(krwlock_t *rwlp);
int rw_tryenter(krwlock_t *rwlp, krw_t enter_type);
void rw_downgrade(krwlock_t *rwlp);
int rw_tryupgrade(krwlock_t *rwlp);
int rw_read_locked(krwlock_t *rwlp);
Readers/writer locks are slightly more expensive than mutex locks, and the advantage of multiple read access may not occur if the lock will only be held for a short time.
The rw_init() function initializes a readers/writer lock. It is an error to initialize a lock more than once. The type argument should be set to RW_DRIVER. If the lock is used by the interrupt handler, the type-specific argument, arg, should be the interrupt priority returned from ddi_intr_get_pri(9F) or ddi_intr_get_softint_pri(9F). Note that arg should be the value of the interrupt priority cast by calling the DDI_INTR_PRI macro. If the lock is not used by any interrupt handler, the argument should be NULL.
The rw_destroy() function releases any resources that might have been allocated by rw_init(). It should be called before freeing the memory containing the lock. The lock must not be held by any thread when it is destroyed.
The rw_enter() function acquires the lock, and blocks if necessary. If enter_type is RW_WRITER, the caller blocks if any thread holds the lock. If enter_type is RW_READER, the caller blocks if there is a writer or a thread attempting to enter for writing. If enter_type is RW_READER_STARVEWRITER, the caller blocks only if there is a writer; if the lock is held for reading and a thread is blocked attempting to enter for writing, the caller will acquire the lock as a reader instead of blocking on the pending writer.
NOTE: It is a programming error for any thread to acquire an rwlock as RW_READER that it already holds. Doing so can deadlock the system: if thread R acquires the lock as RW_READER, then thread W tries to acquire the lock as a writer, W will set write-wanted and block. When R tries to get its second read hold on the lock, it will honor the write-wanted bit and block waiting for W; but W cannot run until R drops the lock. Thus threads R and W deadlock. To opt out of this behavior -- that is, to safely allow a lock to be grabbed recursively as a reader -- the lock should be acquired as RW_READER_STARVEWRITER, which will allow R to get its second read hold without regard for the write-wanted bit set by W. Note that the RW_READER_STARVEWRITER behavior will starve writers in the presence of infinite readers; it should be used with care, and only where the default RW_READER behavior is unacceptable.
The rw_exit() function releases the lock and may wake up one or more threads waiting on the lock.
The rw_tryenter() function attempts to enter the lock, like rw_enter(), but never blocks. It returns a non-zero value if the lock was successfully entered, and zero otherwise.
A thread that holds the lock exclusively (entered with RW_WRITER), may call rw_downgrade() to convert to holding the lock non-exclusively (as if entered with RW_READER). One or more waiting readers may be unblocked.
The rw_tryupgrade() function can be called by a thread that holds the lock for reading to attempt to convert to holding it for writing. This upgrade can only succeed if no other thread is holding the lock and no other thread is blocked waiting to acquire the lock for writing.
The rw_read_locked() function returns non-zero if the calling thread holds the lock for read, and zero if the caller holds the lock for write. The caller must hold the lock. The system may panic if rw_read_locked() is called for a lock that isn't held by the caller.
Writing Device Drivers
|September 19, 2013||OmniOS|