diff --git a/minix/include/minix/mthread.h b/minix/include/minix/mthread.h
index bb4ba56d6..5a3d22b7b 100644
--- a/minix/include/minix/mthread.h
+++ b/minix/include/minix/mthread.h
@@ -73,7 +73,7 @@ typedef struct {
 
 __BEGIN_DECLS
 /* allocate.c */
-int mthread_create(mthread_thread_t *thread, mthread_attr_t *tattr, void
+int mthread_create(mthread_thread_t *thread, const mthread_attr_t *tattr, void
 	*(*proc)(void *), void *arg);
 int mthread_detach(mthread_thread_t thread);
 int mthread_equal(mthread_thread_t l, mthread_thread_t r);
@@ -84,11 +84,11 @@ mthread_thread_t mthread_self(void);
 
 /* attribute.c */
 int mthread_attr_destroy(mthread_attr_t *tattr);
-int mthread_attr_getdetachstate(mthread_attr_t *tattr, int
+int mthread_attr_getdetachstate(const mthread_attr_t *tattr, int
 	*detachstate);
-int mthread_attr_getstack(mthread_attr_t *tattr, void **stackaddr,
+int mthread_attr_getstack(const mthread_attr_t *tattr, void **stackaddr,
 	size_t *stacksize);
-int mthread_attr_getstacksize(mthread_attr_t *tattr, size_t *stacksize);
+int mthread_attr_getstacksize(const mthread_attr_t *tattr, size_t *stacksize);
 int mthread_attr_init(mthread_attr_t *tattr);
 int mthread_attr_setdetachstate(mthread_attr_t *tattr, int detachstate);
 int mthread_attr_setstack(mthread_attr_t *tattr, void *stackaddr, size_t
@@ -99,7 +99,7 @@ int mthread_attr_setstacksize(mthread_attr_t *tattr, size_t stacksize);
 /* condition.c */
 int mthread_cond_broadcast(mthread_cond_t *cond);
 int mthread_cond_destroy(mthread_cond_t *cond);
-int mthread_cond_init(mthread_cond_t *cond, mthread_condattr_t *cattr);
+int mthread_cond_init(mthread_cond_t *cond, const mthread_condattr_t *cattr);
 int mthread_cond_signal(mthread_cond_t *cond);
 int mthread_cond_wait(mthread_cond_t *cond, mthread_mutex_t *mutex);
 
@@ -118,7 +118,7 @@ void mthread_stacktraces(void);
 
 /* mutex.c */
 int mthread_mutex_destroy(mthread_mutex_t *mutex);
-int mthread_mutex_init(mthread_mutex_t *mutex, mthread_mutexattr_t
+int mthread_mutex_init(mthread_mutex_t *mutex, const mthread_mutexattr_t
 	*mattr);
 int mthread_mutex_lock(mthread_mutex_t *mutex);
 int mthread_mutex_trylock(mthread_mutex_t *mutex);
@@ -164,7 +164,7 @@ typedef void *pthread_rwlockattr_t;
 
 __BEGIN_DECLS
 /* allocate.c */
-int pthread_create(pthread_t *thread, pthread_attr_t *tattr, void
+int pthread_create(pthread_t *thread, const pthread_attr_t *tattr, void
 	*(*proc)(void *), void *arg);
 int pthread_detach(pthread_t thread);
 int pthread_equal(pthread_t l, pthread_t r);
@@ -175,11 +175,11 @@ pthread_t pthread_self(void);
 
 /* attribute.c */
 int pthread_attr_destroy(pthread_attr_t *tattr);
-int pthread_attr_getdetachstate(pthread_attr_t *tattr, int
+int pthread_attr_getdetachstate(const pthread_attr_t *tattr, int
 	*detachstate);
-int pthread_attr_getstack(pthread_attr_t *tattr, void **stackaddr,
+int pthread_attr_getstack(const pthread_attr_t *tattr, void **stackaddr,
 	size_t *stacksize);
-int pthread_attr_getstacksize(pthread_attr_t *tattr, size_t *stacksize);
+int pthread_attr_getstacksize(const pthread_attr_t *tattr, size_t *stacksize);
 int pthread_attr_init(pthread_attr_t *tattr);
 int pthread_attr_setdetachstate(pthread_attr_t *tattr, int detachstate);
 int pthread_attr_setstack(pthread_attr_t *tattr, void *stackaddr, size_t
@@ -189,7 +189,7 @@ int pthread_attr_setstacksize(pthread_attr_t *tattr, size_t stacksize);
 /* condition.c */
 int pthread_cond_broadcast(pthread_cond_t *cond);
 int pthread_cond_destroy(pthread_cond_t *cond);
-int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cattr);
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cattr);
 int pthread_cond_signal(pthread_cond_t *cond);
 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
 
@@ -197,11 +197,11 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
 int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
 int pthread_key_delete(pthread_key_t key);
 void *pthread_getspecific(pthread_key_t key);
-int pthread_setspecific(pthread_key_t key, void *value);
+int pthread_setspecific(pthread_key_t key, const void *value);
 
 /* mutex.c */
 int pthread_mutex_destroy(pthread_mutex_t *mutex);
-int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t
+int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
 	*mattr);
 int pthread_mutex_lock(pthread_mutex_t *mutex);
 int pthread_mutex_trylock(pthread_mutex_t *mutex);
@@ -217,7 +217,7 @@ int pthread_event_fire_all(pthread_event_t *event);
 /* rwlock.c */
 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
 int pthread_rwlock_init(pthread_rwlock_t *rwlock,
-	pthread_rwlockattr_t *UNUSED(attr));
+	const pthread_rwlockattr_t *UNUSED(attr));
 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
diff --git a/minix/lib/libmthread/allocate.c b/minix/lib/libmthread/allocate.c
index f34862aa6..e545338a7 100644
--- a/minix/lib/libmthread/allocate.c
+++ b/minix/lib/libmthread/allocate.c
@@ -14,7 +14,7 @@
 #include "proto.h"
 
 static int mthread_increase_thread_pool(void);
-static void mthread_thread_init(mthread_thread_t thread, mthread_attr_t
+static void mthread_thread_init(mthread_thread_t thread, const mthread_attr_t
 	*tattr, void *(*proc)(void *), void *arg);
 
 static void mthread_thread_stop(mthread_thread_t thread);
@@ -46,7 +46,7 @@ mthread_thread_t r;
  *===========================================================================*/
 int mthread_create(threadid, tattr, proc, arg)
 mthread_thread_t *threadid;
-mthread_attr_t *tattr;
+const mthread_attr_t *tattr;
 void *(*proc)(void *);
 void *arg;
 {
@@ -350,7 +350,7 @@ mthread_thread_t mthread_self(void)
  *===========================================================================*/
 static void mthread_thread_init(thread, tattr, proc, arg)
 mthread_thread_t thread;
-mthread_attr_t *tattr;
+const mthread_attr_t *tattr;
 void *(*proc)(void *);
 void *arg;
 {
diff --git a/minix/lib/libmthread/attribute.c b/minix/lib/libmthread/attribute.c
index fe63352cc..4dfc9899e 100644
--- a/minix/lib/libmthread/attribute.c
+++ b/minix/lib/libmthread/attribute.c
@@ -5,7 +5,7 @@
 static struct __mthread_attr *va_front, *va_rear;
 static void mthread_attr_add(mthread_attr_t *a);
 static void mthread_attr_remove(mthread_attr_t *a);
-static int mthread_attr_valid(mthread_attr_t *a);
+static int mthread_attr_valid(const mthread_attr_t *a);
 
 /*===========================================================================*
  *			mthread_init_valid_attributes			     *
@@ -92,7 +92,7 @@ mthread_attr_t *attr;	/* Attribute */
  *				mthread_attr_getdetachstate			     *
  *===========================================================================*/
 int mthread_attr_getdetachstate(attr, detachstate)
-mthread_attr_t *attr;
+const mthread_attr_t *attr;
 int *detachstate;
 {
 /* Get detachstate of a thread attribute */
@@ -141,7 +141,7 @@ int detachstate;
  *				mthread_attr_getstack			     *
  *===========================================================================*/
 int mthread_attr_getstack(attr, stackaddr, stacksize)
-mthread_attr_t *attr;
+const mthread_attr_t *attr;
 void **stackaddr;
 size_t *stacksize;
 {
@@ -166,7 +166,7 @@ size_t *stacksize;
  *				mthread_attr_getstacksize		     *
  *===========================================================================*/
 int mthread_attr_getstacksize(attr, stacksize)
-mthread_attr_t *attr;
+const mthread_attr_t *attr;
 size_t *stacksize;
 {
 /* Get stack size attribute */
@@ -262,7 +262,7 @@ mthread_attr_t *a;
  *				mthread_attr_valid			     *
  *===========================================================================*/
 static int mthread_attr_valid(a)
-mthread_attr_t *a;
+const mthread_attr_t *a;
 {
 /* Check to see if attribute is on the list of valid attributes */
   struct __mthread_attr *loopitem;
diff --git a/minix/lib/libmthread/condition.c b/minix/lib/libmthread/condition.c
index 3488a5f7c..9b66c0b29 100644
--- a/minix/lib/libmthread/condition.c
+++ b/minix/lib/libmthread/condition.c
@@ -117,7 +117,7 @@ mthread_cond_t *cond;
  *===========================================================================*/
 int mthread_cond_init(cond, cattr)
 mthread_cond_t *cond;
-mthread_condattr_t *cattr;
+const mthread_condattr_t *cattr;
 {
 /* Initialize condition variable to a known state. cattr is ignored */
   struct __mthread_cond *c;
diff --git a/minix/lib/libmthread/mutex.c b/minix/lib/libmthread/mutex.c
index 7f4683a6d..0a8a64f41 100644
--- a/minix/lib/libmthread/mutex.c
+++ b/minix/lib/libmthread/mutex.c
@@ -87,7 +87,7 @@ mthread_mutex_t *mutex;
  *===========================================================================*/
 int mthread_mutex_init(mutex, mattr)
 mthread_mutex_t *mutex;	/* Mutex that is to be initialized */
-mthread_mutexattr_t *mattr;	/* Mutex attribute */
+const mthread_mutexattr_t *mattr;	/* Mutex attribute */
 {
 /* Initialize the mutex to a known state. Attributes are not supported */
 
diff --git a/minix/lib/libmthread/pthread_compat.c b/minix/lib/libmthread/pthread_compat.c
index 00715802e..78dd6900b 100644
--- a/minix/lib/libmthread/pthread_compat.c
+++ b/minix/lib/libmthread/pthread_compat.c
@@ -20,7 +20,7 @@
 /*===========================================================================*
  *				pthread_mutex_init			     *
  *===========================================================================*/
-int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *mattr)
+int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr)
 {
 	return mthread_mutex_init(mutex, mattr);
 }
@@ -77,7 +77,7 @@ int pthread_mutex_unlock(pthread_mutex_t *mutex)
 /*===========================================================================*
  *				pthread_cond_init			     *
  *===========================================================================*/
-int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cattr)
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cattr)
 {
 	return mthread_cond_init(cond, cattr);
 }
@@ -134,7 +134,7 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 /*===========================================================================*
  *				pthread_rwlock_init			     *
  *===========================================================================*/
-int pthread_rwlock_init(pthread_rwlock_t *rwlock, pthread_rwlockattr_t *UNUSED(attr))
+int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *UNUSED(attr))
 {
 	return mthread_rwlock_init(rwlock);
 }