98  */

    98  */

    99 void

    99 void

   100 zmutex_init(kmutex_t *mp)

   100 zmutex_init(kmutex_t *mp)

   101 {

   101 {

   102 	mp->m_owner = NULL;

   102 	mp->m_owner = NULL;

   103 	(void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL);

   104 	(void) _mutex_init(&mp->m_lock, USYNC_THREAD, NULL);

   104 }

   105 }

   105 

   106 

   106 void

   107 void

   107 zmutex_destroy(kmutex_t *mp)

   108 zmutex_destroy(kmutex_t *mp)

   108 {

   109 {

   109 	ASSERT(mp->m_owner == NULL);

   111 	ASSERT(mp->m_owner == NULL);

   110 	(void) _mutex_destroy(&(mp)->m_lock);

   112 	(void) _mutex_destroy(&(mp)->m_lock);

   111 	mp->m_owner = (void *)-1UL;

   113 	mp->m_owner = (void *)-1UL;

   112 }

   115 }

   113 

   116 

   114 void

   117 void

   115 mutex_enter(kmutex_t *mp)

   118 mutex_enter(kmutex_t *mp)

   116 {

   119 {

   117 	ASSERT(mp->m_owner != (void *)-1UL);

   121 	ASSERT(mp->m_owner != (void *)-1UL);

   118 	ASSERT(mp->m_owner != curthread);

   122 	ASSERT(mp->m_owner != curthread);

   119 	VERIFY(mutex_lock(&mp->m_lock) == 0);

   123 	VERIFY(mutex_lock(&mp->m_lock) == 0);

   120 	ASSERT(mp->m_owner == NULL);

   124 	ASSERT(mp->m_owner == NULL);

   121 	mp->m_owner = curthread;

   125 	mp->m_owner = curthread;

   122 }

   126 }

   123 

   127 

   124 int

   128 int

   125 mutex_tryenter(kmutex_t *mp)

   129 mutex_tryenter(kmutex_t *mp)

   126 {

   130 {

   127 	ASSERT(mp->m_owner != (void *)-1UL);

   132 	ASSERT(mp->m_owner != (void *)-1UL);

   128 	if (0 == mutex_trylock(&mp->m_lock)) {

   133 	if (0 == mutex_trylock(&mp->m_lock)) {

   129 		ASSERT(mp->m_owner == NULL);

   134 		ASSERT(mp->m_owner == NULL);

   130 		mp->m_owner = curthread;

   135 		mp->m_owner = curthread;

   131 		return (1);

   136 		return (1);

   135 }

   140 }

   136 

   141 

   137 void

   142 void

   138 mutex_exit(kmutex_t *mp)

   143 mutex_exit(kmutex_t *mp)

   139 {

   144 {

   140 	ASSERT(mutex_owner(mp) == curthread);

   146 	ASSERT(mutex_owner(mp) == curthread);

   141 	mp->m_owner = NULL;

   147 	mp->m_owner = NULL;

   142 	VERIFY(mutex_unlock(&mp->m_lock) == 0);

   148 	VERIFY(mutex_unlock(&mp->m_lock) == 0);

   143 }

   149 }

   144 

   150 

   145 void *

   151 void *

   146 mutex_owner(kmutex_t *mp)

   152 mutex_owner(kmutex_t *mp)

   147 {

   153 {

   148 	return (mp->m_owner);

   155 	return (mp->m_owner);

   149 }

   156 }

   150 

   157 

   151 /*

   158 /*

   152  * =========================================================================

   159  * =========================================================================

   157 void

   164 void

   158 rw_init(krwlock_t *rwlp, char *name, int type, void *arg)

   165 rw_init(krwlock_t *rwlp, char *name, int type, void *arg)

   159 {

   166 {

   160 	rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL);

   167 	rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL);

   161 	rwlp->rw_owner = NULL;

   168 	rwlp->rw_owner = NULL;

   162 }

   170 }

   163 

   171 

   164 void

   172 void

   165 rw_destroy(krwlock_t *rwlp)

   173 rw_destroy(krwlock_t *rwlp)

   166 {

   174 {

   167 	rwlock_destroy(&rwlp->rw_lock);

   175 	rwlock_destroy(&rwlp->rw_lock);

   168 	rwlp->rw_owner = (void *)-1UL;

   176 	rwlp->rw_owner = (void *)-1UL;

   169 }

   178 }

   170 

   179 

   171 void

   180 void

   172 rw_enter(krwlock_t *rwlp, krw_t rw)

   181 rw_enter(krwlock_t *rwlp, krw_t rw)

   173 {

   182 {

   174 	ASSERT(!RW_LOCK_HELD(rwlp));

   183 	ASSERT(!RW_LOCK_HELD(rwlp));

   175 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   185 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   176 	ASSERT(rwlp->rw_owner != curthread);

   186 	ASSERT(rwlp->rw_owner != curthread);

   177 

   187 

   178 	if (rw == RW_READER)

   188 	if (rw == RW_READER)

   179 		(void) rw_rdlock(&rwlp->rw_lock);

   189 		(void) rw_rdlock(&rwlp->rw_lock);

   184 }

   194 }

   185 

   195 

   186 void

   196 void

   187 rw_exit(krwlock_t *rwlp)

   197 rw_exit(krwlock_t *rwlp)

   188 {

   198 {

   189 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   200 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   190 

   201 

   191 	rwlp->rw_owner = NULL;

   202 	rwlp->rw_owner = NULL;

   192 	(void) rw_unlock(&rwlp->rw_lock);

   203 	(void) rw_unlock(&rwlp->rw_lock);

   193 }

   204 }

   195 int

   206 int

   196 rw_tryenter(krwlock_t *rwlp, krw_t rw)

   207 rw_tryenter(krwlock_t *rwlp, krw_t rw)

   197 {

   208 {

   198 	int rv;

   209 	int rv;

   199 

   210 

   200 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   212 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   201 

   213 

   202 	if (rw == RW_READER)

   214 	if (rw == RW_READER)

   203 		rv = rw_tryrdlock(&rwlp->rw_lock);

   215 		rv = rw_tryrdlock(&rwlp->rw_lock);

   204 	else

   216 	else

   214 

   226 

   215 /*ARGSUSED*/

   227 /*ARGSUSED*/

   216 int

   228 int

   217 rw_tryupgrade(krwlock_t *rwlp)

   229 rw_tryupgrade(krwlock_t *rwlp)

   218 {

   230 {

   219 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   232 	ASSERT(rwlp->rw_owner != (void *)-1UL);

   220 

   233 

   221 	return (0);

   234 	return (0);

   222 }

   235 }

   223 

   236