common/syscall/lwp_sobj.c

631  * Returns pointer to kernel object (upimutex_t *) if lp is owned.
634 lwp_upimutex_owned(lwp_mutex_t *lp, uint8_t type)
640 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
705 lwp_upimutex_lock(lwp_mutex_t *lp, uint8_t type, int try, lwp_timer_t *lwptp)
723 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
738 		upimutex->upi_vaddr = lp;
743 		fuword16_noerr(&lp->mutex_flag, &flag);
858 		    (upimutex = lwp_upimutex_owned(lp, type))) {
872 		ASSERT(!lwp_upimutex_owned(lp, type));
875 	if (lwp_upimutex_owned(lp, type)) {
876 		ASSERT(lwp_upimutex_owned(lp, type) == upimutex);
881 	 * Now, need to read the user-level lp->mutex_flag to do the following:
888 	 * Now, either lp->mutex_flag is readable or it's not. If not
900 	fuword16_noerr(&lp->mutex_flag, &flag);
971 lwp_upimutex_unlock(lwp_mutex_t *lp, uint8_t type)
987 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
1007 	fuword16_noerr(&lp->mutex_flag, &flag);
1014 		suword16_noerr(&lp->mutex_flag, flag);
1016 	set_owner_pid(lp, 0, 0);
1028 set_owner_pid(lwp_mutex_t *lp, uintptr_t owner, pid_t pid)
1037 	suword32_noerr(&lp->mutex_ownerpid, pid);
1039 	if (((uintptr_t)lp & (_LONG_LONG_ALIGNMENT - 1)) == 0) { /* aligned */
1040 		suword64_noerr(&lp->mutex_owner, un.word64);
1045 	suword32_noerr((uint32_t *)&lp->mutex_owner, un.word32[0]);
1046 	suword32_noerr((uint32_t *)&lp->mutex_owner + 1, un.word32[1]);
1054 lwp_clear_mutex(lwp_mutex_t *lp, uint16_t lockflg)
1058 	fuword16_noerr(&lp->mutex_flag, &flag);
1062 		suword16_noerr(&lp->mutex_flag, flag);
1064 	set_owner_pid(lp, 0, 0);
1065 	suword8_noerr(&lp->mutex_rcount, 0);
1079 	lwp_mutex_t *lp;
1086 	lp = upip->upi_vaddr;
1087 	(void) lwp_clear_mutex(lp, lockflg);
1088 	suword8_noerr(&lp->mutex_lockw, 0);
1144 lwp_mutex_timedlock(lwp_mutex_t *lp, timespec_t *tsp, uintptr_t owner)
1164 	if ((caddr_t)lp >= p->p_as->a_userlimit)
1199 	fuword8_noerr(&lp->mutex_type, (uint8_t *)&type);
1200 	suword8_noerr(&lp->mutex_type, type);
1203 		error = lwp_upimutex_lock(lp, type, UPIMUTEX_BLOCK, &lwpt);
1205 			set_owner_pid(lp, owner,
1213 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
1221 		fuword16_noerr(&lp->mutex_flag, &flag);
1228 	fuword8_noerr(&lp->mutex_waiters, &waiters);
1229 	suword8_noerr(&lp->mutex_waiters, 1);
1237 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
1239 	while (!ulock_try(&lp->mutex_lockw)) {
1251 			watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
1291 			watched = watch_disable_addr((caddr_t)lp, sizeof (*lp),
1315 		watched = watch_disable_addr((caddr_t)lp, sizeof (*lp),
1319 		fuword8_noerr(&lp->mutex_waiters, &waiters);
1320 		suword8_noerr(&lp->mutex_waiters, 1);
1322 			fuword16_noerr(&lp->mutex_flag, &flag);
1334 		set_owner_pid(lp, owner, (type & USYNC_PROCESS)? p->p_pid : 0);
1336 			fuword16_noerr(&lp->mutex_flag, &flag);
1347 	suword8_noerr(&lp->mutex_waiters, waiters);
1353 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
1481 lwp_mutex_wakeup(lwp_mutex_t *lp, int release_all)
1492 	if ((caddr_t)lp >= p->p_as->a_userlimit)
1495 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
1508 	fuword8_noerr(&lp->mutex_type, (uint8_t *)&type);
1509 	suword8_noerr(&lp->mutex_type, type);
1510 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
1539 		suword8_noerr(&lp->mutex_waiters, waiters);
1544 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
2866 	lwp_mutex_t *lp;
2876 	lp = (lwp_mutex_t *)ent->lwpchan_addr;
2877 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
2886 	fuword32_noerr(&lp->mutex_ownerpid, (uint32_t *)&owner_pid);
2902 		flag = lwp_clear_mutex(lp, lockflg);
2903 		suword8_noerr(&lp->mutex_lockw, 0);
2915 		suword8_noerr(&lp->mutex_spinners, 0);
2924 			fuword8_noerr(&lp->mutex_waiters, &waiters);
2926 				fuword16_noerr(&lp->mutex_flag, &flag);
2929 					suword8_noerr(&lp->mutex_waiters, 0);
2932 					suword8_noerr(&lp->mutex_waiters,
2940 			(void) lwp_clear_mutex(lp, lockflg);
2941 			ulock_clear(&lp->mutex_lockw);
2942 			fuword8_noerr(&lp->mutex_waiters, &waiters);
2945 				suword8_noerr(&lp->mutex_waiters, waiters);
2952 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
2959 lwp_mutex_register(lwp_mutex_t *lp, caddr_t uaddr)
2967 	if ((caddr_t)lp >= (caddr_t)USERLIMIT)
2970 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
2980 		fuword8_noerr(&lp->mutex_type, &type);
2981 		suword8_noerr(&lp->mutex_type, type);
2985 		} else if (!lwpchan_get_mapping(curproc->p_as, (caddr_t)lp,
2992 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
3015 lwp_mutex_trylock(lwp_mutex_t *lp, uintptr_t owner)
3027 	if ((caddr_t)lp >= p->p_as->a_userlimit)
3043 	fuword8_noerr(&lp->mutex_type, (uint8_t *)&type);
3044 	suword8_noerr(&lp->mutex_type, type);
3047 		error = lwp_upimutex_lock(lp, type, UPIMUTEX_TRY, NULL);
3049 			set_owner_pid(lp, owner,
3055 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
3063 		fuword16_noerr(&lp->mutex_flag, &flag);
3071 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
3073 	if (!ulock_try(&lp->mutex_lockw))
3076 		set_owner_pid(lp, owner, (type & USYNC_PROCESS)? p->p_pid : 0);
3078 			fuword16_noerr(&lp->mutex_flag, &flag);
3098 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
3109 lwp_mutex_unlock(lwp_mutex_t *lp)
3121 	if ((caddr_t)lp >= p->p_as->a_userlimit)
3136 	fuword8_noerr(&lp->mutex_type, (uint8_t *)&type);
3137 	suword8_noerr(&lp->mutex_type, type);
3141 		error = lwp_upimutex_unlock(lp, type);
3147 	watched = watch_disable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);
3149 	if (!get_lwpchan(curproc->p_as, (caddr_t)lp, type,
3157 		fuword16_noerr(&lp->mutex_flag, &flag);
3161 			suword16_noerr(&lp->mutex_flag, flag);
3164 	set_owner_pid(lp, 0, 0);
3165 	ulock_clear(&lp->mutex_lockw);
3185 	fuword8_noerr(&lp->mutex_waiters, &waiters);
3190 			suword8_noerr(&lp->mutex_waiters, 0);
3192 			suword8_noerr(&lp->mutex_waiters, waiters);
3200 		watch_enable_addr((caddr_t)lp, sizeof (*lp), S_WRITE);