Submitted by: John Birrell <cimaxp1!jb@werple.net.au>

Here are the diffs for libc_r to get it one step closer to P1003.1c
These make most of the thread/mutex/condvar structures opaque to the
user. There are three functions which have been renamed with _np
suffixes because they are extensions to P1003.1c (I did them for JAVA,
which needs to suspend/resume threads and also start threads suspended).

I've created a new header (pthread_np.h) for the non-POSIX stuff.

The egrep tags stuff in /usr/src/lib/libc_r/Makefile that I uncommented
doesn't work. I think its best to delete it. I don't think libc_r needs
tags anyway, 'cause most of the source is in libc which does have tags.

also:

Here's the first batch of man pages for the thread functions.
The diff to /usr/src/lib/libc_r/Makefile removes some stuff that was
inherited from /usr/src/lib/libc/Makefile that should only be done with
libc.

also:

I should have sent this diff with the pthread(3) man page.
It allows people to type

make -DWANT_LIBC_R world

to get libc_r built with the rest of the world. I put this in the
pthread(3) man page.  The default is still not to build libc_r.


also:
The diff attached adds a pthread(3) man page to /usr/src/share/man/man3.
The idea is that without libc_r installed, this man page will give people
enough info to know that they have to build libc_r.

1 files changed, 116 insertions, 27 deletions

diff --git a/lib/libc_r/uthread/uthread_nanosleep.c b/lib/libc_r/uthread/uthread_nanosleep.c
index e91ca5765113..58ade9888c35 100644
--- a/lib/libc_r/uthread/uthread_nanosleep.c
+++ b/lib/libc_r/uthread/uthread_nanosleep.c
@@ -31,6 +31,7 @@
  *
  */
 #include <stdio.h>
+#include <errno.h>
 #ifdef _THREAD_SAFE
 #include <pthread.h>
 #include "pthread_private.h"
@@ -38,50 +39,138 @@
 int
 nanosleep(struct timespec * time_to_sleep, struct timespec * time_remaining)
 {
+	int             ret = 0;
 	struct timespec current_time;
 	struct timespec current_time1;
+	struct timespec remaining_time;
 	struct timeval  tv;
 
-	/* Get the current time: */
-	gettimeofday(&tv, NULL);
-	TIMEVAL_TO_TIMESPEC(&tv, &current_time);
+	/* Check if the time to sleep is legal: */
+#if	defined(__FreeBSD__)
+	if (time_to_sleep == NULL || time_to_sleep->ts_nsec < 0 || time_to_sleep->ts_nsec > 1000000000) {
+#else
+	if (time_to_sleep == NULL || time_to_sleep->tv_nsec < 0 || time_to_sleep->tv_nsec > 1000000000) {
+#endif
+		/* Return an EINVAL error : */
+		errno = EINVAL;
+		ret = -1;
+	} else {
+		/* Get the current time: */
+		gettimeofday(&tv, NULL);
+		TIMEVAL_TO_TIMESPEC(&tv, &current_time);
 
-	/* Calculate the time for the current thread to wake up: */
-	_thread_run->wakeup_time.ts_sec = current_time.ts_sec + time_to_sleep->ts_sec;
-	_thread_run->wakeup_time.ts_nsec = current_time.ts_nsec + time_to_sleep->ts_nsec;
+		/* Calculate the time for the current thread to wake up: */
+#if	defined(__FreeBSD__)
+		_thread_run->wakeup_time.ts_sec = current_time.ts_sec + time_to_sleep->ts_sec;
+		_thread_run->wakeup_time.ts_nsec = current_time.ts_nsec + time_to_sleep->ts_nsec;
+#else
+		_thread_run->wakeup_time.tv_sec = current_time.tv_sec + time_to_sleep->tv_sec;
+		_thread_run->wakeup_time.tv_nsec = current_time.tv_nsec + time_to_sleep->tv_nsec;
+#endif
 
-	/* Check if the nanosecond field has overflowed: */
-	if (_thread_run->wakeup_time.ts_nsec >= 1000000000) {
-		/* Wrap the nanosecond field: */
-		_thread_run->wakeup_time.ts_sec += 1;
-		_thread_run->wakeup_time.ts_nsec -= 1000000000;
-	}
-	/* Reschedule the current thread to sleep: */
-	_thread_kern_sched_state(PS_SLEEP_WAIT, __FILE__, __LINE__);
+		/* Check if the nanosecond field has overflowed: */
+#if	defined(__FreeBSD__)
+		if (_thread_run->wakeup_time.ts_nsec >= 1000000000) {
+#else
+		if (_thread_run->wakeup_time.tv_nsec >= 1000000000) {
+#endif
+			/* Wrap the nanosecond field: */
+#if	defined(__FreeBSD__)
+			_thread_run->wakeup_time.ts_sec += 1;
+			_thread_run->wakeup_time.ts_nsec -= 1000000000;
+#else
+			_thread_run->wakeup_time.tv_sec += 1;
+			_thread_run->wakeup_time.tv_nsec -= 1000000000;
+#endif
+		}
+
+		/* Reschedule the current thread to sleep: */
+		_thread_kern_sched_state(PS_SLEEP_WAIT, __FILE__, __LINE__);
 
-	/* Check if the time remaining is to be returned: */
-	if (time_remaining != NULL) {
 		/* Get the current time: */
 		gettimeofday(&tv, NULL);
 		TIMEVAL_TO_TIMESPEC(&tv, &current_time1);
 
-		/* Return the actual time slept: */
-		time_remaining->ts_sec = time_to_sleep->ts_sec + current_time1.ts_sec - current_time.ts_sec;
-		time_remaining->ts_nsec = time_to_sleep->ts_nsec + current_time1.ts_nsec - current_time.ts_nsec;
+		/* Calculate the remaining time to sleep: */
+#if	defined(__FreeBSD__)
+		remaining_time.ts_sec = time_to_sleep->ts_sec + current_time.ts_sec - current_time1.ts_sec;
+		remaining_time.ts_nsec = time_to_sleep->ts_nsec + current_time.ts_nsec - current_time1.ts_nsec;
+#else
+		remaining_time.tv_sec = time_to_sleep->tv_sec + current_time.tv_sec - current_time1.tv_sec;
+		remaining_time.tv_nsec = time_to_sleep->tv_nsec + current_time.tv_nsec - current_time1.tv_nsec;
+#endif
 
 		/* Check if the nanosecond field has underflowed: */
-		if (time_remaining->ts_nsec < 0) {
+#if	defined(__FreeBSD__)
+		if (remaining_time.ts_nsec < 0) {
+#else
+		if (remaining_time.tv_nsec < 0) {
+#endif
 			/* Handle the underflow: */
-			time_remaining->ts_sec -= 1;
-			time_remaining->ts_nsec += 1000000000;
+#if	defined(__FreeBSD__)
+			remaining_time.ts_sec -= 1;
+			remaining_time.ts_nsec += 1000000000;
+#else
+			remaining_time.tv_sec -= 1;
+			remaining_time.tv_nsec += 1000000000;
+#endif
 		}
+
+		/* Check if the nanosecond field has overflowed: */
+#if	defined(__FreeBSD__)
+		if (remaining_time.ts_nsec >= 1000000000) {
+#else
+		if (remaining_time.tv_nsec >= 1000000000) {
+#endif
+			/* Handle the overflow: */
+#if	defined(__FreeBSD__)
+			remaining_time.ts_sec += 1;
+			remaining_time.ts_nsec -= 1000000000;
+#else
+			remaining_time.tv_sec += 1;
+			remaining_time.tv_nsec -= 1000000000;
+#endif
+		}
+
 		/* Check if the sleep was longer than the required time: */
-		if (time_remaining->ts_sec < 0) {
-			/* Reset the time teft: */
-			time_remaining->ts_sec = 0;
-			time_remaining->ts_nsec = 0;
+#if	defined(__FreeBSD__)
+		if (remaining_time.ts_sec < 0) {
+#else
+		if (remaining_time.tv_sec < 0) {
+#endif
+			/* Reset the time left: */
+#if	defined(__FreeBSD__)
+			remaining_time.ts_sec = 0;
+			remaining_time.ts_nsec = 0;
+#else
+			remaining_time.tv_sec = 0;
+			remaining_time.tv_nsec = 0;
+#endif
+		}
+
+		/* Check if the time remaining is to be returned: */
+		if (time_remaining != NULL) {
+			/* Return the actual time slept: */
+#if	defined(__FreeBSD__)
+			time_remaining->ts_sec = remaining_time.ts_sec;
+			time_remaining->ts_nsec = remaining_time.ts_nsec;
+#else
+			time_remaining->tv_sec = remaining_time.tv_sec;
+			time_remaining->tv_nsec = remaining_time.tv_nsec;
+#endif
+		}
+
+		/* Check if the entire sleep was not completed: */
+#if	defined(__FreeBSD__)
+		if (remaining_time.ts_nsec != 0 || remaining_time.ts_sec != 0) {
+#else
+		if (remaining_time.tv_nsec != 0 || remaining_time.tv_sec != 0) {
+#endif
+			/* Return an EINTR error : */
+			errno = EINTR;
+			ret = -1;
 		}
 	}
-	return (0);
+	return (ret);
 }
 #endif