Return correct error number when time has already elapsed

Extrems · Extrems · commit 0705aa41eb6f · 2025-06-13T18:28:46.000-04:00
diff --git a/gc/ogc/lwp_messages.h b/gc/ogc/lwp_messages.h
@@ -113,8 +113,8 @@ typedef struct _mqcntrl {
 
 u32 __lwpmq_initialize(mq_cntrl *mqueue,mq_attr *attrs,u32 max_pendingmsgs,u32 max_msgsize);
 void __lwpmq_close(mq_cntrl *mqueue,u32 status);
-u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 timeout);
-u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait,s64 timeout);
+u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait_status,s64 timeout);
+u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait_status,s64 timeout);
 u32 __lwpmq_broadcast(mq_cntrl *mqueue,void *buffer,u32 size,u32 id,u32 *count);
 void __lwpmq_msg_insert(mq_cntrl *mqueue,mq_buffercntrl *msg,u32 type);
 u32 __lwpmq_flush(mq_cntrl *mqueue);
diff --git a/gc/ogc/lwp_sema.h b/gc/ogc/lwp_sema.h
@@ -83,7 +83,7 @@ typedef struct _lwpsema {
 
 void __lwp_sema_initialize(lwp_sema *sema,lwp_semattr *attrs,u32 init_count);
 u32 __lwp_sema_surrender(lwp_sema *sema,u32 id);
-u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout);
+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait_status,s64 timeout);
 void __lwp_sema_flush(lwp_sema *sema,u32 status);
 
 #ifdef LIBOGC_INTERNAL
diff --git a/gc/ogc/lwp_threadq.h b/gc/ogc/lwp_threadq.h
@@ -71,7 +71,7 @@ void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,s64
 lwp_cntrl* __lwp_threadqueue_dequeuefifo(lwp_thrqueue *queue);
 void __lwp_threadqueue_enqueuepriority(lwp_thrqueue *queue,lwp_cntrl *thethread,s64 timeout);
 lwp_cntrl* __lwp_threadqueue_dequeuepriority(lwp_thrqueue *queue);
-void __lwp_threadqueue_init(lwp_thrqueue *queue,u32 mode,u32 state,u32 timeout_state);
+void __lwp_threadqueue_init(lwp_thrqueue *queue,u32 mode,u32 state,u32 timeout_status);
 lwp_cntrl* __lwp_threadqueue_first(lwp_thrqueue *queue);
 void __lwp_threadqueue_enqueue(lwp_thrqueue *queue,s64 timeout);
 lwp_cntrl* __lwp_threadqueue_dequeue(lwp_thrqueue *queue);
diff --git a/gc/ogc/lwp_tqdata.h b/gc/ogc/lwp_tqdata.h
@@ -81,7 +81,7 @@ typedef struct _lwpthrqueue {
 	u32 sync_state;
 	u32 mode;
 	u32 state;
-	u32 timeout_state;
+	u32 timeout_status;
 } lwp_thrqueue;
 
 #ifdef __cplusplus
diff --git a/libogc/cond.c b/libogc/cond.c
@@ -111,7 +111,7 @@ static cond_st* __lwp_cond_allocate(void)
 
 static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,s64 timeout,u8 timedout)
 {
-	u32 status,mstatus,level;
+	u32 status,mutex_status,level;
 	cond_st *thecond;
 
 	thecond = __lwp_cond_open(cond);
@@ -142,8 +142,8 @@ static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,s64 timeout,u8 timedout
 		status = ETIMEDOUT;
 	}
 
-	mstatus = LWP_MutexLock(mutex);
-	if(mstatus)
+	mutex_status = LWP_MutexLock(mutex);
+	if(mutex_status)
 		return EINVAL;
 
 	return status;
diff --git a/libogc/lwp.c b/libogc/lwp.c
@@ -357,7 +357,7 @@ void LWP_ExitThread(void *value_ptr)
 	__builtin_unreachable();
 }
 
-static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 timeout)
+static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u32 wait_status,s64 timeout)
 {
 	u32 level;
 	lwp_cntrl *exec,*lwp_thread;
@@ -382,9 +382,9 @@ static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 t
 		return 0;
 	}
 
-	if(!block) {
+	if(wait_status) {
 		__lwp_thread_dispatchenable();
-		return EBUSY;
+		return wait_status;
 	}
 
 	exec = _thr_executing;
@@ -402,25 +402,25 @@ static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 t
 
 s32 LWP_JoinThread(lwp_t thethread,void **value_ptr)
 {
-	return __lwp_thread_joinsupp(thethread,value_ptr,TRUE,LWP_THREADQ_NOTIMEOUT);
+	return __lwp_thread_joinsupp(thethread,value_ptr,0,LWP_THREADQ_NOTIMEOUT);
 }
 
 s32 LWP_TimedJoinThread(lwp_t thethread,void **value_ptr,const struct timespec *reltime)
 {
+	u32 wait_status = 0;
 	s64 timeout = LWP_THREADQ_NOTIMEOUT;
-	u8 block = TRUE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;
 		timeout = __lwp_wd_calc_ticks(reltime);
-		if(timeout<=0) block = FALSE;
+		if(timeout<=0) wait_status = ETIMEDOUT;
 	}
-	return __lwp_thread_joinsupp(thethread,value_ptr,block,timeout);
+	return __lwp_thread_joinsupp(thethread,value_ptr,wait_status,timeout);
 }
 
 s32 LWP_TryJoinThread(lwp_t thethread,void **value_ptr)
 {
-	return __lwp_thread_joinsupp(thethread,value_ptr,FALSE,LWP_THREADQ_NOTIMEOUT);
+	return __lwp_thread_joinsupp(thethread,value_ptr,EBUSY,LWP_THREADQ_NOTIMEOUT);
 }
 
 s32 LWP_DetachThread(lwp_t thethread)
diff --git a/libogc/lwp_messages.c b/libogc/lwp_messages.c
@@ -126,7 +126,7 @@ u32 __lwpmq_initialize(mq_cntrl *mqueue,mq_attr *attrs,u32 max_pendingmsgs,u32 m
 	return 1;
 }
 
-u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 timeout)
+u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait_status,s64 timeout)
 {
 	u32 level;
 	mq_buffercntrl *msg;
@@ -135,7 +135,7 @@ u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 ti
 	exec = _thr_executing;
 	exec->wait.ret_code = LWP_MQ_STATUS_SUCCESSFUL;
 #ifdef _LWPMQ_DEBUG
-	printf("__lwpmq_seize(%p,%d,%p,%p,%d,%d)\n",mqueue,id,buffer,size,wait,mqueue->num_pendingmsgs);
+	printf("__lwpmq_seize(%p,%d,%p,%p,%d,%d)\n",mqueue,id,buffer,size,wait_status,mqueue->num_pendingmsgs);
 #endif
 	
 	_CPU_ISR_Disable(level);
@@ -162,10 +162,10 @@ u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 ti
 		return LWP_MQ_STATUS_SUCCESSFUL;
 	}
 
-	if(!wait) {
+	if(wait_status) {
 		_CPU_ISR_Restore(level);
-		exec->wait.ret_code = LWP_MQ_STATUS_UNSATISFIED_NOWAIT;
-		return LWP_MQ_STATUS_UNSATISFIED_NOWAIT;
+		exec->wait.ret_code = wait_status;
+		return wait_status;
 	}
 
 	__lwp_threadqueue_csenter(&mqueue->wait_queue);
@@ -179,14 +179,14 @@ u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 ti
 	return LWP_MQ_STATUS_SUCCESSFUL;
 }
 
-u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait,s64 timeout)
+u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait_status,s64 timeout)
 {
 	u32 level;
 	lwp_cntrl *thread;
 	mq_buffercntrl *msg;
 
 #ifdef _LWPMQ_DEBUG
-	printf("__lwpmq_submit(%p,%p,%d,%d,%d,%d)\n",mqueue,buffer,size,id,type,wait);
+	printf("__lwpmq_submit(%p,%p,%d,%d,%d,%d)\n",mqueue,buffer,size,id,type,wait_status);
 #endif
 	if(size>mqueue->max_msgsize)
 		return LWP_MQ_STATUS_INVALID_SIZE;
@@ -212,7 +212,7 @@ u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wa
 		return LWP_MQ_STATUS_SUCCESSFUL;
 	}
 
-	if(!wait) return LWP_MQ_STATUS_TOO_MANY;
+	if(wait_status) return wait_status;
 	if(__lwp_isr_in_progress()) return LWP_MQ_STATUS_UNSATISFIED;
 
 	{
diff --git a/libogc/lwp_messages.inl b/libogc/lwp_messages.inl
@@ -91,14 +91,14 @@ static __inline__ void __lwpmq_msg_prepend(mq_cntrl *mqueue,mq_buffercntrl *msg)
 	__lwp_queue_prepend(&mqueue->pending_msgs,&msg->node);
 }
 
-static __inline__ u32 __lwpmq_send(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 wait,s64 timeout)
+static __inline__ u32 __lwpmq_send(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 wait_status,s64 timeout)
 {
-	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait,timeout);
+	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait_status,timeout);
 }
 
-static __inline__ u32 __lwpmq_urgent(mq_cntrl *mqueue,void *buffer,u32 size,u32 id,u32 wait,s64 timeout)
+static __inline__ u32 __lwpmq_urgent(mq_cntrl *mqueue,void *buffer,u32 size,u32 id,u32 wait_status,s64 timeout)
 {
-	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait,timeout);
+	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait_status,timeout);
 }
 
 static __inline__ mq_buffercntrl* __lwpmq_get_pendingmsg(mq_cntrl *mqueue)
diff --git a/libogc/lwp_mutex.inl b/libogc/lwp_mutex.inl
@@ -138,12 +138,12 @@ static __inline__ u32 __lwp_mutex_seize_irq_trylock(lwp_mutex *mutex,u32 *isr_le
 	return 1;
 }
 
-#define __lwp_mutex_seize(_mutex_t,_id,_wait,_timeout,_level) \
+#define __lwp_mutex_seize(_mutex_t,_id,_wait_status,_timeout,_level) \
 	do { \
 		if(__lwp_mutex_seize_irq_trylock(_mutex_t,&_level)) { \
-			if(!_wait) { \
+			if(_wait_status) { \
 				_CPU_ISR_Restore(_level); \
-				_thr_executing->wait.ret_code = LWP_MUTEX_UNSATISFIED_NOWAIT; \
+				_thr_executing->wait.ret_code = _wait_status; \
 			} else { \
 				__lwp_threadqueue_csenter(&(_mutex_t)->wait_queue); \
 				_thr_executing->wait.queue = &(_mutex_t)->wait_queue; \
diff --git a/libogc/lwp_sema.c b/libogc/lwp_sema.c
@@ -80,7 +80,7 @@ u32 __lwp_sema_surrender(lwp_sema *sema,u32 id)
 	return ret;
 }
 
-u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)
+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait_status,s64 timeout)
 {
 	u32 level;
 	lwp_cntrl *exec;
@@ -95,10 +95,10 @@ u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)
 		return LWP_SEMA_SUCCESSFUL;
 	}
 
-	if(!wait) {
+	if(wait_status) {
 		_CPU_ISR_Restore(level);
-		exec->wait.ret_code = LWP_SEMA_UNSATISFIED_NOWAIT;
-		return LWP_SEMA_UNSATISFIED_NOWAIT;
+		exec->wait.ret_code = wait_status;
+		return wait_status;
 	}
 
 	__lwp_threadqueue_csenter(&sema->wait_queue);
diff --git a/libogc/lwp_sema.inl b/libogc/lwp_sema.inl
@@ -64,7 +64,7 @@ static __inline__ u32 __lwp_sema_getcount(lwp_sema *sema)
 	return sema->count;
 }
 
-static __inline__ void __lwp_sema_seize_isrdisable(lwp_sema *sema,u32 id,u32 wait,u32 *isrlevel)
+static __inline__ void __lwp_sema_seize_isrdisable(lwp_sema *sema,u32 id,u32 wait_status,u32 *isrlevel)
 {
 	lwp_cntrl *exec;
 	u32 level = *isrlevel;
@@ -77,9 +77,9 @@ static __inline__ void __lwp_sema_seize_isrdisable(lwp_sema *sema,u32 id,u32 wai
 		return;
 	}
 
-	if(!wait) {
+	if(wait_status) {
 		_CPU_ISR_Restore(level);
-		exec->wait.ret_code = LWP_SEMA_UNSATISFIED_NOWAIT;
+		exec->wait.ret_code = wait_status;
 		return;
 	}
 
@@ -89,7 +89,7 @@ static __inline__ void __lwp_sema_seize_isrdisable(lwp_sema *sema,u32 id,u32 wai
 	exec->wait.id = id;
 	_CPU_ISR_Restore(level);
 
-	__lwp_threadqueue_enqueue(&sema->wait_queue,0);
+	__lwp_threadqueue_enqueue(&sema->wait_queue,LWP_THREADQ_NOTIMEOUT);
 	__lwp_thread_dispatchenable();
 }
 
diff --git a/libogc/lwp_threadq.c b/libogc/lwp_threadq.c
@@ -69,7 +69,7 @@ static void __lwp_threadqueue_timeout(void *usr_data)
 	if(thequeue->sync_state!=LWP_THREADQ_SYNCHRONIZED && __lwp_thread_isexec(thethread)) {
 		if(thequeue->sync_state!=LWP_THREADQ_SATISFIED) thequeue->sync_state = LWP_THREADQ_TIMEOUT;
 	} else {
-		thethread->wait.ret_code = thethread->wait.queue->timeout_state;
+		thethread->wait.ret_code = thethread->wait.queue->timeout_status;
 		__lwp_threadqueue_extract(thethread->wait.queue,thethread);
 	}
 	__lwp_thread_dispatchunnest();
@@ -113,7 +113,7 @@ void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,s64
 			_CPU_ISR_Restore(level);
 			return;
 		case LWP_THREADQ_TIMEOUT:
-			thethread->wait.ret_code = thethread->wait.queue->timeout_state;
+			thethread->wait.ret_code = thethread->wait.queue->timeout_status;
 			_CPU_ISR_Restore(level);
 			break;
 		case LWP_THREADQ_SATISFIED:
@@ -275,7 +275,7 @@ void __lwp_threadqueue_enqueuepriority(lwp_thrqueue *queue,lwp_cntrl *thethread,
 		case LWP_THREADQ_NOTHINGHAPPEND:
 			break;
 		case LWP_THREADQ_TIMEOUT:
-			thethread->wait.ret_code = thethread->wait.queue->timeout_state;
+			thethread->wait.ret_code = thethread->wait.queue->timeout_status;
 			_CPU_ISR_Restore(level);
 			break;
 		case LWP_THREADQ_SATISFIED:
@@ -358,16 +358,16 @@ lwp_cntrl* __lwp_threadqueue_dequeuepriority(lwp_thrqueue *queue)
 	return ret;
 }
 
-void __lwp_threadqueue_init(lwp_thrqueue *queue,u32 mode,u32 state,u32 timeout_state)
+void __lwp_threadqueue_init(lwp_thrqueue *queue,u32 mode,u32 state,u32 timeout_status)
 {
 	u32 index;
 
 	queue->state = state;
 	queue->mode = mode;
-	queue->timeout_state = timeout_state;
+	queue->timeout_status = timeout_status;
 	queue->sync_state = LWP_THREADQ_SYNCHRONIZED;
 #ifdef _LWPTHRQ_DEBUG
-	printf("__lwp_threadqueue_init(%p,%08x,%d,%d)\n",queue,state,timeout_state,mode);
+	printf("__lwp_threadqueue_init(%p,%08x,%d,%d)\n",queue,state,timeout_status,mode);
 #endif
 	switch(mode) {
 		case LWP_THREADQ_MODEFIFO:
diff --git a/libogc/message.c b/libogc/message.c
diff --git a/libogc/mutex.c b/libogc/mutex.c
diff --git a/libogc/semaphore.c b/libogc/semaphore.c
diff --git a/libogc/timesupp.c b/libogc/timesupp.c

Original file line number	Diff line number	Diff line change
`@@ -357,7 +357,7 @@ void LWP_ExitThread(void *value_ptr)`
`357`	`357`	`__builtin_unreachable();`
`358`	`358`	`}`
`359`	`359`
`360`		`-static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 timeout)`
	`360`	`+static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u32 wait_status,s64 timeout)`
`361`	`361`	`{`
`362`	`362`	`u32 level;`
`363`	`363`	`lwp_cntrl exec,lwp_thread;`
`@@ -382,9 +382,9 @@ static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 t`
`382`	`382`	`return 0;`
`383`	`383`	`}`
`384`	`384`
`385`		`- if(!block) {`
	`385`	`+ if(wait_status) {`
`386`	`386`	`__lwp_thread_dispatchenable();`
`387`		`- return EBUSY;`
	`387`	`+ return wait_status;`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`exec = _thr_executing;`
`@@ -402,25 +402,25 @@ static s32 __lwp_thread_joinsupp(lwp_t thethread,void **value_ptr,u8 block,s64 t`
`402`	`402`
`403`	`403`	`s32 LWP_JoinThread(lwp_t thethread,void **value_ptr)`
`404`	`404`	`{`
`405`		`- return __lwp_thread_joinsupp(thethread,value_ptr,TRUE,LWP_THREADQ_NOTIMEOUT);`
	`405`	`+ return __lwp_thread_joinsupp(thethread,value_ptr,0,LWP_THREADQ_NOTIMEOUT);`
`406`	`406`	`}`
`407`	`407`
`408`	`408`	`s32 LWP_TimedJoinThread(lwp_t thethread,void *value_ptr,const struct timespec reltime)`
`409`	`409`	`{`
	`410`	`+ u32 wait_status = 0;`
`410`	`411`	`s64 timeout = LWP_THREADQ_NOTIMEOUT;`
`411`		`- u8 block = TRUE;`
`412`	`412`
`413`	`413`	`if(reltime) {`
`414`	`414`	`if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;`
`415`	`415`	`timeout = __lwp_wd_calc_ticks(reltime);`
`416`		`- if(timeout<=0) block = FALSE;`
	`416`	`+ if(timeout<=0) wait_status = ETIMEDOUT;`
`417`	`417`	`}`
`418`		`- return __lwp_thread_joinsupp(thethread,value_ptr,block,timeout);`
	`418`	`+ return __lwp_thread_joinsupp(thethread,value_ptr,wait_status,timeout);`
`419`	`419`	`}`
`420`	`420`
`421`	`421`	`s32 LWP_TryJoinThread(lwp_t thethread,void **value_ptr)`
`422`	`422`	`{`
`423`		`- return __lwp_thread_joinsupp(thethread,value_ptr,FALSE,LWP_THREADQ_NOTIMEOUT);`
	`423`	`+ return __lwp_thread_joinsupp(thethread,value_ptr,EBUSY,LWP_THREADQ_NOTIMEOUT);`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`s32 LWP_DetachThread(lwp_t thethread)`
Original file line number	Diff line number	Diff line change
`@@ -91,14 +91,14 @@ static __inline__ void __lwpmq_msg_prepend(mq_cntrl mqueue,mq_buffercntrl msg)`
`91`	`91`	`__lwp_queue_prepend(&mqueue->pending_msgs,&msg->node);`
`92`	`92`	`}`
`93`	`93`
`94`		`-static __inline__ u32 __lwpmq_send(mq_cntrl mqueue,u32 id,void buffer,u32 size,u32 wait,s64 timeout)`
	`94`	`+static __inline__ u32 __lwpmq_send(mq_cntrl mqueue,u32 id,void buffer,u32 size,u32 wait_status,s64 timeout)`
`95`	`95`	`{`
`96`		`- return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait,timeout);`
	`96`	`+ return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait_status,timeout);`
`97`	`97`	`}`
`98`	`98`
`99`		`-static __inline__ u32 __lwpmq_urgent(mq_cntrl mqueue,void buffer,u32 size,u32 id,u32 wait,s64 timeout)`
	`99`	`+static __inline__ u32 __lwpmq_urgent(mq_cntrl mqueue,void buffer,u32 size,u32 id,u32 wait_status,s64 timeout)`
`100`	`100`	`{`
`101`		`- return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait,timeout);`
	`101`	`+ return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait_status,timeout);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`static __inline__ mq_buffercntrl* __lwpmq_get_pendingmsg(mq_cntrl *mqueue)`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ u32 __lwp_sema_surrender(lwp_sema *sema,u32 id)`
`80`	`80`	`return ret;`
`81`	`81`	`}`
`82`	`82`
`83`		`-u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)`
	`83`	`+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait_status,s64 timeout)`
`84`	`84`	`{`
`85`	`85`	`u32 level;`
`86`	`86`	`lwp_cntrl *exec;`
`@@ -95,10 +95,10 @@ u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)`
`95`	`95`	`return LWP_SEMA_SUCCESSFUL;`
`96`	`96`	`}`
`97`	`97`
`98`		`- if(!wait) {`
	`98`	`+ if(wait_status) {`
`99`	`99`	`_CPU_ISR_Restore(level);`
`100`		`- exec->wait.ret_code = LWP_SEMA_UNSATISFIED_NOWAIT;`
`101`		`- return LWP_SEMA_UNSATISFIED_NOWAIT;`
	`100`	`+ exec->wait.ret_code = wait_status;`
	`101`	`+ return wait_status;`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`__lwp_threadqueue_csenter(&sema->wait_queue);`