Update.

1998-06-30 11:47  Ulrich Drepper  <drepper@cygnus.com>

	* include/aio.h: New file.
	* posix/Makefile (distribute): Add bits/pthreadtypes.h.
	(tests): Build and run annexc program.
	* posix/annexc.c: New file.
	* posix/bits/posix1_lim.h: Add several more _POSIX_* limits.
	* rt/aio.h: Remove __need_timespec_t.  We can include the whole time.h.
	* rt/aio_misc.c: Include limits.h.
	* rt/aio_notify.c: Include errno.h.
	* sysdeps/unix/sysv/linux/alpha/bits/types.h: Include pthreadtypes.h.
	Define size_t.
	* sysdeps/unix/sysv/linux/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/mips/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/sparc/sparc64/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/bits/errno.h: Define ENOTSUP though the
	kernel doesn't do this.
	* sysdeps/unix/sysv/linux/bits/fcntl.h: Define O_LARGEFILE only if
	__USE_LARGEFILE64 is defined.
	* sysdeps/unix/sysv/linux/bits/pthreadtypes.h: New file.  Empty.
	* sysdeps/unix/sysv/linux/bits/sched.h: Define __sched_param struct
	if requested.
	* sysdeps/unix/sysv/linux/bits/siginifo.h: Protect non-standard names.

	* stdlib/isomac.c: Avoid include_next warning.

linuxthreads/attr.c

@@ -14,6 +14,7 @@
 
 /* Handling of thread attributes */
 
+#include <errno.h>
 #include <unistd.h>
 #include <sys/param.h>
 #include "pthread.h"
@@ -79,14 +80,14 @@ int pthread_attr_setschedparam(pthread_attr_t *attr,
 
   if (param->sched_priority < min_prio || param->sched_priority > max_prio)
     return EINVAL;
-  attr->schedparam = *param;
+  memcpy (&attr->schedparam, param, sizeof (struct sched_param));
   return 0;
 }
 
 int pthread_attr_getschedparam(const pthread_attr_t *attr,
                                struct sched_param *param)
 {
-  *param = attr->schedparam;
+  memcpy (param, &attr->schedparam, sizeof (struct sched_param));
   return 0;
 }
 

linuxthreads/internals.h

@@ -17,6 +17,7 @@
 /* Includes */
 
 #include <bits/libc-lock.h> /* for _LIBC_TSD_KEY_N */
+#include <limits.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <unistd.h>

linuxthreads/manager.c

@@ -303,7 +303,8 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
     switch(attr->inheritsched) {
     case PTHREAD_EXPLICIT_SCHED:
       new_thread->p_start_args.schedpolicy = attr->schedpolicy;
-      new_thread->p_start_args.schedparam = attr->schedparam;
+      memcpy (&new_thread->p_start_args.schedparam, &attr->schedparam,
+	      sizeof (struct sched_param));
       break;
     case PTHREAD_INHERIT_SCHED:
       /* schedpolicy doesn't need to be set, only get priority */

linuxthreads/ptfork.c

@@ -14,6 +14,7 @@
 
 /* The "atfork" stuff */
 
+#include <errno.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <unistd.h>

linuxthreads/pthread.c

@@ -14,6 +14,7 @@
 
 /* Thread creation, initialization, and basic low-level routines */
 
+#include <errno.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>

linuxthreads/semaphore.c

@@ -14,6 +14,7 @@
 
 /* Semaphores a la POSIX 1003.1b */
 
+#include <errno.h>
 #include "pthread.h"
 #include "semaphore.h"
 #include "internals.h"

linuxthreads/specific.c

@@ -14,6 +14,7 @@
 
 /* Thread-specific data */
 
+#include <errno.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include "pthread.h"

linuxthreads/spinlock.c

@@ -14,6 +14,7 @@
 
 /* Internal locks */
 
+#include <errno.h>
 #include <sched.h>
 #include <time.h>
 #include "pthread.h"

linuxthreads/sysdeps/pthread/bits/pthreadtypes.h

@@ -0,0 +1,119 @@
+/* Linuxthreads - a simple clone()-based implementation of Posix        */
+/* threads for Linux.                                                   */
+/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
+/*                                                                      */
+/* This program is free software; you can redistribute it and/or        */
+/* modify it under the terms of the GNU Library General Public License  */
+/* as published by the Free Software Foundation; either version 2       */
+/* of the License, or (at your option) any later version.               */
+/*                                                                      */
+/* This program is distributed in the hope that it will be useful,      */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
+/* GNU Library General Public License for more details.                 */
+
+#if !defined _BITS_TYPES_H && !defined _PTHREAD_H
+# error "Never include <bits/pthreadtypes.h> directly; use <sys/types.h> instead."
+#endif
+
+#ifndef _BITS_PTHREADTYPES_H
+#define _BITS_PTHREADTYPES_H	1
+
+#define __need_schedparam
+#include <bits/sched.h>
+
+/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
+struct _pthread_fastlock
+{
+  long int status;              /* "Free" or "taken" or head of waiting list */
+  int spinlock;                 /* For compare-and-swap emulation */
+};
+
+/* Thread descriptors */
+typedef struct _pthread_descr_struct *_pthread_descr;
+
+
+/* Attributes for threads.  */
+typedef struct
+{
+  int detachstate;
+  int schedpolicy;
+  struct __sched_param schedparam;
+  int inheritsched;
+  int scope;
+  size_t guardsize;
+  int stackaddr_set;
+  void *stackaddr;
+  size_t stacksize;
+} pthread_attr_t;
+
+
+/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
+typedef struct
+{
+  struct _pthread_fastlock c_lock; /* Protect against concurrent access */
+  _pthread_descr c_waiting;        /* Threads waiting on this condition */
+} pthread_cond_t;
+
+
+/* Attribute for conditionally variables.  */
+typedef struct
+{
+  int dummy;
+} pthread_condattr_t;
+
+/* Keys for thread-specific data */
+typedef unsigned int pthread_key_t;
+
+
+/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER).  */
+/* (The layout is unnatural to maintain binary compatibility
+    with earlier releases of LinuxThreads.) */
+typedef struct
+{
+  int m_reserved;               /* Reserved for future use */
+  int m_count;                  /* Depth of recursive locking */
+  _pthread_descr m_owner;       /* Owner thread (if recursive or errcheck) */
+  int m_kind;                   /* Mutex kind: fast, recursive or errcheck */
+  struct _pthread_fastlock m_lock; /* Underlying fast lock */
+} pthread_mutex_t;
+
+
+/* Attribute for mutex.  */
+typedef struct
+{
+  int mutexkind;
+} pthread_mutexattr_t;
+
+
+/* Once-only execution */
+typedef int pthread_once_t;
+
+
+#ifdef __USE_UNIX98
+/* Read-write locks.  */
+typedef struct
+{
+  struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
+  int rw_readers;               /* Number of readers */
+  _pthread_descr rw_writer;     /* Identity of writer, or NULL if none */
+  _pthread_descr rw_read_waiting; /* Threads waiting for reading */
+  _pthread_descr rw_write_waiting; /* Threads waiting for writing */
+  int rw_kind;                  /* Reader/Writer preference selection */
+  int rw_pshared;               /* Shared between processes or not */
+} pthread_rwlock_t;
+
+
+/* Attribute for read-write locks.  */
+typedef struct
+{
+  int lockkind;
+  int pshared;
+} pthread_rwlockattr_t;
+#endif
+
+
+/* Thread identifiers */
+typedef unsigned long int pthread_t;
+
+#endif	/* bits/pthreadtypes.h */

linuxthreads/sysdeps/pthread/pthread.h

@@ -17,85 +17,34 @@
 
 #include <features.h>
 
-#include <errno.h>
-#include <limits.h>
 #include <sched.h>
-#include <unistd.h>
+#include <time.h>
 
 #define __need_sigset_t
 #include <signal.h>
-#define __need_timespec
-#include <time.h>
-
-/* Linux has no ENOTSUP error code.  */
-#ifndef ENOTSUP
-#define ENOTSUP EOPNOTSUPP
-#endif
+#include <bits/pthreadtypes.h>
 
 
 __BEGIN_DECLS
 
-/*** Types ***/
-
-/* Thread identifiers */
-typedef unsigned long int pthread_t;
-
-/* Thread descriptors */
-typedef struct _pthread_descr_struct *_pthread_descr;
-
-/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
-struct _pthread_fastlock
-{
-  long int status;              /* "Free" or "taken" or head of waiting list */
-  int spinlock;                 /* For compare-and-swap emulation */
-};
-
-/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER).  */
-/* (The layout is unnatural to maintain binary compatibility
-    with earlier releases of LinuxThreads.) */
-
-typedef struct
-{
-  int m_reserved;               /* Reserved for future use */
-  int m_count;                  /* Depth of recursive locking */
-  _pthread_descr m_owner;       /* Owner thread (if recursive or errcheck) */
-  int m_kind;                   /* Mutex kind: fast, recursive or errcheck */
-  struct _pthread_fastlock m_lock; /* Underlying fast lock */
-} pthread_mutex_t;
+/* Initializers.  */
 
 #define PTHREAD_MUTEX_INITIALIZER \
   {0, 0, 0, PTHREAD_MUTEX_FAST_NP, {0, 0}}
-#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
+#ifdef __USE_GNU
+# define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
   {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}}
-
-/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
-typedef struct
-{
-  struct _pthread_fastlock c_lock; /* Protect against concurrent access */
-  _pthread_descr c_waiting;        /* Threads waiting on this condition */
-} pthread_cond_t;
+#endif
 
 #define PTHREAD_COND_INITIALIZER {{0, 0}, 0}
 
 #ifdef __USE_UNIX98
-/* Read-write locks.  */
-typedef struct
-{
-  struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
-  int rw_readers;               /* Number of readers */
-  _pthread_descr rw_writer;     /* Identity of writer, or NULL if none */
-  _pthread_descr rw_read_waiting; /* Threads waiting for reading */
-  _pthread_descr rw_write_waiting; /* Threads waiting for writing */
-  int rw_kind;                  /* Reader/Writer preference selection */
-  int rw_pshared;               /* Shared between processes or not */
-} pthread_rwlock_t;
-
 # define PTHREAD_RWLOCK_INITIALIZER \
   { {0, 0}, 0, NULL, NULL, NULL,					      \
     PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }
 #endif
 
-/* Attributes */
+/* Values for attributes.  */
 
 enum
 {
@@ -121,19 +70,6 @@ enum
 #define PTHREAD_SCOPE_PROCESS	PTHREAD_SCOPE_PROCESS
 };
 
-typedef struct
-{
-  int detachstate;
-  int schedpolicy;
-  struct sched_param schedparam;
-  int inheritsched;
-  int scope;
-  size_t guardsize;
-  int stackaddr_set;
-  void *stackaddr;
-  size_t stacksize;
-} pthread_attr_t;
-
 enum
 {
   PTHREAD_MUTEX_FAST_NP,
@@ -148,46 +84,22 @@ enum
 #endif
 };
 
-typedef struct
-{
-  int mutexkind;
-} pthread_mutexattr_t;
-
-typedef struct
-{
-  int dummy;
-} pthread_condattr_t;
-
-#ifdef __USE_UNIX98
 enum
 {
   PTHREAD_PROCESS_PRIVATE,
-# define PTHREAD_PROCESS_PRIVATE	PTHREAD_PROCESS_PRIVATE
+#define PTHREAD_PROCESS_PRIVATE	PTHREAD_PROCESS_PRIVATE
   PTHREAD_PROCESS_SHARED
-# define PTHREAD_PROCESS_SHARED		PTHREAD_PROCESS_SHARED
+#define PTHREAD_PROCESS_SHARED	PTHREAD_PROCESS_SHARED
 };
 
+#ifdef __USE_UNIX98
 enum
 {
   PTHREAD_RWLOCK_PREFER_READER_NP,
   PTHREAD_RWLOCK_PREFER_WRITER_NP,
   PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
 };
-
-typedef struct
-{
-  int lockkind;
-  int pshared;
-} pthread_rwlockattr_t;
-#endif
-
-/* Keys for thread-specific data */
-
-typedef unsigned int pthread_key_t;
-
-/* Once-only execution */
-
-typedef int pthread_once_t;
+#endif	/* Unix98 */
 
 #define PTHREAD_ONCE_INIT 0
 
@@ -592,7 +504,8 @@ extern void _pthread_cleanup_pop __P ((struct _pthread_cleanup_buffer *__buffer,
 /* Install a cleanup handler as pthread_cleanup_push does, but also
    saves the current cancellation type and set it to deferred cancellation. */
 
-#define pthread_cleanup_push_defer_np(routine,arg)			      \
+#ifdef __USE_GNU
+# define pthread_cleanup_push_defer_np(routine,arg)			      \
   { struct _pthread_cleanup_buffer _buffer;				      \
     _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
 
@@ -604,11 +517,12 @@ extern void _pthread_cleanup_push_defer __P ((struct _pthread_cleanup_buffer *__
    restores the cancellation type that was in effect when the matching
    pthread_cleanup_push_defer was called. */
 
-#define pthread_cleanup_pop_restore_np(execute)				      \
+# define pthread_cleanup_pop_restore_np(execute)			      \
   _pthread_cleanup_pop_restore (&_buffer, (execute)); }
 
 extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *__buffer,
 					       int __execute));
+#endif
 
 /* Functions for handling signals. */