Hi,
After this commit, the kernel stalls just before root file system
will be found on my NetBSD/amd64 laptop.
Reverting
src/sys/kern/kern_rwlock.c to r1.60
and
src/sys/sys/rwlock.h to r1.12
in latest -current tree and I can get the kernel that works like
before.
And on another laptop, the problematic kernel stalls before root file
system detection like my laptop.
It may be universal problem.
Could you take a look at this problem?
Thank you.
"Andrew Doran" <a...@netbsd.org> writes:
> Module Name: src
> Committed By: ad
> Date: Sun Jan 19 18:34:24 UTC 2020
>
> Modified Files:
> src/sys/kern: kern_rwlock.c
> src/sys/sys: rwlock.h
>
> Log Message:
> Tidy rwlocks a bit, no functional change intended. Mainly:
>
> - rw_downgrade(): do it in a for () loop like all the others.
> - Explicitly carry around RW_NODEBUG - don't be lazy.
> - Remove pointless macros.
> - Don't make assertions conditional on LOCKDEBUG, there's no reason.
> - Make space for a new flag bit (not added yet).
>
>
> To generate a diff of this commit:
> cvs rdiff -u -r1.60 -r1.61 src/sys/kern/kern_rwlock.c
> cvs rdiff -u -r1.12 -r1.13 src/sys/sys/rwlock.h
>
> Please note that diffs are not public domain; they are subject to the
> copyright notices on the relevant files.
>
> Modified files:
>
> Index: src/sys/kern/kern_rwlock.c
> diff -u src/sys/kern/kern_rwlock.c:1.60 src/sys/kern/kern_rwlock.c:1.61
> --- src/sys/kern/kern_rwlock.c:1.60 Sun Jan 12 18:37:10 2020
> +++ src/sys/kern/kern_rwlock.c Sun Jan 19 18:34:24 2020
> @@ -1,4 +1,4 @@
> -/* $NetBSD: kern_rwlock.c,v 1.60 2020/01/12 18:37:10 ad Exp $ */
> +/* $NetBSD: kern_rwlock.c,v 1.61 2020/01/19 18:34:24 ad Exp $ */
>
> /*-
> * Copyright (c) 2002, 2006, 2007, 2008, 2009, 2019, 2020
> @@ -39,7 +39,9 @@
> */
>
> #include <sys/cdefs.h>
> -__KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.60 2020/01/12 18:37:10 ad Exp
> $");
> +__KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.61 2020/01/19 18:34:24 ad Exp
> $");
> +
> +#include "opt_lockdebug.h"
>
> #define __RWLOCK_PRIVATE
>
> @@ -63,58 +65,32 @@ __KERNEL_RCSID(0, "$NetBSD: kern_rwlock.
> * LOCKDEBUG
> */
>
> -#if defined(LOCKDEBUG)
> -
> -#define RW_WANTLOCK(rw, op)
> \
> - LOCKDEBUG_WANTLOCK(RW_DEBUG_P(rw), (rw), \
> - (uintptr_t)__builtin_return_address(0), op == RW_READER);
> -#define RW_LOCKED(rw, op)
> \
> - LOCKDEBUG_LOCKED(RW_DEBUG_P(rw), (rw), NULL, \
> - (uintptr_t)__builtin_return_address(0), op == RW_READER);
> -#define RW_UNLOCKED(rw, op)
> \
> - LOCKDEBUG_UNLOCKED(RW_DEBUG_P(rw), (rw), \
> - (uintptr_t)__builtin_return_address(0), op == RW_READER);
> -#define RW_DASSERT(rw, cond)
> \
> -do { \
> - if (__predict_false(!(cond))) \
> - rw_abort(__func__, __LINE__, rw, "assertion failed: " #cond);\
> -} while (/* CONSTCOND */ 0);
> -
> -#else /* LOCKDEBUG */
> -
> -#define RW_WANTLOCK(rw, op) /* nothing */
> -#define RW_LOCKED(rw, op) /* nothing */
> -#define RW_UNLOCKED(rw, op) /* nothing */
> -#define RW_DASSERT(rw, cond) /* nothing */
> +#define RW_DEBUG_P(rw) (((rw)->rw_owner & RW_NODEBUG) == 0)
>
> -#endif /* LOCKDEBUG */
> +#define RW_WANTLOCK(rw, op) \
> + LOCKDEBUG_WANTLOCK(RW_DEBUG_P(rw), (rw), \
> + (uintptr_t)__builtin_return_address(0), op == RW_READER);
> +#define RW_LOCKED(rw, op) \
> + LOCKDEBUG_LOCKED(RW_DEBUG_P(rw), (rw), NULL, \
> + (uintptr_t)__builtin_return_address(0), op == RW_READER);
> +#define RW_UNLOCKED(rw, op) \
> + LOCKDEBUG_UNLOCKED(RW_DEBUG_P(rw), (rw), \
> + (uintptr_t)__builtin_return_address(0), op == RW_READER);
>
> /*
> * DIAGNOSTIC
> */
>
> #if defined(DIAGNOSTIC)
> -
> -#define RW_ASSERT(rw, cond)
> \
> -do { \
> - if (__predict_false(!(cond))) \
> +#define RW_ASSERT(rw, cond) \
> +do { \
> + if (__predict_false(!(cond))) \
> rw_abort(__func__, __LINE__, rw, "assertion failed: " #cond);\
> } while (/* CONSTCOND */ 0)
> -
> #else
> -
> #define RW_ASSERT(rw, cond) /* nothing */
> -
> #endif /* DIAGNOSTIC */
>
> -#define RW_SETDEBUG(rw, on) ((rw)->rw_owner |= (on) ? 0 :
> RW_NODEBUG)
> -#define RW_DEBUG_P(rw) (((rw)->rw_owner & RW_NODEBUG)
> == 0)
> -#if defined(LOCKDEBUG)
> -#define RW_INHERITDEBUG(n, o) (n) |= (o) & RW_NODEBUG
> -#else /* defined(LOCKDEBUG) */
> -#define RW_INHERITDEBUG(n, o) /* nothing */
> -#endif /* defined(LOCKDEBUG) */
> -
> /*
> * Memory barriers.
> */
> @@ -128,29 +104,6 @@ do {
> \
> #define RW_MEMBAR_PRODUCER() membar_producer()
> #endif
>
> -static void rw_abort(const char *, size_t, krwlock_t *, const char *);
> -static void rw_dump(const volatile void *, lockop_printer_t);
> -static lwp_t *rw_owner(wchan_t);
> -
> -static inline uintptr_t
> -rw_cas(krwlock_t *rw, uintptr_t o, uintptr_t n)
> -{
> -
> - RW_INHERITDEBUG(n, o);
> - return (uintptr_t)atomic_cas_ptr((volatile void *)&rw->rw_owner,
> - (void *)o, (void *)n);
> -}
> -
> -static inline void
> -rw_swap(krwlock_t *rw, uintptr_t o, uintptr_t n)
> -{
> -
> - RW_INHERITDEBUG(n, o);
> - n = (uintptr_t)atomic_swap_ptr((volatile void *)&rw->rw_owner,
> - (void *)n);
> - RW_DASSERT(rw, n == o);
> -}
> -
> /*
> * For platforms that do not provide stubs, or for the LOCKDEBUG case.
> */
> @@ -164,6 +117,10 @@ __strong_alias(rw_exit,rw_vector_exit);
> __strong_alias(rw_tryenter,rw_vector_tryenter);
> #endif
>
> +static void rw_abort(const char *, size_t, krwlock_t *, const char *);
> +static void rw_dump(const volatile void *, lockop_printer_t);
> +static lwp_t *rw_owner(wchan_t);
> +
> lockops_t rwlock_lockops = {
> .lo_name = "Reader / writer lock",
> .lo_type = LOCKOPS_SLEEP,
> @@ -179,6 +136,37 @@ syncobj_t rw_syncobj = {
> };
>
> /*
> + * rw_cas:
> + *
> + * Do an atomic compare-and-swap on the lock word.
> + */
> +static inline uintptr_t
> +rw_cas(krwlock_t *rw, uintptr_t o, uintptr_t n)
> +{
> +
> + return (uintptr_t)atomic_cas_ptr((volatile void *)&rw->rw_owner,
> + (void *)o, (void *)n);
> +}
> +
> +/*
> + * rw_swap:
> + *
> + * Do an atomic swap of the lock word. This is used only when it's
> + * known that the lock word is set up such that it can't be changed
> + * behind us (assert this), so there's no point considering the result.
> + */
> +static inline void
> +rw_swap(krwlock_t *rw, uintptr_t o, uintptr_t n)
> +{
> +
> + n = (uintptr_t)atomic_swap_ptr((volatile void *)&rw->rw_owner,
> + (void *)n);
> +
> + RW_ASSERT(rw, n == o);
> + RW_ASSERT(rw, (o & RW_HAS_WAITERS) != 0);
> +}
> +
> +/*
> * rw_dump:
> *
> * Dump the contents of a rwlock structure.
> @@ -214,16 +202,14 @@ rw_abort(const char *func, size_t line,
> *
> * Initialize a rwlock for use.
> */
> -void _rw_init(krwlock_t *, uintptr_t);
> void
> _rw_init(krwlock_t *rw, uintptr_t return_address)
> {
> - bool dodebug;
>
> - memset(rw, 0, sizeof(*rw));
> -
> - dodebug = LOCKDEBUG_ALLOC(rw, &rwlock_lockops, return_address);
> - RW_SETDEBUG(rw, dodebug);
> + if (LOCKDEBUG_ALLOC(rw, &rwlock_lockops, return_address))
> + rw->rw_owner = 0;
> + else
> + rw->rw_owner = RW_NODEBUG;
> }
>
> void
> @@ -243,7 +229,7 @@ rw_destroy(krwlock_t *rw)
> {
>
> RW_ASSERT(rw, (rw->rw_owner & ~RW_NODEBUG) == 0);
> - LOCKDEBUG_FREE(RW_DEBUG_P(rw), rw);
> + LOCKDEBUG_FREE((rw->rw_owner & RW_NODEBUG) == 0, rw);
> }
>
> /*
> @@ -327,7 +313,7 @@ rw_vector_enter(krwlock_t *rw, const krw
> need_wait = RW_WRITE_LOCKED | RW_WRITE_WANTED;
> queue = TS_READER_Q;
> } else {
> - RW_DASSERT(rw, op == RW_WRITER);
> + RW_ASSERT(rw, op == RW_WRITER);
> incr = curthread | RW_WRITE_LOCKED;
> set_wait = RW_HAS_WAITERS | RW_WRITE_WANTED;
> need_wait = RW_WRITE_LOCKED | RW_THREAD;
> @@ -430,7 +416,7 @@ rw_vector_enter(krwlock_t *rw, const krw
> (uintptr_t)__builtin_return_address(0)));
> LOCKSTAT_EXIT(lsflag);
>
> - RW_DASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
> + RW_ASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
> (op == RW_READER && RW_COUNT(rw) != 0));
> RW_LOCKED(rw, op);
> }
> @@ -448,7 +434,8 @@ rw_vector_exit(krwlock_t *rw)
> int rcnt, wcnt;
> lwp_t *l;
>
> - curthread = (uintptr_t)curlwp;
> + l = curlwp;
> + curthread = (uintptr_t)l;
> RW_ASSERT(rw, curthread != 0);
>
> /*
> @@ -491,8 +478,8 @@ rw_vector_exit(krwlock_t *rw)
> */
> ts = turnstile_lookup(rw);
> owner = rw->rw_owner;
> - RW_DASSERT(rw, ts != NULL);
> - RW_DASSERT(rw, (owner & RW_HAS_WAITERS) != 0);
> + RW_ASSERT(rw, ts != NULL);
> + RW_ASSERT(rw, (owner & RW_HAS_WAITERS) != 0);
>
> wcnt = TS_WAITERS(ts, TS_WRITER_Q);
> rcnt = TS_WAITERS(ts, TS_READER_Q);
> @@ -509,31 +496,35 @@ rw_vector_exit(krwlock_t *rw)
> * do the work of acquiring the lock in rw_vector_enter().
> */
> if (rcnt == 0 || decr == RW_READ_INCR) {
> - RW_DASSERT(rw, wcnt != 0);
> - RW_DASSERT(rw, (owner & RW_WRITE_WANTED) != 0);
> + RW_ASSERT(rw, wcnt != 0);
> + RW_ASSERT(rw, (owner & RW_WRITE_WANTED) != 0);
>
> if (rcnt != 0) {
> /* Give the lock to the longest waiting writer. */
> l = TS_FIRST(ts, TS_WRITER_Q);
> - newown = (uintptr_t)l | RW_WRITE_LOCKED |
> RW_HAS_WAITERS;
> + newown = (uintptr_t)l | (owner & RW_NODEBUG);
> + newown |= RW_WRITE_LOCKED | RW_HAS_WAITERS;
> if (wcnt > 1)
> newown |= RW_WRITE_WANTED;
> rw_swap(rw, owner, newown);
> turnstile_wakeup(ts, TS_WRITER_Q, 1, l);
> } else {
> /* Wake all writers and let them fight it out. */
> - rw_swap(rw, owner, RW_WRITE_WANTED);
> + newown = owner & RW_NODEBUG;
> + newown |= RW_WRITE_WANTED;
> + rw_swap(rw, owner, newown);
> turnstile_wakeup(ts, TS_WRITER_Q, wcnt, NULL);
> }
> } else {
> - RW_DASSERT(rw, rcnt != 0);
> + RW_ASSERT(rw, rcnt != 0);
>
> /*
> * Give the lock to all blocked readers. If there
> * is a writer waiting, new readers that arrive
> * after the release will be blocked out.
> */
> - newown = rcnt << RW_READ_COUNT_SHIFT;
> + newown = owner & RW_NODEBUG;
> + newown += rcnt << RW_READ_COUNT_SHIFT;
> if (wcnt != 0)
> newown |= RW_HAS_WAITERS | RW_WRITE_WANTED;
>
> @@ -552,8 +543,10 @@ int
> rw_vector_tryenter(krwlock_t *rw, const krw_t op)
> {
> uintptr_t curthread, owner, incr, need_wait, next;
> + lwp_t *l;
>
> - curthread = (uintptr_t)curlwp;
> + l = curlwp;
> + curthread = (uintptr_t)l;
>
> RW_ASSERT(rw, curthread != 0);
>
> @@ -561,7 +554,7 @@ rw_vector_tryenter(krwlock_t *rw, const
> incr = RW_READ_INCR;
> need_wait = RW_WRITE_LOCKED | RW_WRITE_WANTED;
> } else {
> - RW_DASSERT(rw, op == RW_WRITER);
> + RW_ASSERT(rw, op == RW_WRITER);
> incr = curthread | RW_WRITE_LOCKED;
> need_wait = RW_WRITE_LOCKED | RW_THREAD;
> }
> @@ -572,24 +565,23 @@ rw_vector_tryenter(krwlock_t *rw, const
> next = rw_cas(rw, owner, owner + incr);
> if (__predict_true(next == owner)) {
> /* Got it! */
> - RW_MEMBAR_ENTER();
> break;
> }
> }
>
> RW_WANTLOCK(rw, op);
> RW_LOCKED(rw, op);
> - RW_DASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
> + RW_ASSERT(rw, (op != RW_READER && RW_OWNER(rw) == curthread) ||
> (op == RW_READER && RW_COUNT(rw) != 0));
>
> + RW_MEMBAR_ENTER();
> return 1;
> }
>
> /*
> * rw_downgrade:
> *
> - * Downgrade a write lock to a read lock. Optimise memory accesses for
> - * the uncontended case.
> + * Downgrade a write lock to a read lock.
> */
> void
> rw_downgrade(krwlock_t *rw)
> @@ -597,55 +589,64 @@ rw_downgrade(krwlock_t *rw)
> uintptr_t owner, curthread, newown, next;
> turnstile_t *ts;
> int rcnt, wcnt;
> + lwp_t *l;
>
> - curthread = (uintptr_t)curlwp;
> + l = curlwp;
> + curthread = (uintptr_t)l;
> RW_ASSERT(rw, curthread != 0);
> - RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) != 0);
> + RW_ASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) != 0);
> RW_ASSERT(rw, RW_OWNER(rw) == curthread);
> RW_UNLOCKED(rw, RW_WRITER);
> #if !defined(DIAGNOSTIC)
> __USE(curthread);
> #endif
>
> - /*
> - * If there are no waiters, so we can do this the easy way.
> - * Try swapping us down to one read hold. If it fails, the
> - * lock condition has changed and we most likely now have
> - * waiters.
> - */
> RW_MEMBAR_PRODUCER();
> - owner = curthread | RW_WRITE_LOCKED;
> - next = rw_cas(rw, owner, RW_READ_INCR);
> - if (__predict_true(next == owner)) {
> - RW_LOCKED(rw, RW_READER);
> - RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
> - RW_DASSERT(rw, RW_COUNT(rw) != 0);
> - return;
> - }
>
> - /*
> - * Grab the turnstile chain lock. This gets the interlock
> - * on the sleep queue. Once we have that, we can adjust the
> - * waiter bits.
> - */
> - for (;;) {
> - owner = next;
> + for (owner = rw->rw_owner;; owner = next) {
> + /*
> + * If there are no waiters we can do this the easy way. Try
> + * swapping us down to one read hold. If it fails, the lock
> + * condition has changed and we most likely now have
> + * waiters.
> + */
> + if ((owner & RW_HAS_WAITERS) == 0) {
> + newown = (owner & RW_NODEBUG);
> + next = rw_cas(rw, owner, newown + RW_READ_INCR);
> + if (__predict_true(next == owner)) {
> + RW_LOCKED(rw, RW_READER);
> + RW_ASSERT(rw,
> + (rw->rw_owner & RW_WRITE_LOCKED) == 0);
> + RW_ASSERT(rw, RW_COUNT(rw) != 0);
> + return;
> + }
> + continue;
> + }
> +
> + /*
> + * Grab the turnstile chain lock. This gets the interlock
> + * on the sleep queue. Once we have that, we can adjust the
> + * waiter bits.
> + */
> ts = turnstile_lookup(rw);
> - RW_DASSERT(rw, ts != NULL);
> + RW_ASSERT(rw, ts != NULL);
>
> rcnt = TS_WAITERS(ts, TS_READER_Q);
> wcnt = TS_WAITERS(ts, TS_WRITER_Q);
>
> - /*
> - * If there are no readers, just preserve the waiters
> - * bits, swap us down to one read hold and return.
> - */
> if (rcnt == 0) {
> - RW_DASSERT(rw, wcnt != 0);
> - RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_WANTED) != 0);
> - RW_DASSERT(rw, (rw->rw_owner & RW_HAS_WAITERS) != 0);
> -
> - newown = RW_READ_INCR | RW_HAS_WAITERS |
> RW_WRITE_WANTED;
> + /*
> + * If there are no readers, just preserve the
> + * waiters bits, swap us down to one read hold and
> + * return.
> + */
> + RW_ASSERT(rw, wcnt != 0);
> + RW_ASSERT(rw, (rw->rw_owner & RW_WRITE_WANTED) != 0);
> + RW_ASSERT(rw, (rw->rw_owner & RW_HAS_WAITERS) != 0);
> +
> + newown = owner & RW_NODEBUG;
> + newown = RW_READ_INCR | RW_HAS_WAITERS |
> + RW_WRITE_WANTED;
> next = rw_cas(rw, owner, newown);
> turnstile_exit(rw);
> if (__predict_true(next == owner))
> @@ -653,11 +654,12 @@ rw_downgrade(krwlock_t *rw)
> } else {
> /*
> * Give the lock to all blocked readers. We may
> - * retain one read hold if downgrading. If there
> - * is a writer waiting, new readers will be blocked
> + * retain one read hold if downgrading. If there is
> + * a writer waiting, new readers will be blocked
> * out.
> */
> - newown = (rcnt << RW_READ_COUNT_SHIFT) + RW_READ_INCR;
> + newown = owner & RW_NODEBUG;
> + newown += (rcnt << RW_READ_COUNT_SHIFT) + RW_READ_INCR;
> if (wcnt != 0)
> newown |= RW_HAS_WAITERS | RW_WRITE_WANTED;
>
> @@ -673,22 +675,24 @@ rw_downgrade(krwlock_t *rw)
>
> RW_WANTLOCK(rw, RW_READER);
> RW_LOCKED(rw, RW_READER);
> - RW_DASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
> - RW_DASSERT(rw, RW_COUNT(rw) != 0);
> + RW_ASSERT(rw, (rw->rw_owner & RW_WRITE_LOCKED) == 0);
> + RW_ASSERT(rw, RW_COUNT(rw) != 0);
> }
>
> /*
> * rw_tryupgrade:
> *
> * Try to upgrade a read lock to a write lock. We must be the only
> - * reader. Optimise memory accesses for the uncontended case.
> + * reader.
> */
> int
> rw_tryupgrade(krwlock_t *rw)
> {
> uintptr_t owner, curthread, newown, next;
> + struct lwp *l;
>
> - curthread = (uintptr_t)curlwp;
> + l = curlwp;
> + curthread = (uintptr_t)l;
> RW_ASSERT(rw, curthread != 0);
> RW_ASSERT(rw, rw_read_held(rw));
>
> @@ -709,8 +713,8 @@ rw_tryupgrade(krwlock_t *rw)
> RW_UNLOCKED(rw, RW_READER);
> RW_WANTLOCK(rw, RW_WRITER);
> RW_LOCKED(rw, RW_WRITER);
> - RW_DASSERT(rw, rw->rw_owner & RW_WRITE_LOCKED);
> - RW_DASSERT(rw, RW_OWNER(rw) == curthread);
> + RW_ASSERT(rw, rw->rw_owner & RW_WRITE_LOCKED);
> + RW_ASSERT(rw, RW_OWNER(rw) == curthread);
>
> return 1;
> }
>
> Index: src/sys/sys/rwlock.h
> diff -u src/sys/sys/rwlock.h:1.12 src/sys/sys/rwlock.h:1.13
> --- src/sys/sys/rwlock.h:1.12 Wed Jan 1 21:34:39 2020
> +++ src/sys/sys/rwlock.h Sun Jan 19 18:34:24 2020
> @@ -1,7 +1,7 @@
> -/* $NetBSD: rwlock.h,v 1.12 2020/01/01 21:34:39 ad Exp $ */
> +/* $NetBSD: rwlock.h,v 1.13 2020/01/19 18:34:24 ad Exp $ */
>
> /*-
> - * Copyright (c) 2002, 2006, 2007, 2008, 2019 The NetBSD Foundation, Inc.
> + * Copyright (c) 2002, 2006, 2007, 2008, 2019, 2020 The NetBSD Foundation,
> Inc.
> * All rights reserved.
> *
> * This code is derived from software contributed to The NetBSD Foundation
> @@ -45,10 +45,6 @@
> * rw_tryenter()
> */
>
> -#if defined(_KERNEL_OPT)
> -#include "opt_lockdebug.h"
> -#endif
> -
> #if !defined(_KERNEL)
> #include <sys/types.h>
> #include <sys/inttypes.h>
> @@ -75,13 +71,9 @@ typedef struct krwlock krwlock_t;
> #define RW_HAS_WAITERS 0x01UL /* lock has waiters */
> #define RW_WRITE_WANTED 0x02UL /* >= 1 waiter is a writer */
> #define RW_WRITE_LOCKED 0x04UL /* lock is currently write
> locked */
> -#if defined(LOCKDEBUG)
> -#define RW_NODEBUG 0x08UL /* LOCKDEBUG disabled */
> -#else
> -#define RW_NODEBUG 0x00UL /* do nothing */
> -#endif /* LOCKDEBUG */
> +#define RW_NODEBUG 0x10UL /* LOCKDEBUG disabled */
>
> -#define RW_READ_COUNT_SHIFT 4
> +#define RW_READ_COUNT_SHIFT 5
> #define RW_READ_INCR (1UL << RW_READ_COUNT_SHIFT)
> #define RW_THREAD ((uintptr_t)-RW_READ_INCR)
> #define RW_OWNER(rw) ((rw)->rw_owner & RW_THREAD)
> @@ -91,6 +83,7 @@ typedef struct krwlock krwlock_t;
> void rw_vector_enter(krwlock_t *, const krw_t);
> void rw_vector_exit(krwlock_t *);
> int rw_vector_tryenter(krwlock_t *, const krw_t);
> +void _rw_init(krwlock_t *, uintptr_t);
> #endif /* __RWLOCK_PRIVATE */
>
> struct krwlock {
>
--
Ryo ONODERA // r...@tetera.org
PGP fingerprint = 82A2 DC91 76E0 A10A 8ABB FD1B F404 27FA C7D1 15F3
