Handle negative time values

Extrems · Extrems · commit 546f1500c371 · 2025-06-06T14:17:16.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,u64 timeout);
-u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait,u64 timeout);
+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_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_mutex.h b/gc/ogc/lwp_mutex.h
@@ -96,7 +96,7 @@ typedef struct _lwpmutex {
 
 void __lwp_mutex_initialize(lwp_mutex *mutex,lwp_mutex_attr *attrs,u32 init_lock);
 u32 __lwp_mutex_surrender(lwp_mutex *mutex);
-void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,u64 timeout);
+void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,s64 timeout);
 void __lwp_mutex_flush(lwp_mutex *mutex,u32 status);
 
 #ifdef LIBOGC_INTERNAL
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,u64 timeout);
+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,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
@@ -67,13 +67,13 @@ extern "C" {
 
 lwp_cntrl* __lwp_threadqueue_firstfifo(lwp_thrqueue *queue);
 lwp_cntrl* __lwp_threadqueue_firstpriority(lwp_thrqueue *queue);
-void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,u64 timeout);
+void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,s64 timeout);
 lwp_cntrl* __lwp_threadqueue_dequeuefifo(lwp_thrqueue *queue);
-void __lwp_threadqueue_enqueuepriority(lwp_thrqueue *queue,lwp_cntrl *thethread,u64 timeout);
+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);
 lwp_cntrl* __lwp_threadqueue_first(lwp_thrqueue *queue);
-void __lwp_threadqueue_enqueue(lwp_thrqueue *queue,u64 timeout);
+void __lwp_threadqueue_enqueue(lwp_thrqueue *queue,s64 timeout);
 lwp_cntrl* __lwp_threadqueue_dequeue(lwp_thrqueue *queue);
 void __lwp_threadqueue_flush(lwp_thrqueue *queue,u32 status);
 void __lwp_threadqueue_extract(lwp_thrqueue *queue,lwp_cntrl *thethread);
diff --git a/libogc/cond.c b/libogc/cond.c
@@ -109,20 +109,19 @@ static cond_st* __lwp_cond_allocate(void)
 	return NULL;
 }
 
-static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,u64 timeout,u8 timedout)
+static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,s64 timeout,u8 timedout)
 {
 	u32 status,mstatus,level;
 	cond_st *thecond;
 
 	thecond = __lwp_cond_open(cond);
 	if(!thecond) return -1;
-		
+
 	if(thecond->lock!=LWP_MUTEX_NULL && thecond->lock!=mutex) {
 		__lwp_thread_dispatchenable();
 		return EINVAL;
 	}
 
-
 	LWP_MutexUnlock(mutex);
 	if(!timedout) {
 		thecond->lock = mutex;
@@ -201,13 +200,13 @@ s32 LWP_CondBroadcast(cond_t cond)
 
 s32 LWP_CondTimedWait(cond_t cond,mutex_t mutex,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
-	bool timedout = FALSE;
+	s64 timeout = LWP_THREADQ_NOTIMEOUT;
+	u8 timedout = FALSE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;
-		if(reltime->tv_sec<0) timedout = TRUE;
 		timeout = __lwp_wd_calc_ticks(reltime);
+		if(timeout<=0) timedout = TRUE;
 	}
 	return __lwp_cond_waitsupp(cond,mutex,timeout,timedout);
 }
diff --git a/libogc/lwp.c b/libogc/lwp.c
@@ -412,7 +412,7 @@ void LWP_CloseQueue(lwpq_t thequeue)
 	return;
 }
 
-static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)
+static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,s64 timeout,u8 timedout)
 {
 	u32 level;
 	tqueue_st *tq;
@@ -426,6 +426,12 @@ static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)
 		return EDEADLK;
 	}
 
+	if(timedout) {
+		__lwp_thread_yield();
+		__lwp_thread_dispatchenable();
+		return ETIMEDOUT;
+	}
+
 	exec = _thr_executing;
 	_CPU_ISR_Disable(level);
 	__lwp_threadqueue_csenter(&tq->tqueue);
@@ -442,18 +448,20 @@ static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)
 
 s32 LWP_ThreadSleep(lwpq_t thequeue)
 {
-	return __lwp_tqueue_sleepsupp(thequeue,LWP_THREADQ_NOTIMEOUT);
+	return __lwp_tqueue_sleepsupp(thequeue,LWP_THREADQ_NOTIMEOUT,FALSE);
 }
 
 s32 LWP_ThreadTimedSleep(lwpq_t thequeue,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	s64 timeout = LWP_THREADQ_NOTIMEOUT;
+	u8 timedout = FALSE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;
 		timeout = __lwp_wd_calc_ticks(reltime);
+		if(timeout<=0) timedout = TRUE;
 	}
-	return __lwp_tqueue_sleepsupp(thequeue,timeout);
+	return __lwp_tqueue_sleepsupp(thequeue,timeout,timedout);
 }
 
 void LWP_ThreadBroadcast(lwpq_t thequeue)
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,u64 timeout)
+u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,s64 timeout)
 {
 	u32 level;
 	mq_buffercntrl *msg;
@@ -179,7 +179,7 @@ u32 __lwpmq_seize(mq_cntrl *mqueue,u32 id,void *buffer,u32 *size,u32 wait,u64 ti
 	return LWP_MQ_STATUS_SUCCESSFUL;
 }
 
-u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait,u64 timeout)
+u32 __lwpmq_submit(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 type,u32 wait,s64 timeout)
 {
 	u32 level;
 	lwp_cntrl *thread;
diff --git a/libogc/lwp_messages.inl b/libogc/lwp_messages.inl
@@ -91,12 +91,12 @@ 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,u32 timeout)
+static __inline__ u32 __lwpmq_send(mq_cntrl *mqueue,u32 id,void *buffer,u32 size,u32 wait,s64 timeout)
 {
 	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait,timeout);
 }
 
-static __inline__ u32 __lwpmq_urgent(mq_cntrl *mqueue,void *buffer,u32 size,u32 id,u32 wait,u32 timeout)
+static __inline__ u32 __lwpmq_urgent(mq_cntrl *mqueue,void *buffer,u32 size,u32 id,u32 wait,s64 timeout)
 {
 	return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait,timeout);
 }
diff --git a/libogc/lwp_mutex.c b/libogc/lwp_mutex.c
@@ -120,7 +120,7 @@ u32 __lwp_mutex_surrender(lwp_mutex *mutex)
 	return LWP_MUTEX_SUCCESSFUL;
 }
 
-void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,u64 timeout)
+void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,s64 timeout)
 {
 	lwp_cntrl *exec;
 
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,u64 timeout)
+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)
 {
 	u32 level;
 	lwp_cntrl *exec;
diff --git a/libogc/lwp_threadq.c b/libogc/lwp_threadq.c
@@ -94,7 +94,7 @@ lwp_cntrl* __lwp_threadqueue_firstpriority(lwp_thrqueue *queue)
 	return NULL;
 }
 
-void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,u64 timeout)
+void __lwp_threadqueue_enqueuefifo(lwp_thrqueue *queue,lwp_cntrl *thethread,s64 timeout)
 {
 	u32 level,sync_state;
 
@@ -163,7 +163,7 @@ lwp_cntrl* __lwp_threadqueue_dequeuefifo(lwp_thrqueue *queue)
 	return NULL;
 }
 
-void __lwp_threadqueue_enqueuepriority(lwp_thrqueue *queue,lwp_cntrl *thethread,u64 timeout)
+void __lwp_threadqueue_enqueuepriority(lwp_thrqueue *queue,lwp_cntrl *thethread,s64 timeout)
 {
 	u32 level,search_prio,header_idx,prio,block_state,sync_state;
 	lwp_cntrl *search_thread;
@@ -399,7 +399,7 @@ lwp_cntrl* __lwp_threadqueue_first(lwp_thrqueue *queue)
 	return ret;
 }
 
-void __lwp_threadqueue_enqueue(lwp_thrqueue *queue,u64 timeout)
+void __lwp_threadqueue_enqueue(lwp_thrqueue *queue,s64 timeout)
 {
 	lwp_cntrl *thethread;
 
diff --git a/libogc/lwp_watchdog.inl b/libogc/lwp_watchdog.inl
@@ -104,9 +104,9 @@ static __inline__ bool __lwp_wd_timespec_valid(const struct timespec *time)
 	return true;
 }
 
-static __inline__ u64 __lwp_wd_calc_ticks(const struct timespec *time)
+static __inline__ s64 __lwp_wd_calc_ticks(const struct timespec *time)
 {
-	u64 ticks;
+	s64 ticks;
 
 	ticks = secs_to_ticks(time->tv_sec);
 	ticks += nanosecs_to_ticks(time->tv_nsec);
diff --git a/libogc/message.c b/libogc/message.c
@@ -107,7 +107,7 @@ static mqbox_st* __lwp_mqbox_allocate(void)
 	return NULL;
 }
 
-static BOOL __lwp_mqbox_sendsupp(mqbox_t mqbox,mqmsg_t msg,u32 type,u32 wait,u64 timeout)
+static BOOL __lwp_mqbox_sendsupp(mqbox_t mqbox,mqmsg_t msg,u32 type,u32 wait,s64 timeout)
 {
 	u32 status,size = sizeof(mqmsg_t);
 	mqbox_st *mbox;
@@ -123,7 +123,7 @@ static BOOL __lwp_mqbox_sendsupp(mqbox_t mqbox,mqmsg_t msg,u32 type,u32 wait,u64
 	return (status==LWP_MQ_STATUS_SUCCESSFUL);
 }
 
-static BOOL __lwp_mqbox_recvsupp(mqbox_t mqbox,mqmsg_t *msg,u32 wait,u64 timeout)
+static BOOL __lwp_mqbox_recvsupp(mqbox_t mqbox,mqmsg_t *msg,u32 wait,s64 timeout)
 {
 	u32 status,size;
 	mqbox_st *mbox;
@@ -182,13 +182,15 @@ BOOL MQ_Send(mqbox_t mqbox,mqmsg_t msg,u32 flags)
 
 BOOL MQ_TimedSend(mqbox_t mqbox,mqmsg_t msg,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	s64 timeout = LWP_THREADQ_NOTIMEOUT;
+	u32 wait = TRUE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return FALSE;
 		timeout = __lwp_wd_calc_ticks(reltime);
+		if(timeout<=0) wait = FALSE;
 	}
-	return __lwp_mqbox_sendsupp(mqbox,msg,LWP_MQ_SEND_REQUEST,TRUE,timeout);
+	return __lwp_mqbox_sendsupp(mqbox,msg,LWP_MQ_SEND_REQUEST,wait,timeout);
 }
 
 BOOL MQ_Jam(mqbox_t mqbox,mqmsg_t msg,u32 flags)
@@ -200,13 +202,15 @@ BOOL MQ_Jam(mqbox_t mqbox,mqmsg_t msg,u32 flags)
 
 BOOL MQ_TimedJam(mqbox_t mqbox,mqmsg_t msg,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	s64 timeout = LWP_THREADQ_NOTIMEOUT;
+	u32 wait = TRUE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return FALSE;
 		timeout = __lwp_wd_calc_ticks(reltime);
+		if(timeout<=0) wait = FALSE;
 	}
-	return __lwp_mqbox_sendsupp(mqbox,msg,LWP_MQ_SEND_URGENT,TRUE,timeout);
+	return __lwp_mqbox_sendsupp(mqbox,msg,LWP_MQ_SEND_URGENT,wait,timeout);
 }
 
 BOOL MQ_Receive(mqbox_t mqbox,mqmsg_t *msg,u32 flags)
@@ -218,11 +222,13 @@ BOOL MQ_Receive(mqbox_t mqbox,mqmsg_t *msg,u32 flags)
 
 BOOL MQ_TimedReceive(mqbox_t mqbox,mqmsg_t *msg,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	s64 timeout = LWP_THREADQ_NOTIMEOUT;
+	u32 wait = TRUE;
 
 	if(reltime) {
 		if(!__lwp_wd_timespec_valid(reltime)) return FALSE;
 		timeout = __lwp_wd_calc_ticks(reltime);
+		if(timeout<=0) wait = FALSE;
 	}
-	return __lwp_mqbox_recvsupp(mqbox,msg,TRUE,timeout);
+	return __lwp_mqbox_recvsupp(mqbox,msg,wait,timeout);
 }
diff --git a/libogc/mutex.c b/libogc/mutex.c
@@ -77,7 +77,7 @@ typedef struct _mutex_st
 
 lwp_objinfo _lwp_mutex_objects;
 
-static s32 __lwp_mutex_locksupp(mutex_t lock,u64 timeout,u8 block)
+static s32 __lwp_mutex_locksupp(mutex_t lock,s64 timeout,u8 block)
 {
 	u32 level;
 	mutex_st *p;
@@ -185,13 +185,15 @@ s32 LWP_MutexLock(mutex_t mutex)
 
 s32 LWP_MutexTimedLock(mutex_t mutex,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	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;
 	}
-	return __lwp_mutex_locksupp(mutex,timeout,TRUE);
+	return __lwp_mutex_locksupp(mutex,timeout,block);
 }
 
 s32 LWP_MutexTryLock(mutex_t mutex)
diff --git a/libogc/semaphore.c b/libogc/semaphore.c
@@ -108,7 +108,7 @@ static sema_st* __lwp_sema_allocate(void)
 	return NULL;
 }
 
-static s32 __lwp_sema_waitsupp(sem_t sem,u8 block,u64 timeout)
+static s32 __lwp_sema_waitsupp(sem_t sem,u8 block,s64 timeout)
 {
 	sema_st *lwp_sem;
 
@@ -159,13 +159,15 @@ s32 LWP_SemWait(sem_t sem)
 
 s32 LWP_SemTimedWait(sem_t sem,const struct timespec *reltime)
 {
-	u64 timeout = LWP_THREADQ_NOTIMEOUT;
+	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;
 	}
-	return __lwp_sema_waitsupp(sem,TRUE,timeout);
+	return __lwp_sema_waitsupp(sem,block,timeout);
 }
 
 s32 LWP_SemTryWait(sem_t sem)
diff --git a/libogc/timesupp.c b/libogc/timesupp.c
@@ -143,20 +143,25 @@ void udelay(u32 usec)
 
 int __syscall_nanosleep(const struct timespec *tb, struct timespec *rem)
 {
-	u64 timeout;
+	s64 timeout;
 
 	if (!__lwp_wd_timespec_valid(tb)) {
 		errno = EINVAL;
 		return -1;
 	}
 
-	__lwp_thread_dispatchdisable();
-
 	timeout = __lwp_wd_calc_ticks(tb);
+	if (timeout <= 0) {
+		__lwp_thread_dispatchdisable();
+		__lwp_thread_yield();
+		__lwp_thread_dispatchenable();
+		return 0;
+	}
+
+	__lwp_thread_dispatchdisable();
 	__lwp_thread_setstate(_thr_executing,LWP_STATES_DELAYING|LWP_STATES_INTERRUPTIBLE_BY_SIGNAL);
 	__lwp_wd_initialize(&_thr_executing->timer,__lwp_thread_delayended,_thr_executing->object.id,_thr_executing);
 	__lwp_wd_insert_ticks(&_thr_executing->timer,timeout);
-
 	__lwp_thread_dispatchenable();
 	return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -109,20 +109,19 @@ static cond_st* __lwp_cond_allocate(void)`
`109`	`109`	`return NULL;`
`110`	`110`	`}`
`111`	`111`
`112`		`-static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,u64 timeout,u8 timedout)`
	`112`	`+static s32 __lwp_cond_waitsupp(cond_t cond,mutex_t mutex,s64 timeout,u8 timedout)`
`113`	`113`	`{`
`114`	`114`	`u32 status,mstatus,level;`
`115`	`115`	`cond_st *thecond;`
`116`	`116`
`117`	`117`	`thecond = __lwp_cond_open(cond);`
`118`	`118`	`if(!thecond) return -1;`
`119`		`-`
	`119`	`+`
`120`	`120`	`if(thecond->lock!=LWP_MUTEX_NULL && thecond->lock!=mutex) {`
`121`	`121`	`__lwp_thread_dispatchenable();`
`122`	`122`	`return EINVAL;`
`123`	`123`	`}`
`124`	`124`
`125`		`-`
`126`	`125`	`LWP_MutexUnlock(mutex);`
`127`	`126`	`if(!timedout) {`
`128`	`127`	`thecond->lock = mutex;`
`@@ -201,13 +200,13 @@ s32 LWP_CondBroadcast(cond_t cond)`
`201`	`200`
`202`	`201`	`s32 LWP_CondTimedWait(cond_t cond,mutex_t mutex,const struct timespec *reltime)`
`203`	`202`	`{`
`204`		`- u64 timeout = LWP_THREADQ_NOTIMEOUT;`
`205`		`- bool timedout = FALSE;`
	`203`	`+ s64 timeout = LWP_THREADQ_NOTIMEOUT;`
	`204`	`+ u8 timedout = FALSE;`
`206`	`205`
`207`	`206`	`if(reltime) {`
`208`	`207`	`if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;`
`209`		`- if(reltime->tv_sec<0) timedout = TRUE;`
`210`	`208`	`timeout = __lwp_wd_calc_ticks(reltime);`
	`209`	`+ if(timeout<=0) timedout = TRUE;`
`211`	`210`	`}`
`212`	`211`	`return __lwp_cond_waitsupp(cond,mutex,timeout,timedout);`
`213`	`212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ void LWP_CloseQueue(lwpq_t thequeue)`
`412`	`412`	`return;`
`413`	`413`	`}`
`414`	`414`
`415`		`-static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)`
	`415`	`+static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,s64 timeout,u8 timedout)`
`416`	`416`	`{`
`417`	`417`	`u32 level;`
`418`	`418`	`tqueue_st *tq;`
`@@ -426,6 +426,12 @@ static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)`
`426`	`426`	`return EDEADLK;`
`427`	`427`	`}`
`428`	`428`
	`429`	`+ if(timedout) {`
	`430`	`+ __lwp_thread_yield();`
	`431`	`+ __lwp_thread_dispatchenable();`
	`432`	`+ return ETIMEDOUT;`
	`433`	`+ }`
	`434`	`+`
`429`	`435`	`exec = _thr_executing;`
`430`	`436`	`_CPU_ISR_Disable(level);`
`431`	`437`	`__lwp_threadqueue_csenter(&tq->tqueue);`
`@@ -442,18 +448,20 @@ static s32 __lwp_tqueue_sleepsupp(lwpq_t thequeue,u64 timeout)`
`442`	`448`
`443`	`449`	`s32 LWP_ThreadSleep(lwpq_t thequeue)`
`444`	`450`	`{`
`445`		`- return __lwp_tqueue_sleepsupp(thequeue,LWP_THREADQ_NOTIMEOUT);`
	`451`	`+ return __lwp_tqueue_sleepsupp(thequeue,LWP_THREADQ_NOTIMEOUT,FALSE);`
`446`	`452`	`}`
`447`	`453`
`448`	`454`	`s32 LWP_ThreadTimedSleep(lwpq_t thequeue,const struct timespec *reltime)`
`449`	`455`	`{`
`450`		`- u64 timeout = LWP_THREADQ_NOTIMEOUT;`
	`456`	`+ s64 timeout = LWP_THREADQ_NOTIMEOUT;`
	`457`	`+ u8 timedout = FALSE;`
`451`	`458`
`452`	`459`	`if(reltime) {`
`453`	`460`	`if(!__lwp_wd_timespec_valid(reltime)) return EINVAL;`
`454`	`461`	`timeout = __lwp_wd_calc_ticks(reltime);`
	`462`	`+ if(timeout<=0) timedout = TRUE;`
`455`	`463`	`}`
`456`		`- return __lwp_tqueue_sleepsupp(thequeue,timeout);`
	`464`	`+ return __lwp_tqueue_sleepsupp(thequeue,timeout,timedout);`
`457`	`465`	`}`
`458`	`466`
`459`	`467`	`void LWP_ThreadBroadcast(lwpq_t thequeue)`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ u32 __lwpmq_initialize(mq_cntrl mqueue,mq_attr attrs,u32 max_pendingmsgs,u32 m`
`126`	`126`	`return 1;`
`127`	`127`	`}`
`128`	`128`
`129`		`-u32 __lwpmq_seize(mq_cntrl mqueue,u32 id,void buffer,u32 *size,u32 wait,u64 timeout)`
	`129`	`+u32 __lwpmq_seize(mq_cntrl mqueue,u32 id,void buffer,u32 *size,u32 wait,s64 timeout)`
`130`	`130`	`{`
`131`	`131`	`u32 level;`
`132`	`132`	`mq_buffercntrl *msg;`
`@@ -179,7 +179,7 @@ u32 __lwpmq_seize(mq_cntrl mqueue,u32 id,void buffer,u32 *size,u32 wait,u64 ti`
`179`	`179`	`return LWP_MQ_STATUS_SUCCESSFUL;`
`180`	`180`	`}`
`181`	`181`
`182`		`-u32 __lwpmq_submit(mq_cntrl mqueue,u32 id,void buffer,u32 size,u32 type,u32 wait,u64 timeout)`
	`182`	`+u32 __lwpmq_submit(mq_cntrl mqueue,u32 id,void buffer,u32 size,u32 type,u32 wait,s64 timeout)`
`183`	`183`	`{`
`184`	`184`	`u32 level;`
`185`	`185`	`lwp_cntrl *thread;`
Original file line number	Diff line number	Diff line change
`@@ -91,12 +91,12 @@ 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,u32 timeout)`
	`94`	`+static __inline__ u32 __lwpmq_send(mq_cntrl mqueue,u32 id,void buffer,u32 size,u32 wait,s64 timeout)`
`95`	`95`	`{`
`96`	`96`	`return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_REQUEST,wait,timeout);`
`97`	`97`	`}`
`98`	`98`
`99`		`-static __inline__ u32 __lwpmq_urgent(mq_cntrl mqueue,void buffer,u32 size,u32 id,u32 wait,u32 timeout)`
	`99`	`+static __inline__ u32 __lwpmq_urgent(mq_cntrl mqueue,void buffer,u32 size,u32 id,u32 wait,s64 timeout)`
`100`	`100`	`{`
`101`	`101`	`return __lwpmq_submit(mqueue,id,buffer,size,LWP_MQ_SEND_URGENT,wait,timeout);`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ u32 __lwp_mutex_surrender(lwp_mutex *mutex)`
`120`	`120`	`return LWP_MUTEX_SUCCESSFUL;`
`121`	`121`	`}`
`122`	`122`
`123`		`-void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,u64 timeout)`
	`123`	`+void __lwp_mutex_seize_irq_blocking(lwp_mutex *mutex,s64 timeout)`
`124`	`124`	`{`
`125`	`125`	`lwp_cntrl *exec;`
`126`	`126`
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,u64 timeout)`
	`83`	`+u32 __lwp_sema_seize(lwp_sema *sema,u32 id,u32 wait,s64 timeout)`
`84`	`84`	`{`
`85`	`85`	`u32 level;`
`86`	`86`	`lwp_cntrl *exec;`