Index: libc/stdlib/malloc/free.c
===================================================================
--- libc/stdlib/malloc/free.c	(revision 24146)
+++ libc/stdlib/malloc/free.c	(working copy)
@@ -30,7 +30,7 @@
 static void
 __free_to_heap (void *mem, struct heap_free_area **heap
 #ifdef HEAP_USE_LOCKING
-		, malloc_mutex_t *heap_lock
+		, pthread_mutex_t *heap_lock
 #endif
 	       )
 {
Index: libc/stdlib/malloc/malloc.c
===================================================================
--- libc/stdlib/malloc/malloc.c	(revision 24146)
+++ libc/stdlib/malloc/malloc.c	(working copy)
@@ -28,12 +28,12 @@
 HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256);
 struct heap_free_area *__malloc_heap = HEAP_INIT_WITH_FA (initial_fa);
 #ifdef HEAP_USE_LOCKING
-malloc_mutex_t __malloc_heap_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t __malloc_heap_lock = PTHREAD_MUTEX_INITIALIZER;
 #endif
 
 #if defined(MALLOC_USE_LOCKING) && defined(MALLOC_USE_SBRK)
 /* A lock protecting our use of sbrk.  */
-malloc_mutex_t __malloc_sbrk_lock;
+pthread_mutex_t __malloc_sbrk_lock;
 #endif /* MALLOC_USE_LOCKING && MALLOC_USE_SBRK */
 
 
@@ -48,7 +48,7 @@ struct malloc_mmb *__malloc_mmapped_bloc
 HEAP_DECLARE_STATIC_FREE_AREA (initial_mmb_fa, 48); /* enough for 3 mmbs */
 struct heap_free_area *__malloc_mmb_heap = HEAP_INIT_WITH_FA (initial_mmb_fa);
 #ifdef HEAP_USE_LOCKING
-malloc_mutex_t __malloc_mmb_heap_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t __malloc_mmb_heap_lock = PTHREAD_MUTEX_INITIALIZER;
 #endif
 #endif /* __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
 
@@ -61,7 +61,7 @@ malloc_mutex_t __malloc_mmb_heap_lock = 
 static void *
 __malloc_from_heap (size_t size, struct heap_free_area **heap
 #ifdef HEAP_USE_LOCKING
-		, malloc_mutex_t *heap_lock
+		, pthread_mutex_t *heap_lock
 #endif
 		)
 {
Index: libc/stdlib/malloc/malloc.h
===================================================================
--- libc/stdlib/malloc/malloc.h	(revision 24146)
+++ libc/stdlib/malloc/malloc.h	(working copy)
@@ -130,24 +130,21 @@ extern int __malloc_mmb_debug;
 
 
 /* Locking for multithreaded apps.  */
-#ifdef __UCLIBC_HAS_THREADS__
+#if defined __UCLIBC_HAS_THREADS__ && defined __LINUXTHREADS_OLD__
 
 # include <pthread.h>
 # include <bits/uClibc_pthread.h>
 
 # define MALLOC_USE_LOCKING
 
-typedef pthread_mutex_t malloc_mutex_t;
-# define MALLOC_MUTEX_INIT	PTHREAD_MUTEX_INITIALIZER
-
 # ifdef MALLOC_USE_SBRK
 /* This lock is used to serialize uses of the `sbrk' function (in both
    malloc and free, sbrk may be used several times in succession, and
    things will break if these multiple calls are interleaved with another
    thread's use of sbrk!).  */
-extern malloc_mutex_t __malloc_sbrk_lock;
-#  define __malloc_lock_sbrk()	__pthread_mutex_lock (&__malloc_sbrk_lock)
-#  define __malloc_unlock_sbrk() __pthread_mutex_unlock (&__malloc_sbrk_lock)
+__UCLIBC_MUTEX_EXTERN(__malloc_sbrk_lock);
+#  define __malloc_lock_sbrk()	__UCLIBC_MUTEX_LOCK(__malloc_sbrk_lock)
+#  define __malloc_unlock_sbrk() __UCLIBC_MUTEX_UNLOCK(__malloc_sbrk_lock)
 # endif /* MALLOC_USE_SBRK */
 
 #else /* !__UCLIBC_HAS_THREADS__ */
@@ -222,9 +219,10 @@ extern void __malloc_debug_printf (int i
 
 /* The malloc heap.  */
 extern struct heap_free_area *__malloc_heap;
-#ifdef __UCLIBC_HAS_THREADS__
-extern malloc_mutex_t __malloc_heap_lock;
+#if defined __UCLIBC_HAS_THREADS__
+#include <bits/uClibc_mutex.h>
+__UCLIBC_MUTEX_EXTERN(__malloc_heap_lock);
 #ifdef __UCLIBC_UCLINUX_BROKEN_MUNMAP__
-extern malloc_mutex_t __malloc_mmb_heap_lock;
+__UCLIBC_MUTEX_EXTERN(__malloc_mmb_heap_lock);
 #endif
 #endif
Index: libc/sysdeps/linux/common/bits/uClibc_mutex.h
===================================================================
--- libc/sysdeps/linux/common/bits/uClibc_mutex.h	(revision 24146)
+++ libc/sysdeps/linux/common/bits/uClibc_mutex.h	(working copy)
@@ -18,9 +18,9 @@
 #define __UCLIBC_MUTEX_TYPE				pthread_mutex_t
 
 #define __UCLIBC_MUTEX(M)				pthread_mutex_t M
-#define __UCLIBC_MUTEX_INIT(M,I)			pthread_mutex_t M = I
-#define __UCLIBC_MUTEX_STATIC(M,I)			static pthread_mutex_t M = I
-#define __UCLIBC_MUTEX_EXTERN(M)			extern pthread_mutex_t M
+#define __UCLIBC_MUTEX_INIT(M,I)		pthread_mutex_t M = I
+#define __UCLIBC_MUTEX_STATIC(M,I)		static pthread_mutex_t M = I
+#define __UCLIBC_MUTEX_EXTERN(M)		extern pthread_mutex_t M attribute_hidden
 
 #define __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)								\
 		__pthread_mutex_lock(&(M))