2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A
2N/A/*
2N/A * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A#include <stdio.h>
2N/A#include <rpc/types.h>
2N/A#include <rpc/xdr.h>
2N/A#include "db_dictionary_c.h"
2N/A#include "nisdb_rw.h"
2N/A#include "nisdb_ldap.h"
2N/A
2N/A/*
2N/A * Nesting-safe RW locking functions. Return 0 when successful, an
2N/A * error number from the E-series when not.
2N/A */
2N/A
2N/Aint
2N/A__nisdb_rwinit(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if ((ret = mutex_init(&rw->mutex, USYNC_THREAD, 0)) != 0)
2N/A return (ret);
2N/A if ((ret = cond_init(&rw->cv, USYNC_THREAD, 0)) != 0)
2N/A return (ret);
2N/A rw->destroyed = 0;
2N/A
2N/A /*
2N/A * If we allow read-to-write lock migration, there's a potential
2N/A * race condition if two or more threads want to upgrade at the
2N/A * same time. The simple and safe (but crude and possibly costly)
2N/A * method to fix this is to always use exclusive locks, and so
2N/A * that has to be the default.
2N/A *
2N/A * There are two conditions under which it is safe to set
2N/A * 'force_write' to zero for a certain lock structure:
2N/A *
2N/A * (1) The lock will never be subject to migration, or
2N/A *
2N/A * (2) It's OK if the data protected by the lock has changed
2N/A * (a) Every time the lock (read or write) has been
2N/A * acquired (even if the lock already was held by
2N/A * the thread), and
2N/A * (b) After every call to a function that might have
2N/A * acquired the lock.
2N/A */
2N/A rw->force_write = NISDB_FORCE_WRITE;
2N/A
2N/A rw->writer_count = rw->reader_count = rw->reader_blocked = 0;
2N/A rw->writer.id = rw->reader.id = INV_PTHREAD_ID;
2N/A rw->writer.count = rw->reader.count = 0;
2N/A rw->writer.next = rw->reader.next = 0;
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A
2N/Astatic __nisdb_rl_t *
2N/Afind_reader(pthread_t id, __nisdb_rwlock_t *rw) {
2N/A
2N/A __nisdb_rl_t *rr;
2N/A
2N/A for (rr = &rw->reader; rr != 0; rr = rr->next) {
2N/A if (rr->id == INV_PTHREAD_ID) {
2N/A rr = 0;
2N/A break;
2N/A }
2N/A if (rr->id == id)
2N/A break;
2N/A }
2N/A
2N/A return (rr);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_rw_readlock_ok(__nisdb_rwlock_t *rw) {
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr;
2N/A
2N/A if (rw == 0)
2N/A return (EFAULT);
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A /*
2N/A * Only allow changing 'force_write' when it's really safe; i.e.,
2N/A * the lock hasn't been destroyed, and there are no readers.
2N/A */
2N/A if (rw->destroyed == 0 && rw->reader_count == 0) {
2N/A rw->force_write = 0;
2N/A ret = 0;
2N/A } else {
2N/A ret = EBUSY;
2N/A }
2N/A
2N/A (void) mutex_unlock(&rw->mutex);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_rw_force_writelock(__nisdb_rwlock_t *rw) {
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr;
2N/A
2N/A if (rw == 0 || rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A /*
2N/A * Only allow changing 'force_write' when it's really safe; i.e.,
2N/A * the lock hasn't been destroyed, and there are no readers.
2N/A */
2N/A if (rw->destroyed == 0 && rw->reader_count == 0) {
2N/A rw->force_write = 1;
2N/A ret = 0;
2N/A } else {
2N/A ret = EBUSY;
2N/A }
2N/A
2N/A (void) mutex_unlock(&rw->mutex);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_wlock_trylock(__nisdb_rwlock_t *rw, int trylock) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A int all_readers_blocked = 0;
2N/A __nisdb_rl_t *rr = 0;
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A /* This shouldn't happen */
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A /* Simplest (and probably most common) case: no readers or writers */
2N/A if (rw->reader_count == 0 && rw->writer_count == 0) {
2N/A rw->writer_count = 1;
2N/A rw->writer.id = myself;
2N/A rw->writer.count = 1;
2N/A return (mutex_unlock(&rw->mutex));
2N/A }
2N/A
2N/A /*
2N/A * Need to know if we're holding a read lock already, and if
2N/A * all other readers are blocked waiting for the mutex.
2N/A */
2N/A if (rw->reader_count > 0) {
2N/A if ((rr = find_reader(myself, rw)) != 0) {
2N/A if (rr->count)
2N/A /*
2N/A * We're already holding a read lock, so
2N/A * if the number of readers equals the number
2N/A * of blocked readers plus one, all other
2N/A * readers are blocked.
2N/A */
2N/A if (rw->reader_count ==
2N/A (rw->reader_blocked + 1))
2N/A all_readers_blocked = 1;
2N/A else
2N/A /*
2N/A * We're not holding a read lock, so the
2N/A * number of readers should equal the number
2N/A * of blocked readers if all readers are
2N/A * blocked.
2N/A */
2N/A if (rw->reader_count == rw->reader_blocked)
2N/A all_readers_blocked = 1;
2N/A }
2N/A }
2N/A
2N/A /* Wait for reader(s) or writer to finish */
2N/A while (1) {
2N/A /*
2N/A * We can stop looping if one of the following holds:
2N/A * - No readers, no writers
2N/A * - No writers (or writer is myself), and one of:
2N/A * - No readers
2N/A * - One reader, and it's us
2N/A * - N readers, but all blocked on the mutex
2N/A */
2N/A if (
2N/A (rw->writer_count == 0 && rw->reader_count == 0) ||
2N/A ((rw->writer_count == 0 || rw->writer.id == myself) &&
2N/A (rw->reader_count == 0) ||
2N/A (rw->reader_count == 1 &&
2N/A rw->reader.id == myself))) {
2N/A break;
2N/A }
2N/A /*
2N/A * Provided that all readers are blocked on the mutex
2N/A * we break a potential dead-lock by acquiring the
2N/A * write lock.
2N/A */
2N/A if (all_readers_blocked) {
2N/A if (rw->writer_count == 0 || rw->writer.id == myself) {
2N/A break;
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * If 'trylock' is set, tell the caller that we'd have to
2N/A * block to obtain the lock.
2N/A */
2N/A if (trylock) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (EBUSY);
2N/A }
2N/A
2N/A /* If we're also a reader, indicate that we're blocking */
2N/A if (rr != 0) {
2N/A rr->wait = 1;
2N/A rw->reader_blocked++;
2N/A }
2N/A if ((ret = cond_wait(&rw->cv, &rw->mutex)) != 0) {
2N/A if (rr != 0) {
2N/A rr->wait = 0;
2N/A if (rw->reader_blocked > 0)
2N/A rw->reader_blocked--;
2N/A#ifdef NISDB_MT_DEBUG
2N/A else
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A }
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ret);
2N/A }
2N/A if (rr != 0) {
2N/A rr->wait = 0;
2N/A if (rw->reader_blocked > 0)
2N/A rw->reader_blocked--;
2N/A#ifdef NISDB_MT_DEBUG
2N/A else
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A }
2N/A }
2N/A
2N/A /* OK to grab the write lock */
2N/A rw->writer.id = myself;
2N/A /* Increment lock depth */
2N/A rw->writer.count++;
2N/A /* Set number of writers (doesn't increase with lock depth) */
2N/A if (rw->writer_count == 0)
2N/A rw->writer_count = 1;
2N/A
2N/A return (mutex_unlock(&rw->mutex));
2N/A}
2N/A
2N/Aint
2N/A__nisdb_wlock(__nisdb_rwlock_t *rw) {
2N/A return (__nisdb_wlock_trylock(rw, 0));
2N/A}
2N/A
2N/A
2N/Astatic __nisdb_rl_t *
2N/Aincrement_reader(pthread_t id, __nisdb_rwlock_t *rw) {
2N/A
2N/A __nisdb_rl_t *rr;
2N/A
2N/A for (rr = &rw->reader; rr != 0; rr = rr->next) {
2N/A if (rr->id == id || rr->id == INV_PTHREAD_ID)
2N/A break;
2N/A }
2N/A if (rw->reader_count == 0 && rr == &rw->reader) {
2N/A /* No previous reader */
2N/A rr->id = id;
2N/A rw->reader_count = 1;
2N/A } else if (rr == 0) {
2N/A if ((rr = malloc(sizeof (__nisdb_rl_t))) == 0)
2N/A return (0);
2N/A rr->id = id;
2N/A rr->count = 0;
2N/A /*
2N/A * For insertion simplicity, make it the second item
2N/A * on the list.
2N/A */
2N/A rr->next = rw->reader.next;
2N/A rw->reader.next = rr;
2N/A rw->reader_count++;
2N/A }
2N/A rr->count++;
2N/A
2N/A return (rr);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_rlock(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr;
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A /* This shouldn't happen */
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if (rw->force_write)
2N/A return (__nisdb_wlock(rw));
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A rr = find_reader(myself, rw);
2N/A
2N/A /* Wait for writer to complete; writer == myself also OK */
2N/A while (rw->writer_count > 0 && rw->writer.id != myself) {
2N/A if (rr != 0) {
2N/A rr->wait = 1;
2N/A rw->reader_blocked++;
2N/A }
2N/A if ((ret = cond_wait(&rw->cv, &rw->mutex)) != 0) {
2N/A if (rr != 0) {
2N/A rr->wait = 0;
2N/A if (rw->reader_blocked > 0)
2N/A rw->reader_blocked--;
2N/A#ifdef NISDB_MT_DEBUG
2N/A else
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A }
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ret);
2N/A }
2N/A if (rr != 0) {
2N/A rr->wait = 0;
2N/A if (rw->reader_blocked > 0)
2N/A rw->reader_blocked--;
2N/A#ifdef NISDB_MT_DEBUG
2N/A else
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A }
2N/A }
2N/A
2N/A rr = increment_reader(myself, rw);
2N/A ret = mutex_unlock(&rw->mutex);
2N/A return ((rr == 0) ? ENOMEM : ret);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_wulock(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A /* This shouldn't happen */
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A /* Sanity check */
2N/A if (rw->writer_count == 0 ||
2N/A rw->writer.id != myself || rw->writer.count == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ENOLCK);
2N/A }
2N/A
2N/A rw->writer.count--;
2N/A if (rw->writer.count == 0) {
2N/A rw->writer.id = INV_PTHREAD_ID;
2N/A rw->writer_count = 0;
2N/A if ((ret = cond_broadcast(&rw->cv)) != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ret);
2N/A }
2N/A }
2N/A
2N/A return (mutex_unlock(&rw->mutex));
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_rulock(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr, *prev;
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if (rw->force_write)
2N/A return (__nisdb_wulock(rw));
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A /* Sanity check */
2N/A if (rw->reader_count == 0 ||
2N/A (rw->writer_count > 0 && rw->writer.id != myself)) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ENOLCK);
2N/A }
2N/A
2N/A /* Find the reader record */
2N/A for (rr = &rw->reader, prev = 0; rr != 0; prev = rr, rr = rr->next) {
2N/A if (rr->id == myself)
2N/A break;
2N/A }
2N/A
2N/A if (rr == 0 || rr->count == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ENOLCK);
2N/A }
2N/A
2N/A rr->count--;
2N/A if (rr->count == 0) {
2N/A if (rr != &rw->reader) {
2N/A /* Remove item from list and free it */
2N/A prev->next = rr->next;
2N/A free(rr);
2N/A } else {
2N/A /*
2N/A * First record: copy second to first, and free second
2N/A * record.
2N/A */
2N/A if (rr->next != 0) {
2N/A rr = rr->next;
2N/A rw->reader.id = rr->id;
2N/A rw->reader.count = rr->count;
2N/A rw->reader.next = rr->next;
2N/A free(rr);
2N/A } else {
2N/A /* Decomission the first record */
2N/A rr->id = INV_PTHREAD_ID;
2N/A }
2N/A }
2N/A rw->reader_count--;
2N/A }
2N/A
2N/A /* If there are no readers, wake up any waiting writer */
2N/A if (rw->reader_count == 0) {
2N/A if ((ret = cond_broadcast(&rw->cv)) != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ret);
2N/A }
2N/A }
2N/A
2N/A return (mutex_unlock(&rw->mutex));
2N/A}
2N/A
2N/A
2N/A/* Return zero if write lock held by this thread, non-zero otherwise */
2N/Aint
2N/A__nisdb_assert_wheld(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A if (rw->writer_count == 0 || rw->writer.id != pthread_self()) {
2N/A ret = mutex_unlock(&rw->mutex);
2N/A return ((ret == 0) ? -1 : ret);
2N/A }
2N/A
2N/A /*
2N/A * We're holding the lock, so we should return zero. Since
2N/A * that's what mutex_unlock() does if it succeeds, we just
2N/A * return the value of mutex_unlock().
2N/A */
2N/A return (mutex_unlock(&rw->mutex));
2N/A}
2N/A
2N/A
2N/A/* Return zero if read lock held by this thread, non-zero otherwise */
2N/Aint
2N/A__nisdb_assert_rheld(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr;
2N/A
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if (rw->force_write)
2N/A return (__nisdb_assert_wheld(rw));
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A /* Write lock also OK */
2N/A if (rw->writer_count > 0 && rw->writer.id == myself) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (0);
2N/A }
2N/A
2N/A if (rw->reader_count == 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (EBUSY);
2N/A }
2N/A
2N/A rr = &rw->reader;
2N/A do {
2N/A if (rr->id == myself) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (0);
2N/A }
2N/A rr = rr->next;
2N/A } while (rr != 0);
2N/A
2N/A ret = mutex_unlock(&rw->mutex);
2N/A return ((ret == 0) ? EBUSY : ret);
2N/A}
2N/A
2N/A
2N/Aint
2N/A__nisdb_destroy_lock(__nisdb_rwlock_t *rw) {
2N/A
2N/A int ret;
2N/A pthread_t myself = pthread_self();
2N/A __nisdb_rl_t *rr;
2N/A
2N/A
2N/A if (rw == 0) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A return (EFAULT);
2N/A }
2N/A
2N/A if (rw->destroyed != 0)
2N/A return (ESHUTDOWN);
2N/A
2N/A if ((ret = mutex_lock(&rw->mutex)) != 0)
2N/A return (ret);
2N/A
2N/A if (rw->destroyed != 0) {
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ESHUTDOWN);
2N/A }
2N/A
2N/A /*
2N/A * Only proceed if if there are neither readers nor writers
2N/A * other than this thread. Also, no nested locks may be in
2N/A * effect.
2N/A */
2N/A if ((rw->writer_count > 0 &&
2N/A (rw->writer.id != myself || rw->writer.count != 1) ||
2N/A (rw->reader_count > 0 &&
2N/A !(rw->reader_count == 1 && rw->reader.id == myself &&
2N/A rw->reader.count == 1))) ||
2N/A (rw->writer_count > 0 && rw->reader_count > 0)) {
2N/A#ifdef NISDB_MT_DEBUG
2N/A abort();
2N/A#endif /* NISDB_MT_DEBUG */
2N/A (void) mutex_unlock(&rw->mutex);
2N/A return (ENOLCK);
2N/A }
2N/A
2N/A /*
2N/A * Mark lock destroyed, so that any thread waiting on the mutex
2N/A * will know what's what. Of course, this is a bit iffy, since
2N/A * we're probably being called from a destructor, and the structure
2N/A * where we live will soon cease to exist (i.e., be freed and
2N/A * perhaps re-used). Still, we can only do our best, and give
2N/A * those other threads the best chance possible.
2N/A */
2N/A rw->destroyed++;
2N/A
2N/A return (mutex_unlock(&rw->mutex));
2N/A}
2N/A
2N/Avoid
2N/A__nisdb_lock_report(__nisdb_rwlock_t *rw) {
2N/A const char *myself = "__nisdb_lock_report";
2N/A
2N/A if (rw == 0) {
2N/A printf("%s: NULL argument\n", myself);
2N/A return;
2N/A }
2N/A
2N/A if (rw->destroyed)
2N/A printf("0x%x: DESTROYED\n", rw);
2N/A
2N/A printf("0x%x: Read locking %s\n",
2N/A rw, rw->force_write ? "disallowed" : "allowed");
2N/A
2N/A if (rw->writer_count == 0)
2N/A printf("0x%x: No writer\n", rw);
2N/A else if (rw->writer_count == 1) {
2N/A printf("0x%x: Write locked by %d, depth = %d\n",
2N/A rw, rw->writer.id, rw->writer.count);
2N/A if (rw->writer.wait)
2N/A printf("0x%x:\tWriter blocked\n", rw);
2N/A } else
2N/A printf("0x%x: Invalid writer count = %d\n",
2N/A rw, rw->writer_count);
2N/A
2N/A if (rw->reader_count == 0)
2N/A printf("0x%x: No readers\n", rw);
2N/A else {
2N/A __nisdb_rl_t *r;
2N/A
2N/A printf("0x%x: %d readers, %d blocked\n",
2N/A rw, rw->reader_count, rw->reader_blocked);
2N/A for (r = &rw->reader; r != 0; r = r->next) {
2N/A printf("0x%x:\tthread %d, depth = %d%s\n",
2N/A rw, r->id, r->count,
2N/A (r->wait ? " (blocked)" : ""));
2N/A }
2N/A }
2N/A}