path: root/toolchain/uClibc/uClibc-0.9.28-mutex-cancel.patch

diff --git a/include/printf.h b/include/printf.h
index 340b6cb..2dea58f 100644
--- a/include/printf.h
+++ b/include/printf.h
@@ -75,6 +75,7 @@ struct printf_info
   unsigned int is_short:1;	/* h flag.  */
   unsigned int is_long:1;	/* l flag.  */
   unsigned int is_long_double:1;/* L flag.  */
+  unsigned int __padding:20;/* non-gnu -- total of 32 bits on 32bit arch */
 
 #elif __BYTE_ORDER == __BIG_ENDIAN
 
diff --git a/include/pthread.h b/include/pthread.h
index 8c01172..cee112b 100644
--- a/include/pthread.h
+++ b/include/pthread.h
@@ -644,7 +644,8 @@ extern void _pthread_cleanup_pop (struct
 /* Install a cleanup handler as pthread_cleanup_push does, but also
    saves the current cancellation type and set it to deferred cancellation.  */
 
-#ifdef __USE_GNU
+/* #ifdef __USE_GNU */
+#if defined(__USE_GNU) || defined(_LIBC)
 # define pthread_cleanup_push_defer_np(routine,arg) \
   { struct _pthread_cleanup_buffer _buffer;				      \
     _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
diff --git a/libc/inet/getnetent.c b/libc/inet/getnetent.c
index 181c5ad..659bf5d 100644
--- a/libc/inet/getnetent.c
+++ b/libc/inet/getnetent.c
@@ -22,18 +22,9 @@
 #include <netdb.h>
 #include <arpa/inet.h>
 
+#include <bits/uClibc_mutex.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
-
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 #define	MAXALIASES	35
 static const char NETDB[] = _PATH_NETWORKS;
@@ -46,25 +37,25 @@ int _net_stayopen;
 
 void setnetent(int f)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (netf == NULL)
-	netf = fopen(NETDB, "r" );
+		netf = fopen(NETDB, "r" );
     else
-	rewind(netf);
+		rewind(netf);
     _net_stayopen |= f;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return;
 }
 
 void endnetent(void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (netf) {
-	fclose(netf);
-	netf = NULL;
+		fclose(netf);
+		netf = NULL;
     }
     _net_stayopen = 0;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 static char * any(register char *cp, char *match)
@@ -72,10 +63,10 @@ static char * any(register char *cp, cha
     register char *mp, c;
 
     while ((c = *cp)) {
-	for (mp = match; *mp; mp++)
-	    if (*mp == c)
-		return (cp);
-	cp++;
+		for (mp = match; *mp; mp++)
+			if (*mp == c)
+				return (cp);
+		cp++;
     }
     return ((char *)0);
 }
@@ -84,59 +75,62 @@ struct netent * getnetent(void)
 {
     char *p;
     register char *cp, **q;
+	struct netent *rv = NULL;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (netf == NULL && (netf = fopen(NETDB, "r" )) == NULL) {
-	UNLOCK;
-	return (NULL);
+		goto DONE;
     }
-again:
+ again:
 
     if (!line) {
-	line = malloc(BUFSIZ + 1);
-	if (!line)
-	    abort();
+		line = malloc(BUFSIZ + 1);
+		if (!line)
+			abort();
     }
 
     p = fgets(line, BUFSIZ, netf);
     if (p == NULL) {
-	UNLOCK;
-	return (NULL);
+		goto DONE;
     }
     if (*p == '#')
-	goto again;
+		goto again;
     cp = any(p, "#\n");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp = '\0';
     net.n_name = p;
     cp = any(p, " \t");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp++ = '\0';
     while (*cp == ' ' || *cp == '\t')
-	cp++;
+		cp++;
     p = any(cp, " \t");
     if (p != NULL)
-	*p++ = '\0';
+		*p++ = '\0';
     net.n_net = inet_network(cp);
     net.n_addrtype = AF_INET;
     q = net.n_aliases = net_aliases;
     if (p != NULL)
-	cp = p;
+		cp = p;
     while (cp && *cp) {
-	if (*cp == ' ' || *cp == '\t') {
-	    cp++;
-	    continue;
-	}
-	if (q < &net_aliases[MAXALIASES - 1])
-	    *q++ = cp;
-	cp = any(cp, " \t");
-	if (cp != NULL)
-	    *cp++ = '\0';
+		if (*cp == ' ' || *cp == '\t') {
+			cp++;
+			continue;
+		}
+		if (q < &net_aliases[MAXALIASES - 1])
+			*q++ = cp;
+		cp = any(cp, " \t");
+		if (cp != NULL)
+			*cp++ = '\0';
     }
     *q = NULL;
-    UNLOCK;
-    return (&net);
+
+	rv = &net;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
+    return rv;
 }
 
diff --git a/libc/inet/getproto.c b/libc/inet/getproto.c
index c9f35f1..3665d89 100644
--- a/libc/inet/getproto.c
+++ b/libc/inet/getproto.c
@@ -62,17 +62,9 @@
 #include <string.h>
 #include <errno.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
+#include <bits/uClibc_mutex.h>
 
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 #define	MAXALIASES	35
 #define	SBUFSIZE	(BUFSIZ + 1 + (sizeof(char *) * MAXALIASES))
@@ -85,109 +77,114 @@ static int proto_stayopen;
 static void __initbuf(void)
 {
     if (!static_aliases) {
-	static_aliases = malloc(SBUFSIZE);
-	if (!static_aliases)
-	    abort();
+		static_aliases = malloc(SBUFSIZE);
+		if (!static_aliases)
+			abort();
     }
 }
 
 void setprotoent(int f)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (protof == NULL)
-	protof = fopen(_PATH_PROTOCOLS, "r" );
+		protof = fopen(_PATH_PROTOCOLS, "r" );
     else
-	rewind(protof);
+		rewind(protof);
     proto_stayopen |= f;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void endprotoent(void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (protof) {
-	fclose(protof);
-	protof = NULL;
+		fclose(protof);
+		protof = NULL;
     }
     proto_stayopen = 0;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 int getprotoent_r(struct protoent *result_buf,
-		  char *buf, size_t buflen,
-		  struct protoent **result)
+				  char *buf, size_t buflen,
+				  struct protoent **result)
 {
     char *p;
     register char *cp, **q;
     char **proto_aliases;
     char *line;
+	int rv;
 
     *result = NULL;
 
     if (buflen < sizeof(*proto_aliases)*MAXALIASES) {
-	errno=ERANGE;
-	return errno;
+		errno=ERANGE;
+		return errno;
     }
-    LOCK;
+
+    __UCLIBC_MUTEX_LOCK(mylock);
     proto_aliases=(char **)buf;
     buf+=sizeof(*proto_aliases)*MAXALIASES;
     buflen-=sizeof(*proto_aliases)*MAXALIASES;
 
     if (buflen < BUFSIZ+1) {
-	UNLOCK;
-	errno=ERANGE;
-	return errno;
+		errno=rv=ERANGE;
+		goto DONE;
     }
     line=buf;
     buf+=BUFSIZ+1;
     buflen-=BUFSIZ+1;
 
     if (protof == NULL && (protof = fopen(_PATH_PROTOCOLS, "r" )) == NULL) {
-	UNLOCK;
-	return errno;
+		rv=errno;
+		goto DONE;
     }
-again:
+ again:
     if ((p = fgets(line, BUFSIZ, protof)) == NULL) {
-	UNLOCK;
-	return TRY_AGAIN;
+		rv=TRY_AGAIN;
+		goto DONE;
     }
 
     if (*p == '#')
-	goto again;
+		goto again;
     cp = strpbrk(p, "#\n");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp = '\0';
     result_buf->p_name = p;
     cp = strpbrk(p, " \t");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp++ = '\0';
     while (*cp == ' ' || *cp == '\t')
-	cp++;
+		cp++;
     p = strpbrk(cp, " \t");
     if (p != NULL)
-	*p++ = '\0';
+		*p++ = '\0';
     result_buf->p_proto = atoi(cp);
     q = result_buf->p_aliases = proto_aliases;
     if (p != NULL) {
-	cp = p;
-	while (cp && *cp) {
-	    if (*cp == ' ' || *cp == '\t') {
-		cp++;
-		continue;
-	    }
-	    if (q < &proto_aliases[MAXALIASES - 1])
-		*q++ = cp;
-	    cp = strpbrk(cp, " \t");
-	    if (cp != NULL)
-		*cp++ = '\0';
-	}
+		cp = p;
+		while (cp && *cp) {
+			if (*cp == ' ' || *cp == '\t') {
+				cp++;
+				continue;
+			}
+			if (q < &proto_aliases[MAXALIASES - 1])
+				*q++ = cp;
+			cp = strpbrk(cp, " \t");
+			if (cp != NULL)
+				*cp++ = '\0';
+		}
     }
     *q = NULL;
     *result=result_buf;
-    UNLOCK;
-    return 0;
+
+	rv = 0;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
+    return rv;
 }
 
 struct protoent * getprotoent(void)
@@ -201,26 +198,26 @@ struct protoent * getprotoent(void)
 
 
 int getprotobyname_r(const char *name,
-		    struct protoent *result_buf,
-		    char *buf, size_t buflen,
-		    struct protoent **result)
+					 struct protoent *result_buf,
+					 char *buf, size_t buflen,
+					 struct protoent **result)
 {
     register char **cp;
     int ret;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     setprotoent(proto_stayopen);
     while (!(ret=getprotoent_r(result_buf, buf, buflen, result))) {
-	if (strcmp(result_buf->p_name, name) == 0)
-	    break;
-	for (cp = result_buf->p_aliases; *cp != 0; cp++)
-	    if (strcmp(*cp, name) == 0)
-		goto found;
+		if (strcmp(result_buf->p_name, name) == 0)
+			break;
+		for (cp = result_buf->p_aliases; *cp != 0; cp++)
+			if (strcmp(*cp, name) == 0)
+				goto found;
     }
-found:
+ found:
     if (!proto_stayopen)
-	endprotoent();
-    UNLOCK;
+		endprotoent();
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return *result?0:ret;
 }
 
@@ -236,20 +233,20 @@ struct protoent * getprotobyname(const c
 
 
 int getprotobynumber_r (int proto_num,
-			struct protoent *result_buf,
-			char *buf, size_t buflen,
-			struct protoent **result)
+						struct protoent *result_buf,
+						char *buf, size_t buflen,
+						struct protoent **result)
 {
     int ret;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     setprotoent(proto_stayopen);
     while (!(ret=getprotoent_r(result_buf, buf, buflen, result)))
-	if (result_buf->p_proto == proto_num)
-	    break;
+		if (result_buf->p_proto == proto_num)
+			break;
     if (!proto_stayopen)
-	endprotoent();
-    UNLOCK;
+		endprotoent();
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return *result?0:ret;
 }
 
diff --git a/libc/inet/getservice.c b/libc/inet/getservice.c
index cbe5c50..b666057 100644
--- a/libc/inet/getservice.c
+++ b/libc/inet/getservice.c
@@ -65,20 +65,9 @@
 #include <arpa/inet.h>
 #include <errno.h>
 
+#include <bits/uClibc_mutex.h>
 
-
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
-
-
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 #define	MAXALIASES	35
 #define SBUFSIZE	(BUFSIZ + 1 + (sizeof(char *) * MAXALIASES))
@@ -91,32 +80,32 @@ static int serv_stayopen;
 static void __initbuf(void)
 {
     if (!servbuf) {
-	servbuf = malloc(SBUFSIZE);
-	if (!servbuf)
-	    abort();
+		servbuf = malloc(SBUFSIZE);
+		if (!servbuf)
+			abort();
     }
 }
 
 void setservent(int f)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (servf == NULL)
-	servf = fopen(_PATH_SERVICES, "r" );
+		servf = fopen(_PATH_SERVICES, "r" );
     else
-	rewind(servf);
+		rewind(servf);
     serv_stayopen |= f;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void endservent(void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (servf) {
-	fclose(servf);
-	servf = NULL;
+		fclose(servf);
+		servf = NULL;
     }
     serv_stayopen = 0;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 struct servent * getservent(void)
@@ -149,127 +138,129 @@ struct servent * getservbyport(int port,
 }
 
 int getservent_r(struct servent * result_buf,
-		 char * buf, size_t buflen,
-		 struct servent ** result)
+				 char * buf, size_t buflen,
+				 struct servent ** result)
 {
     char *p;
     register char *cp, **q;
     char **serv_aliases;
     char *line;
+	int rv;
 
     *result=NULL;
 
     if (buflen < sizeof(*serv_aliases)*MAXALIASES) {
-	errno=ERANGE;
-	return errno;
+		errno=ERANGE;
+		return errno;
     }
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     serv_aliases=(char **)buf;
     buf+=sizeof(*serv_aliases)*MAXALIASES;
     buflen-=sizeof(*serv_aliases)*MAXALIASES;
 
     if (buflen < BUFSIZ+1) {
-	UNLOCK;
-	errno=ERANGE;
-	return errno;
+		errno=rv=ERANGE;
+		goto DONE;
     }
     line=buf;
     buf+=BUFSIZ+1;
     buflen-=BUFSIZ+1;
 
     if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL) {
-	UNLOCK;
-	errno=EIO;
-	return errno;
+		errno=rv=EIO;
+		goto DONE;
     }
-again:
+ again:
     if ((p = fgets(line, BUFSIZ, servf)) == NULL) {
-	UNLOCK;
-	errno=EIO;
-	return errno;
+		errno=rv=EIO;
+		goto DONE;
     }
     if (*p == '#')
-	goto again;
+		goto again;
     cp = strpbrk(p, "#\n");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp = '\0';
     result_buf->s_name = p;
     p = strpbrk(p, " \t");
     if (p == NULL)
-	goto again;
+		goto again;
     *p++ = '\0';
     while (*p == ' ' || *p == '\t')
-	p++;
+		p++;
     cp = strpbrk(p, ",/");
     if (cp == NULL)
-	goto again;
+		goto again;
     *cp++ = '\0';
     result_buf->s_port = htons((u_short)atoi(p));
     result_buf->s_proto = cp;
     q = result_buf->s_aliases = serv_aliases;
     cp = strpbrk(cp, " \t");
     if (cp != NULL)
-	*cp++ = '\0';
+		*cp++ = '\0';
     while (cp && *cp) {
-	if (*cp == ' ' || *cp == '\t') {
-	    cp++;
-	    continue;
-	}
-	if (q < &serv_aliases[MAXALIASES - 1])
-	    *q++ = cp;
-	cp = strpbrk(cp, " \t");
-	if (cp != NULL)
-	    *cp++ = '\0';
+		if (*cp == ' ' || *cp == '\t') {
+			cp++;
+			continue;
+		}
+		if (q < &serv_aliases[MAXALIASES - 1])
+			*q++ = cp;
+		cp = strpbrk(cp, " \t");
+		if (cp != NULL)
+			*cp++ = '\0';
     }
     *q = NULL;
     *result=result_buf;
-    UNLOCK;
-    return 0;
+
+	rv = 0;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
+    return rv;
 }
 
 int getservbyname_r(const char *name, const char *proto,
-	struct servent * result_buf, char * buf, size_t buflen,
-	struct servent ** result)
+					struct servent * result_buf, char * buf, size_t buflen,
+					struct servent ** result)
 {
     register char **cp;
     int ret;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     setservent(serv_stayopen);
     while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
-	if (strcmp(name, result_buf->s_name) == 0)
-	    goto gotname;
-	for (cp = result_buf->s_aliases; *cp; cp++)
-	    if (strcmp(name, *cp) == 0)
-		goto gotname;
-	continue;
-gotname:
-	if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
-	    break;
+		if (strcmp(name, result_buf->s_name) == 0)
+			goto gotname;
+		for (cp = result_buf->s_aliases; *cp; cp++)
+			if (strcmp(name, *cp) == 0)
+				goto gotname;
+		continue;
+	gotname:
+		if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
+			break;
     }
     if (!serv_stayopen)
-	endservent();
-    UNLOCK;
+		endservent();
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return *result?0:ret;
 }
 
 int getservbyport_r(int port, const char *proto,
-	struct servent * result_buf, char * buf,
-	size_t buflen, struct servent ** result)
+					struct servent * result_buf, char * buf,
+					size_t buflen, struct servent ** result)
 {
     int ret;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     setservent(serv_stayopen);
     while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
-	if (result_buf->s_port != port)
-	    continue;
-	if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
-	    break;
+		if (result_buf->s_port != port)
+			continue;
+		if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
+			break;
     }
     if (!serv_stayopen)
-	endservent();
-    UNLOCK;
+		endservent();
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return *result?0:ret;
 }
diff --git a/libc/inet/resolv.c b/libc/inet/resolv.c
index 27b60ef..0f583ab 100644
--- a/libc/inet/resolv.c
+++ b/libc/inet/resolv.c
@@ -7,7 +7,7 @@
  * 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.
-*/
+ */
 
 /*
  * Portions Copyright (c) 1985, 1993
@@ -153,6 +153,11 @@
 #include <sys/utsname.h>
 #include <sys/un.h>
 
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_EXTERN(__resolv_lock);
+
+
 #define MAX_RECURSE 5
 #define REPLY_TIMEOUT 10
 #define MAX_RETRIES 3
@@ -180,18 +185,6 @@ extern char * __nameserver[MAX_SERVERS];
 extern int __searchdomains;
 extern char * __searchdomain[MAX_SEARCH];
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-extern pthread_mutex_t __resolv_lock;
-# define BIGLOCK	__pthread_mutex_lock(&__resolv_lock)
-# define BIGUNLOCK	__pthread_mutex_unlock(&__resolv_lock);
-#else
-# define BIGLOCK
-# define BIGUNLOCK
-#endif
-
-
-
 /* Structs */
 struct resolv_header {
 	int id;
@@ -229,49 +222,49 @@ enum etc_hosts_action {
 
 /* function prototypes */
 extern int __get_hosts_byname_r(const char * name, int type,
-			      struct hostent * result_buf,
-			      char * buf, size_t buflen,
-			      struct hostent ** result,
-			      int * h_errnop);
+								struct hostent * result_buf,
+								char * buf, size_t buflen,
+								struct hostent ** result,
+								int * h_errnop);
 extern int __get_hosts_byaddr_r(const char * addr, int len, int type,
-			      struct hostent * result_buf,
-			      char * buf, size_t buflen,
-			      struct hostent ** result,
-			      int * h_errnop);
+								struct hostent * result_buf,
+								char * buf, size_t buflen,
+								struct hostent ** result,
+								int * h_errnop);
 extern void __open_etc_hosts(FILE **fp);
 extern int __read_etc_hosts_r(FILE *fp, const char * name, int type,
-			    enum etc_hosts_action action,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop);
+							  enum etc_hosts_action action,
+							  struct hostent * result_buf,
+							  char * buf, size_t buflen,
+							  struct hostent ** result,
+							  int * h_errnop);
 extern int __dns_lookup(const char * name, int type, int nscount,
-	char ** nsip, unsigned char ** outpacket, struct resolv_answer * a);
+						char ** nsip, unsigned char ** outpacket, struct resolv_answer * a);
 
 extern int __encode_dotted(const char * dotted, unsigned char * dest, int maxlen);
 extern int __decode_dotted(const unsigned char * message, int offset,
-	char * dest, int maxlen);
+						   char * dest, int maxlen);
 extern int __length_dotted(const unsigned char * message, int offset);
 extern int __encode_header(struct resolv_header * h, unsigned char * dest, int maxlen);
 extern int __decode_header(unsigned char * data, struct resolv_header * h);
 extern int __encode_question(struct resolv_question * q,
-	unsigned char * dest, int maxlen);
+							 unsigned char * dest, int maxlen);
 extern int __decode_question(unsigned char * message, int offset,
-	struct resolv_question * q);
+							 struct resolv_question * q);
 extern int __encode_answer(struct resolv_answer * a,
-	unsigned char * dest, int maxlen);
+						   unsigned char * dest, int maxlen);
 extern int __decode_answer(unsigned char * message, int offset,
-	struct resolv_answer * a);
+						   struct resolv_answer * a);
 extern int __length_question(unsigned char * message, int offset);
 extern int __open_nameservers(void);
 extern void __close_nameservers(void);
 extern int __dn_expand(const u_char *, const u_char *, const u_char *,
-	char *, int);
+					   char *, int);
 extern int __ns_name_uncompress(const u_char *, const u_char *,
-		const u_char *, char *, size_t);
+								const u_char *, char *, size_t);
 extern int __ns_name_ntop(const u_char *, char *, size_t);
 extern int __ns_name_unpack(const u_char *, const u_char *, const u_char *,
-               u_char *, size_t);
+							u_char *, size_t);
 
 
 #ifdef L_encodeh
@@ -361,7 +354,7 @@ int __encode_dotted(const char *dotted, 
    This routine understands compressed data. */
 
 int __decode_dotted(const unsigned char *data, int offset,
-				  char *dest, int maxlen)
+					char *dest, int maxlen)
 {
 	int l;
 	int measure = 1;
@@ -435,7 +428,7 @@ int __length_dotted(const unsigned char 
 
 #ifdef L_encodeq
 int __encode_question(struct resolv_question *q,
-					unsigned char *dest, int maxlen)
+					  unsigned char *dest, int maxlen)
 {
 	int i;
 
@@ -460,7 +453,7 @@ int __encode_question(struct resolv_ques
 
 #ifdef L_decodeq
 int __decode_question(unsigned char *message, int offset,
-					struct resolv_question *q)
+					  struct resolv_question *q)
 {
 	char temp[256];
 	int i;
@@ -525,7 +518,7 @@ int __encode_answer(struct resolv_answer
 
 #ifdef L_decodea
 int __decode_answer(unsigned char *message, int offset,
-				  struct resolv_answer *a)
+					struct resolv_answer *a)
 {
 	char temp[256];
 	int i;
@@ -557,11 +550,11 @@ int __decode_answer(unsigned char *messa
 
 #ifdef L_encodep
 int __encode_packet(struct resolv_header *h,
-	struct resolv_question **q,
-	struct resolv_answer **an,
-	struct resolv_answer **ns,
-	struct resolv_answer **ar,
-	unsigned char *dest, int maxlen)
+					struct resolv_question **q,
+					struct resolv_answer **an,
+					struct resolv_answer **ns,
+					struct resolv_answer **ar,
+					unsigned char *dest, int maxlen)
 {
 	int i, total = 0;
 	int j;
@@ -621,7 +614,7 @@ int __decode_packet(unsigned char *data,
 
 #ifdef L_formquery
 int __form_query(int id, const char *name, int type, unsigned char *packet,
-			   int maxlen)
+				 int maxlen)
 {
 	struct resolv_header h;
 	struct resolv_question q;
@@ -649,14 +642,7 @@ int __form_query(int id, const char *nam
 
 #ifdef L_dnslookup
 
-#ifdef __UCLIBC_HAS_THREADS__
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 /* Just for the record, having to lock __dns_lookup() just for these two globals
  * is pretty lame.  I think these two variables can probably be de-global-ized,
@@ -665,7 +651,7 @@ static pthread_mutex_t mylock = PTHREAD_
 static int ns=0, id=1;
 
 int __dns_lookup(const char *name, int type, int nscount, char **nsip,
-			   unsigned char **outpacket, struct resolv_answer *a)
+				 unsigned char **outpacket, struct resolv_answer *a)
 {
 	int i, j, len, fd, pos, rc;
 	struct timeval tv;
@@ -693,10 +679,10 @@ int __dns_lookup(const char *name, int t
 	DPRINTF("Looking up type %d answer for '%s'\n", type, name);
 
 	/* Mess with globals while under lock */
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	local_ns = ns % nscount;
 	local_id = id;
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
 	while (retries < MAX_RETRIES) {
 		if (fd != -1)
@@ -722,13 +708,13 @@ int __dns_lookup(const char *name, int t
 
 		strncpy(lookup,name,MAXDNAME);
 		if (variant >= 0) {
-                        BIGLOCK;
-                        if (variant < __searchdomains) {
-                                strncat(lookup,".", MAXDNAME);
-                                strncat(lookup,__searchdomain[variant], MAXDNAME);
-                        }
-                        BIGUNLOCK;
-                }
+			__UCLIBC_MUTEX_LOCK(__resolv_lock);
+			if (variant < __searchdomains) {
+				strncat(lookup,".", MAXDNAME);
+				strncat(lookup,__searchdomain[variant], MAXDNAME);
+			}
+			__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
+		}
 		DPRINTF("lookup name: %s\n", lookup);
 		q.dotted = (char *)lookup;
 		q.qtype = type;
@@ -750,7 +736,7 @@ int __dns_lookup(const char *name, int t
 		fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 #endif
 		if (fd < 0) {
-                    retries++;
+			retries++;
 		    continue;
 		}
 
@@ -772,11 +758,11 @@ int __dns_lookup(const char *name, int t
 #endif
 		if (rc < 0) {
 		    if (errno == ENETUNREACH) {
-			/* routing error, presume not transient */
-			goto tryall;
+				/* routing error, presume not transient */
+				goto tryall;
 		    } else
-			/* retry */
-                        retries++;
+				/* retry */
+				retries++;
 			continue;
 		}
 
@@ -838,55 +824,55 @@ int __dns_lookup(const char *name, int t
 
 		first_answer = 1;
 		for (j=0;j<h.ancount;j++,pos += i)
-		{
-		    i = __decode_answer(packet, pos, &ma);
+			{
+				i = __decode_answer(packet, pos, &ma);
 
-		    if (i<0) {
-			DPRINTF("failed decode %d\n", i);
-			goto again;
-		    }
+				if (i<0) {
+					DPRINTF("failed decode %d\n", i);
+					goto again;
+				}
 
-		    if ( first_answer )
-		    {
-			ma.buf = a->buf;
-			ma.buflen = a->buflen;
-			ma.add_count = a->add_count;
-			memcpy(a, &ma, sizeof(ma));
-			if (a->atype != T_SIG && (0 == a->buf || (type != T_A && type != T_AAAA)))
-			{
-			    break;
-			}
-			if (a->atype != type)
-			{
-			    free(a->dotted);
-			    continue;
-			}
-			a->add_count = h.ancount - j - 1;
-			if ((a->rdlength + sizeof(struct in_addr*)) * a->add_count > a->buflen)
-			{
-			    break;
-			}
-			a->add_count = 0;
-			first_answer = 0;
-		    }
-		    else
-		    {
-			free(ma.dotted);
-			if (ma.atype != type)
-			{
-			    continue;
-			}
-			if (a->rdlength != ma.rdlength)
-			{
-			    free(a->dotted);
-			    DPRINTF("Answer address len(%u) differs from original(%u)\n",
-				    ma.rdlength, a->rdlength);
-			    goto again;
+				if ( first_answer )
+					{
+						ma.buf = a->buf;
+						ma.buflen = a->buflen;
+						ma.add_count = a->add_count;
+						memcpy(a, &ma, sizeof(ma));
+						if (a->atype != T_SIG && (0 == a->buf || (type != T_A && type != T_AAAA)))
+							{
+								break;
+							}
+						if (a->atype != type)
+							{
+								free(a->dotted);
+								continue;
+							}
+						a->add_count = h.ancount - j - 1;
+						if ((a->rdlength + sizeof(struct in_addr*)) * a->add_count > a->buflen)
+							{
+								break;
+							}
+						a->add_count = 0;
+						first_answer = 0;
+					}
+				else
+					{
+						free(ma.dotted);
+						if (ma.atype != type)
+							{
+								continue;
+							}
+						if (a->rdlength != ma.rdlength)
+							{
+								free(a->dotted);
+								DPRINTF("Answer address len(%u) differs from original(%u)\n",
+										ma.rdlength, a->rdlength);
+								goto again;
+							}
+						memcpy(a->buf + (a->add_count * ma.rdlength), ma.rdata, ma.rdlength);
+						++a->add_count;
+					}
 			}
-			memcpy(a->buf + (a->add_count * ma.rdlength), ma.rdata, ma.rdlength);
-			++a->add_count;
-		    }
-		}
 
 		DPRINTF("Answer name = |%s|\n", a->dotted);
 		DPRINTF("Answer type = |%d|\n", a->atype);
@@ -900,48 +886,48 @@ int __dns_lookup(const char *name, int t
 		free(lookup);
 
 		/* Mess with globals while under lock */
-		LOCK;
+		__UCLIBC_MUTEX_LOCK(mylock);
 		ns = local_ns;
 		id = local_id;
-		UNLOCK;
+		__UCLIBC_MUTEX_UNLOCK(mylock);
 
 		return (len);				/* success! */
 
-	  tryall:
+	tryall:
 		/* if there are other nameservers, give them a go,
 		   otherwise return with error */
 		{
 		    variant = -1;
-                    local_ns = (local_ns + 1) % nscount;
-                    if (local_ns == 0)
-                      retries++;
+			local_ns = (local_ns + 1) % nscount;
+			if (local_ns == 0)
+				retries++;
 
-                    continue;
+			continue;
 		}
 
-	  again:
+	again:
 		/* if there are searchdomains, try them or fallback as passed */
 		{
 		    int sdomains;
-		    BIGLOCK;
+		    __UCLIBC_MUTEX_LOCK(__resolv_lock);
 		    sdomains=__searchdomains;
-		    BIGUNLOCK;
+		    __UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 
 		    if (variant < sdomains - 1) {
-			/* next search */
-			variant++;
+				/* next search */
+				variant++;
 		    } else {
-			/* next server, first search */
-			local_ns = (local_ns + 1) % nscount;
-                        if (local_ns == 0)
-                          retries++;
+				/* next server, first search */
+				local_ns = (local_ns + 1) % nscount;
+				if (local_ns == 0)
+					retries++;
 
-			variant = -1;
+				variant = -1;
 		    }
 		}
 	}
 
-fail:
+ fail:
 	if (fd != -1)
 	    close(fd);
 	if (lookup)
@@ -951,10 +937,10 @@ fail:
 	h_errno = NETDB_INTERNAL;
 	/* Mess with globals while under lock */
 	if (local_ns != -1) {
-	    LOCK;
+	    __UCLIBC_MUTEX_LOCK(mylock);
 	    ns = local_ns;
 	    id = local_id;
-	    UNLOCK;
+	    __UCLIBC_MUTEX_UNLOCK(mylock);
 	}
 	return -1;
 }
@@ -966,9 +952,8 @@ int __nameservers;
 char * __nameserver[MAX_SERVERS];
 int __searchdomains;
 char * __searchdomain[MAX_SEARCH];
-#ifdef __UCLIBC_HAS_THREADS__
-pthread_mutex_t __resolv_lock = PTHREAD_MUTEX_INITIALIZER;
-#endif
+
+__UCLIBC_MUTEX_INIT(__resolv_lock, PTHREAD_MUTEX_INITIALIZER);
 
 /*
  *	we currently read formats not quite the same as that on normal
@@ -982,60 +967,63 @@ int __open_nameservers()
 #define RESOLV_ARGS 5
 	char szBuffer[128], *p, *argv[RESOLV_ARGS];
 	int argc;
+	int rv = 0;
 
-	BIGLOCK;
+	__UCLIBC_MUTEX_LOCK(__resolv_lock);
 	if (__nameservers > 0) {
-	    BIGUNLOCK;
-	    return 0;
+		goto DONE;
 	}
 
 	if ((fp = fopen("/etc/resolv.conf", "r")) ||
-			(fp = fopen("/etc/config/resolv.conf", "r")))
-	{
-
-		while (fgets(szBuffer, sizeof(szBuffer), fp) != NULL) {
+		(fp = fopen("/etc/config/resolv.conf", "r")))
+		{
 
-			for (p = szBuffer; *p && isspace(*p); p++)
-				/* skip white space */;
-			if (*p == '\0' || *p == '\n' || *p == '#') /* skip comments etc */
-				continue;
-			argc = 0;
-			while (*p && argc < RESOLV_ARGS) {
-				argv[argc++] = p;
-				while (*p && !isspace(*p) && *p != '\n')
-					p++;
-				while (*p && (isspace(*p) || *p == '\n')) /* remove spaces */
-					*p++ = '\0';
-			}
+			while (fgets(szBuffer, sizeof(szBuffer), fp) != NULL) {
 
-			if (strcmp(argv[0], "nameserver") == 0) {
-				for (i = 1; i < argc && __nameservers < MAX_SERVERS; i++) {
-					__nameserver[__nameservers++] = strdup(argv[i]);
-					DPRINTF("adding nameserver %s\n", argv[i]);
+				for (p = szBuffer; *p && isspace(*p); p++)
+					/* skip white space */;
+				if (*p == '\0' || *p == '\n' || *p == '#') /* skip comments etc */
+					continue;
+				argc = 0;
+				while (*p && argc < RESOLV_ARGS) {
+					argv[argc++] = p;
+					while (*p && !isspace(*p) && *p != '\n')
+						p++;
+					while (*p && (isspace(*p) || *p == '\n')) /* remove spaces */
+						*p++ = '\0';
 				}
-			}
 
-			/* domain and search are mutually exclusive, the last one wins */
-			if (strcmp(argv[0],"domain")==0 || strcmp(argv[0],"search")==0) {
-				while (__searchdomains > 0) {
-					free(__searchdomain[--__searchdomains]);
-					__searchdomain[__searchdomains] = NULL;
+				if (strcmp(argv[0], "nameserver") == 0) {
+					for (i = 1; i < argc && __nameservers < MAX_SERVERS; i++) {
+						__nameserver[__nameservers++] = strdup(argv[i]);
+						DPRINTF("adding nameserver %s\n", argv[i]);
+					}
 				}
-				for (i=1; i < argc && __searchdomains < MAX_SEARCH; i++) {
-					__searchdomain[__searchdomains++] = strdup(argv[i]);
-					DPRINTF("adding search %s\n", argv[i]);
+
+				/* domain and search are mutually exclusive, the last one wins */
+				if (strcmp(argv[0],"domain")==0 || strcmp(argv[0],"search")==0) {
+					while (__searchdomains > 0) {
+						free(__searchdomain[--__searchdomains]);
+						__searchdomain[__searchdomains] = NULL;
+					}
+					for (i=1; i < argc && __searchdomains < MAX_SEARCH; i++) {
+						__searchdomain[__searchdomains++] = strdup(argv[i]);
+						DPRINTF("adding search %s\n", argv[i]);
+					}
 				}
 			}
+			fclose(fp);
+			DPRINTF("nameservers = %d\n", __nameservers);
+			goto DONE;
 		}
-		fclose(fp);
-		DPRINTF("nameservers = %d\n", __nameservers);
-		BIGUNLOCK;
-		return 0;
-	}
 	DPRINTF("failed to open %s\n", "resolv.conf");
 	h_errno = NO_RECOVERY;
-	BIGUNLOCK;
-	return -1;
+
+	rv = -1;
+
+ DONE:
+	__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
+	return rv;
 }
 #endif
 
@@ -1044,7 +1032,7 @@ int __open_nameservers()
 
 void __close_nameservers(void)
 {
-	BIGLOCK;
+	__UCLIBC_MUTEX_LOCK(__resolv_lock);
 	while (__nameservers > 0) {
 		free(__nameserver[--__nameservers]);
 		__nameserver[__nameservers] = NULL;
@@ -1053,7 +1041,7 @@ void __close_nameservers(void)
 		free(__searchdomain[--__searchdomains]);
 		__searchdomain[__searchdomains] = NULL;
 	}
-	BIGUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 }
 #endif
 
@@ -1063,8 +1051,8 @@ struct hostent *gethostbyname(const char
 {
 	static struct hostent h;
 	static char buf[sizeof(struct in_addr) +
-			sizeof(struct in_addr *)*2 +
-			sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
+					sizeof(struct in_addr *)*2 +
+					sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
 	struct hostent *hp;
 
 	gethostbyname_r(name, &h, buf, sizeof(buf), &hp, &h_errno);
@@ -1082,8 +1070,8 @@ struct hostent *gethostbyname2(const cha
 #else /* __UCLIBC_HAS_IPV6__ */
 	static struct hostent h;
 	static char buf[sizeof(struct in6_addr) +
-			sizeof(struct in6_addr *)*2 +
-			sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
+					sizeof(struct in6_addr *)*2 +
+					sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
 	struct hostent *hp;
 
 	gethostbyname2_r(name, family, &h, buf, sizeof(buf), &hp, &h_errno);
@@ -1119,7 +1107,7 @@ int res_init(void)
 	/** rp->rhook = NULL; **/
 	/** rp->_u._ext.nsinit = 0; **/
 
-	BIGLOCK;
+	__UCLIBC_MUTEX_LOCK(__resolv_lock);
 	if(__searchdomains) {
 		int i;
 		for(i=0; i<__searchdomains; i++) {
@@ -1139,7 +1127,7 @@ int res_init(void)
 		}
 	}
 	rp->nscount = __nameservers;
-	BIGUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 
 	return(0);
 }
@@ -1175,10 +1163,10 @@ int res_query(const char *dname, int cla
 
 	memset((char *) &a, '\0', sizeof(a));
 
-	BIGLOCK;
+	__UCLIBC_MUTEX_LOCK(__resolv_lock);
 	__nameserversXX=__nameservers;
 	__nameserverXX=__nameserver;
-	BIGUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 	i = __dns_lookup(dname, type, __nameserversXX, __nameserverXX, &packet, &a);
 
 	if (i < 0) {
@@ -1207,10 +1195,10 @@ int res_query(const char *dname, int cla
  * is detected.  Error code, if any, is left in h_errno.
  */
 int res_search(name, class, type, answer, anslen)
-	const char *name;	/* domain name */
-	int class, type;	/* class and type of query */
-	u_char *answer;		/* buffer to put answer */
-	int anslen;		/* size of answer */
+	 const char *name;	/* domain name */
+	 int class, type;	/* class and type of query */
+	 u_char *answer;		/* buffer to put answer */
+	 int anslen;		/* size of answer */
 {
 	const char *cp, * const *domain;
 	HEADER *hp = (HEADER *)(void *)answer;
@@ -1256,11 +1244,11 @@ int res_search(name, class, type, answer
 		int done = 0;
 
 		for (domain = (const char * const *)_res.dnsrch;
-		   *domain && !done;
-		   domain++) {
+			 *domain && !done;
+			 domain++) {
 
 			ret = res_querydomain(name, *domain, class, type,
-			    answer, anslen);
+								  answer, anslen);
 			if (ret > 0)
 				return (ret);
 
@@ -1283,22 +1271,22 @@ int res_search(name, class, type, answer
 			}
 
 			switch (h_errno) {
-			case NO_DATA:
-				got_nodata++;
-				/* FALLTHROUGH */
-			case HOST_NOT_FOUND:
-				/* keep trying */
-				break;
-			case TRY_AGAIN:
-				if (hp->rcode == SERVFAIL) {
-					/* try next search element, if any */
-					got_servfail++;
+				case NO_DATA:
+					got_nodata++;
+					/* FALLTHROUGH */
+				case HOST_NOT_FOUND:
+					/* keep trying */
 					break;
-				}
-				/* FALLTHROUGH */
-			default:
-				/* anything else implies that we're done */
-				done++;
+				case TRY_AGAIN:
+					if (hp->rcode == SERVFAIL) {
+						/* try next search element, if any */
+						got_servfail++;
+						break;
+					}
+					/* FALLTHROUGH */
+				default:
+					/* anything else implies that we're done */
+					done++;
 			}
 			/*
 			 * if we got here for some reason other than DNSRCH,
@@ -1342,10 +1330,10 @@ int res_search(name, class, type, answer
  * removing a trailing dot from name if domain is NULL.
  */
 int res_querydomain(name, domain, class, type, answer, anslen)
-	const char *name, *domain;
-	int class, type;	/* class and type of query */
-	u_char *answer;		/* buffer to put answer */
-	int anslen;		/* size of answer */
+	 const char *name, *domain;
+	 int class, type;	/* class and type of query */
+	 u_char *answer;		/* buffer to put answer */
+	 int anslen;		/* size of answer */
 {
 	char nbuf[MAXDNAME];
 	const char *longname = nbuf;
@@ -1359,7 +1347,7 @@ int res_querydomain(name, domain, class,
 #ifdef DEBUG
 	if (_res.options & RES_DEBUG)
 		printf(";; res_querydomain(%s, %s, %d, %d)\n",
-			name, domain?domain:"<Nil>", class, type);
+			   name, domain?domain:"<Nil>", class, type);
 #endif
 	if (domain == NULL) {
 		/*
@@ -1400,11 +1388,11 @@ struct hostent *gethostbyaddr (const voi
 	static struct hostent h;
 	static char buf[
 #ifndef __UCLIBC_HAS_IPV6__
-		sizeof(struct in_addr) + sizeof(struct in_addr *)*2 +
+					sizeof(struct in_addr) + sizeof(struct in_addr *)*2 +
 #else
-		sizeof(struct in6_addr) + sizeof(struct in6_addr *)*2 +
+					sizeof(struct in6_addr) + sizeof(struct in6_addr *)*2 +
 #endif /* __UCLIBC_HAS_IPV6__ */
-		sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
+					sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
 	struct hostent *hp;
 
 	gethostbyaddr_r(addr, len, type, &h, buf, sizeof(buf), &hp, &h_errno);
@@ -1425,11 +1413,11 @@ void __open_etc_hosts(FILE **fp)
 }
 
 int __read_etc_hosts_r(FILE * fp, const char * name, int type,
-		     enum etc_hosts_action action,
-		     struct hostent * result_buf,
-		     char * buf, size_t buflen,
-		     struct hostent ** result,
-		     int * h_errnop)
+					   enum etc_hosts_action action,
+					   struct hostent * result_buf,
+					   char * buf, size_t buflen,
+					   struct hostent ** result,
+					   int * h_errnop)
 {
 	struct in_addr	*in=NULL;
 	struct in_addr	**addr_list=NULL;
@@ -1576,56 +1564,49 @@ int __read_etc_hosts_r(FILE * fp, const 
 
 #ifdef L_gethostent
 
-#ifdef __UCLIBC_HAS_THREADS__
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 static int __stay_open;
 static FILE * __gethostent_fp;
 
 void endhostent (void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     __stay_open = 0;
     if (__gethostent_fp) {
-	fclose(__gethostent_fp);
+		fclose(__gethostent_fp);
     }
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void sethostent (int stay_open)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     __stay_open = stay_open;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 int gethostent_r(struct hostent *result_buf, char *buf, size_t buflen,
-	struct hostent **result, int *h_errnop)
+				 struct hostent **result, int *h_errnop)
 {
-    int ret;
+    int ret = 0;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (__gethostent_fp == NULL) {
-	__open_etc_hosts(&__gethostent_fp);
-	if (__gethostent_fp == NULL) {
-	    UNLOCK;
-	    *result=NULL;
-	    return 0;
-	}
+		__open_etc_hosts(&__gethostent_fp);
+		if (__gethostent_fp == NULL) {
+			*result=NULL;
+			goto DONE;
+		}
     }
 
     ret = __read_etc_hosts_r(__gethostent_fp, NULL, AF_INET, GETHOSTENT,
-		   result_buf, buf, buflen, result, h_errnop);
+							 result_buf, buf, buflen, result, h_errnop);
     if (__stay_open==0) {
-	fclose(__gethostent_fp);
+		fclose(__gethostent_fp);
     }
-    UNLOCK;
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return(ret);
 }
 
@@ -1634,17 +1615,17 @@ struct hostent *gethostent (void)
     static struct hostent h;
     static char buf[
 #ifndef __UCLIBC_HAS_IPV6__
-	    sizeof(struct in_addr) + sizeof(struct in_addr *)*2 +
+					sizeof(struct in_addr) + sizeof(struct in_addr *)*2 +
 #else
-	    sizeof(struct in6_addr) + sizeof(struct in6_addr *)*2 +
+					sizeof(struct in6_addr) + sizeof(struct in6_addr *)*2 +
 #endif /* __UCLIBC_HAS_IPV6__ */
-		sizeof(char *)*(ALIAS_DIM) +
-	    80/*namebuffer*/ + 2/* margin */];
+					sizeof(char *)*(ALIAS_DIM) +
+					80/*namebuffer*/ + 2/* margin */];
     struct hostent *host;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     gethostent_r(&h, buf, sizeof(buf), &host, &h_errno);
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return(host);
 }
 #endif
@@ -1652,23 +1633,23 @@ struct hostent *gethostent (void)
 #ifdef L_get_hosts_byname_r
 
 int __get_hosts_byname_r(const char * name, int type,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop)
+						 struct hostent * result_buf,
+						 char * buf, size_t buflen,
+						 struct hostent ** result,
+						 int * h_errnop)
 {
 	return(__read_etc_hosts_r(NULL, name, type, GET_HOSTS_BYNAME,
-		    result_buf, buf, buflen, result, h_errnop));
+							  result_buf, buf, buflen, result, h_errnop));
 }
 #endif
 
 #ifdef L_get_hosts_byaddr_r
 
 int __get_hosts_byaddr_r(const char * addr, int len, int type,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop)
+						 struct hostent * result_buf,
+						 char * buf, size_t buflen,
+						 struct hostent ** result,
+						 int * h_errnop)
 {
 #ifndef __UCLIBC_HAS_IPV6__
 	char	ipaddr[INET_ADDRSTRLEN];
@@ -1677,24 +1658,24 @@ int __get_hosts_byaddr_r(const char * ad
 #endif /* __UCLIBC_HAS_IPV6__ */
 
     switch (type) {
-	case AF_INET:
-		if (len != sizeof(struct in_addr))
-			return 0;
-		break;
+		case AF_INET:
+			if (len != sizeof(struct in_addr))
+				return 0;
+			break;
 #ifdef __UCLIBC_HAS_IPV6__
-	case AF_INET6:
-		if (len != sizeof(struct in6_addr))
-			return 0;
-		break;
+		case AF_INET6:
+			if (len != sizeof(struct in6_addr))
+				return 0;
+			break;
 #endif /* __UCLIBC_HAS_IPV6__ */
-	default:
-		return 0;
+		default:
+			return 0;
 	}
 
 	inet_ntop(type, addr, ipaddr, sizeof(ipaddr));
 
 	return(__read_etc_hosts_r(NULL, ipaddr, type, GET_HOSTS_BYADDR,
-		    result_buf, buf, buflen, result, h_errnop));
+							  result_buf, buf, buflen, result, h_errnop));
 }
 #endif
 
@@ -1705,8 +1686,8 @@ int __get_hosts_byaddr_r(const char * ad
 #endif /* min */
 
 int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
-	     socklen_t hostlen, char *serv, socklen_t servlen,
-	     unsigned int flags)
+				 socklen_t hostlen, char *serv, socklen_t servlen,
+				 unsigned int flags)
 {
 	int serrno = errno;
 	int ok = 0;
@@ -1720,167 +1701,167 @@ int getnameinfo (const struct sockaddr *
 		return EAI_FAMILY;
 
 	switch (sa->sa_family) {
-	case AF_LOCAL:
-		break;
-	case AF_INET:
-		if (addrlen < sizeof (struct sockaddr_in))
-			return EAI_FAMILY;
-		break;
+		case AF_LOCAL:
+			break;
+		case AF_INET:
+			if (addrlen < sizeof (struct sockaddr_in))
+				return EAI_FAMILY;
+			break;
 #ifdef __UCLIBC_HAS_IPV6__
-	case AF_INET6:
-		if (addrlen < sizeof (struct sockaddr_in6))
-			return EAI_FAMILY;
-		break;
+		case AF_INET6:
+			if (addrlen < sizeof (struct sockaddr_in6))
+				return EAI_FAMILY;
+			break;
 #endif /* __UCLIBC_HAS_IPV6__ */
-	default:
-		return EAI_FAMILY;
+		default:
+			return EAI_FAMILY;
 	}
 
 	if (host != NULL && hostlen > 0)
 		switch (sa->sa_family) {
-		case AF_INET:
+			case AF_INET:
 #ifdef __UCLIBC_HAS_IPV6__
-		case AF_INET6:
+			case AF_INET6:
 #endif /* __UCLIBC_HAS_IPV6__ */
-			if (!(flags & NI_NUMERICHOST)) {
+				if (!(flags & NI_NUMERICHOST)) {
 #ifdef __UCLIBC_HAS_IPV6__
-				if (sa->sa_family == AF_INET6)
-					h = gethostbyaddr ((const void *)
-						&(((const struct sockaddr_in6 *) sa)->sin6_addr),
-						sizeof(struct in6_addr), AF_INET6);
-				else
-#endif /* __UCLIBC_HAS_IPV6__ */
-                    h = gethostbyaddr ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
-					  sizeof(struct in_addr), AF_INET);
-
-				if (h) {
-					char *c;
-					if ((flags & NI_NOFQDN)
-					    && (getdomainname (domain, sizeof(domain)) == 0)
-					    && (c = strstr (h->h_name, domain))
-					    && (c != h->h_name) && (*(--c) == '.')) {
-						strncpy (host, h->h_name,
-							min(hostlen, (size_t) (c - h->h_name)));
-						host[min(hostlen - 1, (size_t) (c - h->h_name))] = '\0';
-						ok = 1;
-					} else {
-						strncpy (host, h->h_name, hostlen);
-						ok = 1;
+					if (sa->sa_family == AF_INET6)
+						h = gethostbyaddr ((const void *)
+										   &(((const struct sockaddr_in6 *) sa)->sin6_addr),
+										   sizeof(struct in6_addr), AF_INET6);
+					else
+#endif /* __UCLIBC_HAS_IPV6__ */
+						h = gethostbyaddr ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
+										   sizeof(struct in_addr), AF_INET);
+
+					if (h) {
+						char *c;
+						if ((flags & NI_NOFQDN)
+							&& (getdomainname (domain, sizeof(domain)) == 0)
+							&& (c = strstr (h->h_name, domain))
+							&& (c != h->h_name) && (*(--c) == '.')) {
+							strncpy (host, h->h_name,
+									 min(hostlen, (size_t) (c - h->h_name)));
+							host[min(hostlen - 1, (size_t) (c - h->h_name))] = '\0';
+							ok = 1;
+						} else {
+							strncpy (host, h->h_name, hostlen);
+							ok = 1;
+						}
 					}
-				 }
-			}
+				}
 
-			if (!ok) {
-				if (flags & NI_NAMEREQD) {
-					errno = serrno;
-					return EAI_NONAME;
-				} else {
-					const char *c;
+				if (!ok) {
+					if (flags & NI_NAMEREQD) {
+						errno = serrno;
+						return EAI_NONAME;
+					} else {
+						const char *c;
 #ifdef __UCLIBC_HAS_IPV6__
-					if (sa->sa_family == AF_INET6) {
-						const struct sockaddr_in6 *sin6p;
+						if (sa->sa_family == AF_INET6) {
+							const struct sockaddr_in6 *sin6p;
 
-						sin6p = (const struct sockaddr_in6 *) sa;
+							sin6p = (const struct sockaddr_in6 *) sa;
 
-						c = inet_ntop (AF_INET6,
-							(const void *) &sin6p->sin6_addr, host, hostlen);
+							c = inet_ntop (AF_INET6,
+										   (const void *) &sin6p->sin6_addr, host, hostlen);
 #if 0
-						/* Does scope id need to be supported? */
-						uint32_t scopeid;
-						scopeid = sin6p->sin6_scope_id;
-						if (scopeid != 0) {
-							/* Buffer is >= IFNAMSIZ+1.  */
-							char scopebuf[IFNAMSIZ + 1];
-							char *scopeptr;
-							int ni_numericscope = 0;
-							size_t real_hostlen = __strnlen (host, hostlen);
-							size_t scopelen = 0;
-
-							scopebuf[0] = SCOPE_DELIMITER;
-							scopebuf[1] = '\0';
-							scopeptr = &scopebuf[1];
-
-							if (IN6_IS_ADDR_LINKLOCAL (&sin6p->sin6_addr)
-							    || IN6_IS_ADDR_MC_LINKLOCAL (&sin6p->sin6_addr)) {
-								if (if_indextoname (scopeid, scopeptr) == NULL)
+							/* Does scope id need to be supported? */
+							uint32_t scopeid;
+							scopeid = sin6p->sin6_scope_id;
+							if (scopeid != 0) {
+								/* Buffer is >= IFNAMSIZ+1.  */
+								char scopebuf[IFNAMSIZ + 1];
+								char *scopeptr;
+								int ni_numericscope = 0;
+								size_t real_hostlen = __strnlen (host, hostlen);
+								size_t scopelen = 0;
+
+								scopebuf[0] = SCOPE_DELIMITER;
+								scopebuf[1] = '\0';
+								scopeptr = &scopebuf[1];
+
+								if (IN6_IS_ADDR_LINKLOCAL (&sin6p->sin6_addr)
+									|| IN6_IS_ADDR_MC_LINKLOCAL (&sin6p->sin6_addr)) {
+									if (if_indextoname (scopeid, scopeptr) == NULL)
+										++ni_numericscope;
+									else
+										scopelen = strlen (scopebuf);
+								} else {
 									++ni_numericscope;
-								else
-									scopelen = strlen (scopebuf);
-							} else {
-								++ni_numericscope;
-							}
+								}
 
-							if (ni_numericscope)
-								scopelen = 1 + snprintf (scopeptr,
-									(scopebuf
-									+ sizeof scopebuf
-									- scopeptr),
-									"%u", scopeid);
-
-							if (real_hostlen + scopelen + 1 > hostlen)
-								return EAI_SYSTEM;
-							memcpy (host + real_hostlen, scopebuf, scopelen + 1);
-						}
+								if (ni_numericscope)
+									scopelen = 1 + snprintf (scopeptr,
+															 (scopebuf
+															  + sizeof scopebuf
+															  - scopeptr),
+															 "%u", scopeid);
+
+								if (real_hostlen + scopelen + 1 > hostlen)
+									return EAI_SYSTEM;
+								memcpy (host + real_hostlen, scopebuf, scopelen + 1);
+							}
 #endif
-					} else
+						} else
 #endif /* __UCLIBC_HAS_IPV6__ */
-						c = inet_ntop (AF_INET, (const void *)
-							&(((const struct sockaddr_in *) sa)->sin_addr),
-							host, hostlen);
-
-					if (c == NULL) {
-						errno = serrno;
-						return EAI_SYSTEM;
+							c = inet_ntop (AF_INET, (const void *)
+										   &(((const struct sockaddr_in *) sa)->sin_addr),
+										   host, hostlen);
+
+						if (c == NULL) {
+							errno = serrno;
+							return EAI_SYSTEM;
+						}
 					}
+					ok = 1;
 				}
-				ok = 1;
-			}
-			break;
-
-		case AF_LOCAL:
-			if (!(flags & NI_NUMERICHOST)) {
-				struct utsname utsname;
+				break;
 
-				if (!uname (&utsname)) {
-					strncpy (host, utsname.nodename, hostlen);
-					break;
+			case AF_LOCAL:
+				if (!(flags & NI_NUMERICHOST)) {
+					struct utsname utsname;
+
+					if (!uname (&utsname)) {
+						strncpy (host, utsname.nodename, hostlen);
+						break;
+					};
 				};
-			};
 
-			if (flags & NI_NAMEREQD) {
-				errno = serrno;
-				return EAI_NONAME;
-			}
+				if (flags & NI_NAMEREQD) {
+					errno = serrno;
+					return EAI_NONAME;
+				}
 
-			strncpy (host, "localhost", hostlen);
-			break;
+				strncpy (host, "localhost", hostlen);
+				break;
 
-		default:
-			return EAI_FAMILY;
-	}
+			default:
+				return EAI_FAMILY;
+		}
 
 	if (serv && (servlen > 0)) {
 		switch (sa->sa_family) {
-		case AF_INET:
+			case AF_INET:
 #ifdef __UCLIBC_HAS_IPV6__
-		case AF_INET6:
+			case AF_INET6:
 #endif /* __UCLIBC_HAS_IPV6__ */
-			if (!(flags & NI_NUMERICSERV)) {
-				struct servent *s;
-				s = getservbyport (((const struct sockaddr_in *) sa)->sin_port,
-				      ((flags & NI_DGRAM) ? "udp" : "tcp"));
-				if (s) {
-					strncpy (serv, s->s_name, servlen);
-					break;
+				if (!(flags & NI_NUMERICSERV)) {
+					struct servent *s;
+					s = getservbyport (((const struct sockaddr_in *) sa)->sin_port,
+									   ((flags & NI_DGRAM) ? "udp" : "tcp"));
+					if (s) {
+						strncpy (serv, s->s_name, servlen);
+						break;
+					}
 				}
-			}
-			snprintf (serv, servlen, "%d",
-				ntohs (((const struct sockaddr_in *) sa)->sin_port));
-			break;
+				snprintf (serv, servlen, "%d",
+						  ntohs (((const struct sockaddr_in *) sa)->sin_port));
+				break;
 
-		case AF_LOCAL:
-			strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
-			break;
+			case AF_LOCAL:
+				strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
+				break;
 		}
 	}
 	if (host && (hostlen > 0))
@@ -1896,10 +1877,10 @@ int getnameinfo (const struct sockaddr *
 #ifdef L_gethostbyname_r
 
 int gethostbyname_r(const char * name,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop)
+					struct hostent * result_buf,
+					char * buf, size_t buflen,
+					struct hostent ** result,
+					int * h_errnop)
 {
 	struct in_addr *in;
 	struct in_addr **addr_list;
@@ -1921,7 +1902,7 @@ int gethostbyname_r(const char * name,
 		__set_errno(0);			/* to check for missing /etc/hosts. */
 
 		if ((i=__get_hosts_byname_r(name, AF_INET, result_buf,
-				buf, buflen, result, h_errnop))==0)
+									buf, buflen, result, h_errnop))==0)
 			return i;
 		switch (*h_errnop) {
 			case HOST_NOT_FOUND:
@@ -1983,60 +1964,60 @@ int gethostbyname_r(const char * name,
 
 	for (;;) {
 
-	    BIGLOCK;
+	    __UCLIBC_MUTEX_LOCK(__resolv_lock);
 	    __nameserversXX=__nameservers;
 	    __nameserverXX=__nameserver;
-	    BIGUNLOCK;
+	    __UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 	    a.buf = buf;
 	    a.buflen = buflen;
 	    a.add_count = 0;
 	    i = __dns_lookup(name, T_A, __nameserversXX, __nameserverXX, &packet, &a);
 
 	    if (i < 0) {
-		*h_errnop = HOST_NOT_FOUND;
-		DPRINTF("__dns_lookup\n");
-		return TRY_AGAIN;
+			*h_errnop = HOST_NOT_FOUND;
+			DPRINTF("__dns_lookup\n");
+			return TRY_AGAIN;
 	    }
 
 	    if ((a.rdlength + sizeof(struct in_addr*)) * a.add_count + 256 > buflen)
-	    {
-		free(a.dotted);
-		free(packet);
-		*h_errnop = NETDB_INTERNAL;
-		DPRINTF("buffer too small for all addresses\n");
-		return ERANGE;
-	    }
+			{
+				free(a.dotted);
+				free(packet);
+				*h_errnop = NETDB_INTERNAL;
+				DPRINTF("buffer too small for all addresses\n");
+				return ERANGE;
+			}
 	    else if(a.add_count > 0)
-	    {
-		memmove(buf - sizeof(struct in_addr*)*2, buf, a.add_count * a.rdlength);
-		addr_list = (struct in_addr**)(buf + a.add_count * a.rdlength);
-		addr_list[0] = in;
-		for (i = a.add_count-1; i>=0; --i)
-		    addr_list[i+1] = (struct in_addr*)(buf - sizeof(struct in_addr*)*2 + a.rdlength * i);
-		addr_list[a.add_count + 1] = 0;
-		buflen -= (((char*)&(addr_list[a.add_count + 2])) - buf);
-		buf = (char*)&addr_list[a.add_count + 2];
-	    }
+			{
+				memmove(buf - sizeof(struct in_addr*)*2, buf, a.add_count * a.rdlength);
+				addr_list = (struct in_addr**)(buf + a.add_count * a.rdlength);
+				addr_list[0] = in;
+				for (i = a.add_count-1; i>=0; --i)
+					addr_list[i+1] = (struct in_addr*)(buf - sizeof(struct in_addr*)*2 + a.rdlength * i);
+				addr_list[a.add_count + 1] = 0;
+				buflen -= (((char*)&(addr_list[a.add_count + 2])) - buf);
+				buf = (char*)&addr_list[a.add_count + 2];
+			}
 
 	    strncpy(buf, a.dotted, buflen);
 	    free(a.dotted);
 
 	    if (a.atype == T_A) { /* ADDRESS */
-		memcpy(in, a.rdata, sizeof(*in));
-		result_buf->h_name = buf;
-		result_buf->h_addrtype = AF_INET;
-		result_buf->h_length = sizeof(*in);
-		result_buf->h_addr_list = (char **) addr_list;
+			memcpy(in, a.rdata, sizeof(*in));
+			result_buf->h_name = buf;
+			result_buf->h_addrtype = AF_INET;
+			result_buf->h_length = sizeof(*in);
+			result_buf->h_addr_list = (char **) addr_list;
 #ifdef __UCLIBC_MJN3_ONLY__
 #warning TODO -- generate the full list
 #endif
-		result_buf->h_aliases = alias; /* TODO: generate the full list */
-		free(packet);
-		break;
+			result_buf->h_aliases = alias; /* TODO: generate the full list */
+			free(packet);
+			break;
 	    } else {
-		free(packet);
-		*h_errnop=HOST_NOT_FOUND;
-		return TRY_AGAIN;
+			free(packet);
+			*h_errnop=HOST_NOT_FOUND;
+			return TRY_AGAIN;
 	    }
 	}
 
@@ -2049,14 +2030,14 @@ int gethostbyname_r(const char * name,
 #ifdef L_gethostbyname2_r
 
 int gethostbyname2_r(const char *name, int family,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop)
+					 struct hostent * result_buf,
+					 char * buf, size_t buflen,
+					 struct hostent ** result,
+					 int * h_errnop)
 {
 #ifndef __UCLIBC_HAS_IPV6__
 	return family == (AF_INET)? gethostbyname_r(name, result_buf,
-		buf, buflen, result, h_errnop) : HOST_NOT_FOUND;
+												buf, buflen, result, h_errnop) : HOST_NOT_FOUND;
 #else /* __UCLIBC_HAS_IPV6__ */
 	struct in6_addr *in;
 	struct in6_addr **addr_list;
@@ -2084,7 +2065,7 @@ int gethostbyname2_r(const char *name, i
 		__set_errno(0);			/* to check for missing /etc/hosts. */
 
 		if ((i=__get_hosts_byname_r(name, AF_INET, result_buf,
-				buf, buflen, result, h_errnop))==0)
+									buf, buflen, result, h_errnop))==0)
 			return i;
 		switch (*h_errnop) {
 			case HOST_NOT_FOUND:
@@ -2137,10 +2118,10 @@ int gethostbyname2_r(const char *name, i
 	memset((char *) &a, '\0', sizeof(a));
 
 	for (;;) {
-	BIGLOCK;
-	__nameserversXX=__nameservers;
-	__nameserverXX=__nameserver;
-	BIGUNLOCK;
+		__UCLIBC_MUTEX_LOCK(__resolv_lock);
+		__nameserversXX=__nameservers;
+		__nameserverXX=__nameserver;
+		__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 
 		i = __dns_lookup(buf, T_AAAA, __nameserversXX, __nameserverXX, &packet, &a);
 
@@ -2190,10 +2171,10 @@ int gethostbyname2_r(const char *name, i
 
 #ifdef L_gethostbyaddr_r
 int gethostbyaddr_r (const void *addr, socklen_t len, int type,
-			    struct hostent * result_buf,
-			    char * buf, size_t buflen,
-			    struct hostent ** result,
-			    int * h_errnop)
+					 struct hostent * result_buf,
+					 char * buf, size_t buflen,
+					 struct hostent ** result,
+					 int * h_errnop)
 
 {
 	struct in_addr *in;
@@ -2234,7 +2215,7 @@ int gethostbyaddr_r (const void *addr, s
 
 	/* do /etc/hosts first */
 	if ((i=__get_hosts_byaddr_r(addr, len, type, result_buf,
-				  buf, buflen, result, h_errnop))==0)
+								buf, buflen, result, h_errnop))==0)
 		return i;
 	switch (*h_errnop) {
 		case HOST_NOT_FOUND:
@@ -2294,7 +2275,7 @@ int gethostbyaddr_r (const void *addr, s
 		addr_list[0] = in;
 
 		sprintf(buf, "%u.%u.%u.%u.in-addr.arpa",
-			tmp_addr[3], tmp_addr[2], tmp_addr[1], tmp_addr[0]);
+				tmp_addr[3], tmp_addr[2], tmp_addr[1], tmp_addr[0]);
 #ifdef __UCLIBC_HAS_IPV6__
 	} else {
 		memcpy(in6->s6_addr, addr, len);
@@ -2304,7 +2285,7 @@ int gethostbyaddr_r (const void *addr, s
 
 		for (i = len - 1; i >= 0; i--) {
 			qp += sprintf(qp, "%x.%x.", in6->s6_addr[i] & 0xf,
-				(in6->s6_addr[i] >> 4) & 0xf);
+						  (in6->s6_addr[i] >> 4) & 0xf);
     	}
     	strcpy(qp, "ip6.int");
 #endif /* __UCLIBC_HAS_IPV6__ */
@@ -2314,10 +2295,10 @@ int gethostbyaddr_r (const void *addr, s
 
 	for (;;) {
 
-	BIGLOCK;
-	__nameserversXX=__nameservers;
-	__nameserverXX=__nameserver;
-	BIGUNLOCK;
+		__UCLIBC_MUTEX_LOCK(__resolv_lock);
+		__nameserversXX=__nameservers;
+		__nameserverXX=__nameserver;
+		__UCLIBC_MUTEX_UNLOCK(__resolv_lock);
 		i = __dns_lookup(buf, T_PTR, __nameserversXX, __nameserverXX, &packet, &a);
 
 		if (i < 0) {
@@ -2381,7 +2362,7 @@ int gethostbyaddr_r (const void *addr, s
  * Return size of compressed name or -1 if there was an error.
  */
 int __dn_expand(const u_char *msg, const u_char *eom, const u_char *src,
-          char *dst, int dstsiz)
+				char *dst, int dstsiz)
 {
 	int n = ns_name_uncompress(msg, eom, src, dst, (size_t)dstsiz);
 
@@ -2401,7 +2382,7 @@ int __dn_expand(const u_char *msg, const
  */
 static int printable(int ch)
 {
-        return (ch > 0x20 && ch < 0x7f);
+	return (ch > 0x20 && ch < 0x7f);
 }
 
 /*
@@ -2413,18 +2394,18 @@ static int printable(int ch)
  */
 static int special(int ch)
 {
-        switch (ch) {
+	switch (ch) {
         case 0x22: /* '"' */
         case 0x2E: /* '.' */
         case 0x3B: /* ';' */
         case 0x5C: /* '\\' */
-        /* Special modifiers in zone files. */
+			/* Special modifiers in zone files. */
         case 0x40: /* '@' */
         case 0x24: /* '$' */
-                return (1);
+			return (1);
         default:
-                return (0);
-        }
+			return (0);
+	}
 }
 
 /*
@@ -2436,7 +2417,7 @@ static int special(int ch)
  *      Root domain returns as "." not "".
  */
 int __ns_name_uncompress(const u_char *msg, const u_char *eom,
-		const u_char *src, char *dst, size_t dstsiz)
+						 const u_char *src, char *dst, size_t dstsiz)
 {
 	u_char tmp[NS_MAXCDNAME];
 	int n;
@@ -2525,7 +2506,7 @@ int __ns_name_ntop(const u_char *src, ch
 		return (-1);
 	}
 	*dn++ = '\0';
-        return (dn - dst);
+	return (dn - dst);
 }
 
 /*
@@ -2535,7 +2516,7 @@ int __ns_name_ntop(const u_char *src, ch
  *      -1 if it fails, or consumed octets if it succeeds.
  */
 int __ns_name_unpack(const u_char *msg, const u_char *eom, const u_char *src,
-               u_char *dst, size_t dstsiz)
+					 u_char *dst, size_t dstsiz)
 {
 	const u_char *srcp, *dstlim;
 	u_char *dstp;
@@ -2554,46 +2535,46 @@ int __ns_name_unpack(const u_char *msg, 
 	while ((n = *srcp++) != 0) {
 		/* Check for indirection. */
 		switch (n & NS_CMPRSFLGS) {
-		case 0:
-			/* Limit checks. */
-			if (dstp + n + 1 >= dstlim || srcp + n >= eom) {
-				__set_errno (EMSGSIZE);
-				return (-1);
-			}
-			checked += n + 1;
-			*dstp++ = n;
-			memcpy(dstp, srcp, n);
-			dstp += n;
-			srcp += n;
-			break;
+			case 0:
+				/* Limit checks. */
+				if (dstp + n + 1 >= dstlim || srcp + n >= eom) {
+					__set_errno (EMSGSIZE);
+					return (-1);
+				}
+				checked += n + 1;
+				*dstp++ = n;
+				memcpy(dstp, srcp, n);
+				dstp += n;
+				srcp += n;
+				break;
 
-		case NS_CMPRSFLGS:
-			if (srcp >= eom) {
-				__set_errno (EMSGSIZE);
-				return (-1);
-			}
-			if (len < 0)
-				len = srcp - src + 1;
-			srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff));
-			if (srcp < msg || srcp >= eom) {  /* Out of range. */
-				__set_errno (EMSGSIZE);
-				return (-1);
-			}
-			checked += 2;
-			/*
-			 * Check for loops in the compressed name;
-			 * if we've looked at the whole message,
-			 * there must be a loop.
-			 */
-			if (checked >= eom - msg) {
-				__set_errno (EMSGSIZE);
-				return (-1);
-			}
-			break;
+			case NS_CMPRSFLGS:
+				if (srcp >= eom) {
+					__set_errno (EMSGSIZE);
+					return (-1);
+				}
+				if (len < 0)
+					len = srcp - src + 1;
+				srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff));
+				if (srcp < msg || srcp >= eom) {  /* Out of range. */
+					__set_errno (EMSGSIZE);
+					return (-1);
+				}
+				checked += 2;
+				/*
+				 * Check for loops in the compressed name;
+				 * if we've looked at the whole message,
+				 * there must be a loop.
+				 */
+				if (checked >= eom - msg) {
+					__set_errno (EMSGSIZE);
+					return (-1);
+				}
+				break;
 
-		default:
-			__set_errno (EMSGSIZE);
-			return (-1);                    /* flag error */
+			default:
+				__set_errno (EMSGSIZE);
+				return (-1);                    /* flag error */
 		}
 	}
 	*dstp = '\0';
diff --git a/libc/inet/rpc/create_xid.c b/libc/inet/rpc/create_xid.c
index cbb961e..c86cbb4 100644
--- a/libc/inet/rpc/create_xid.c
+++ b/libc/inet/rpc/create_xid.c
@@ -27,15 +27,7 @@
 
 /* The RPC code is not threadsafe, but new code should be threadsafe. */
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t createxid_lock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&createxid_lock)
-# define UNLOCK	__pthread_mutex_unlock(&createxid_lock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 static int is_initialized;
 static struct drand48_data __rpc_lrand48_data;
@@ -43,22 +35,22 @@ static struct drand48_data __rpc_lrand48
 unsigned long
 _create_xid (void)
 {
-  unsigned long res;
+	unsigned long res;
 
-  LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
-  if (!is_initialized)
-    {
-      struct timeval now;
+	if (!is_initialized)
+		{
+			struct timeval now;
 
-      gettimeofday (&now, (struct timezone *) 0);
-      srand48_r (now.tv_sec ^ now.tv_usec, &__rpc_lrand48_data);
-      is_initialized = 1;
-    }
+			gettimeofday (&now, (struct timezone *) 0);
+			srand48_r (now.tv_sec ^ now.tv_usec, &__rpc_lrand48_data);
+			is_initialized = 1;
+		}
 
-  lrand48_r (&__rpc_lrand48_data, &res);
+	lrand48_r (&__rpc_lrand48_data, &res);
 
-  UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
-  return res;
+	return res;
 }
diff --git a/libc/misc/dirent/closedir.c b/libc/misc/dirent/closedir.c
index 068e2d3..56adb23 100644
--- a/libc/misc/dirent/closedir.c
+++ b/libc/misc/dirent/closedir.c
@@ -4,7 +4,6 @@
 #include <unistd.h>
 #include "dirstream.h"
 
-
 int closedir(DIR * dir)
 {
 	int fd;
@@ -19,14 +18,10 @@ int closedir(DIR * dir)
 		__set_errno(EBADF);
 		return -1;
 	}
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 	fd = dir->dd_fd;
 	dir->dd_fd = -1;
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
 	free(dir->dd_buf);
 	free(dir);
 	return close(fd);
diff --git a/libc/misc/dirent/dirstream.h b/libc/misc/dirent/dirstream.h
index 2dd0264..bd721c5 100644
--- a/libc/misc/dirent/dirstream.h
+++ b/libc/misc/dirent/dirstream.h
@@ -26,9 +26,8 @@ Cambridge, MA 02139, USA.  */
 
 #include <features.h>
 #include <sys/types.h>
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-#endif
+
+#include <bits/uClibc_mutex.h>
 
 /* For now, syscall readdir () only supports one entry at a time. It
  * will be changed in the future.
@@ -63,11 +62,7 @@ struct __dirstream {
   size_t dd_max;
  
   /* lock */
-#ifdef __UCLIBC_HAS_THREADS__
-  pthread_mutex_t dd_lock;
-#else
-  void *dd_lock;
-#endif
+  __UCLIBC_MUTEX(dd_lock);
 };				/* stream data from opendir() */
 
 
diff --git a/libc/misc/dirent/readdir.c b/libc/misc/dirent/readdir.c
index 1f196e1..c55317a 100644
--- a/libc/misc/dirent/readdir.c
+++ b/libc/misc/dirent/readdir.c
@@ -5,7 +5,6 @@
 #include <dirent.h>
 #include "dirstream.h"
 
-
 struct dirent *readdir(DIR * dir)
 {
 	ssize_t bytes;
@@ -16,9 +15,7 @@ struct dirent *readdir(DIR * dir)
 		return NULL;
 	}
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 
 	do {
 	    if (dir->dd_size <= dir->dd_nextloc) {
@@ -44,8 +41,6 @@ struct dirent *readdir(DIR * dir)
 	} while (de->d_ino == 0);
 
 all_done:
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
 	return de;
 }
diff --git a/libc/misc/dirent/readdir64.c b/libc/misc/dirent/readdir64.c
index f798c6f..6da3b0d 100644
--- a/libc/misc/dirent/readdir64.c
+++ b/libc/misc/dirent/readdir64.c
@@ -20,7 +20,6 @@
 #include <dirent.h>
 #include "dirstream.h"
 
-
 struct dirent64 *readdir64(DIR * dir)
 {
 	ssize_t bytes;
@@ -31,9 +30,7 @@ struct dirent64 *readdir64(DIR * dir)
 		return NULL;
 	}
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 
 	do {
 	    if (dir->dd_size <= dir->dd_nextloc) {
@@ -59,9 +56,7 @@ struct dirent64 *readdir64(DIR * dir)
 	} while (de->d_ino == 0);
 
 all_done:
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
 
 	return de;
 }
diff --git a/libc/misc/dirent/readdir64_r.c b/libc/misc/dirent/readdir64_r.c
index da3564e..cc96eff 100644
--- a/libc/misc/dirent/readdir64_r.c
+++ b/libc/misc/dirent/readdir64_r.c
@@ -19,7 +19,6 @@
 #include <dirent.h>
 #include "dirstream.h"
 
-
 int readdir64_r(DIR *dir, struct dirent64 *entry, struct dirent64 **result)
 {
 	int ret;
@@ -32,21 +31,19 @@ int readdir64_r(DIR *dir, struct dirent6
 	}
 	de = NULL;
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 
 	do {
 	    if (dir->dd_size <= dir->dd_nextloc) {
-		/* read dir->dd_max bytes of directory entries. */
-		bytes = __getdents64(dir->dd_fd, dir->dd_buf, dir->dd_max);
-		if (bytes <= 0) {
-		    *result = NULL;
-		    ret = errno;
-		    goto all_done;
-		}
-		dir->dd_size = bytes;
-		dir->dd_nextloc = 0;
+			/* read dir->dd_max bytes of directory entries. */
+			bytes = __getdents64(dir->dd_fd, dir->dd_buf, dir->dd_max);
+			if (bytes <= 0) {
+				*result = NULL;
+				ret = errno;
+				goto all_done;
+			}
+			dir->dd_size = bytes;
+			dir->dd_nextloc = 0;
 	    }
 
 	    de = (struct dirent64 *) (((char *) dir->dd_buf) + dir->dd_nextloc);
@@ -66,12 +63,10 @@ int readdir64_r(DIR *dir, struct dirent6
 	}
 	ret = 0;
 
-all_done:
+ all_done:
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
-        return((de != NULL)? 0 : ret);
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
+	return((de != NULL)? 0 : ret);
 }
 #endif /* __UCLIBC_HAS_LFS__ */
 
diff --git a/libc/misc/dirent/readdir_r.c b/libc/misc/dirent/readdir_r.c
index 245dcbd..aeccdd8 100644
--- a/libc/misc/dirent/readdir_r.c
+++ b/libc/misc/dirent/readdir_r.c
@@ -5,7 +5,6 @@
 #include <dirent.h>
 #include "dirstream.h"
 
-
 int readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
 {
 	int ret;
@@ -18,21 +17,19 @@ int readdir_r(DIR *dir, struct dirent *e
 	}
 	de = NULL;
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 
 	do {
 	    if (dir->dd_size <= dir->dd_nextloc) {
-		/* read dir->dd_max bytes of directory entries. */
-		bytes = __getdents(dir->dd_fd, dir->dd_buf, dir->dd_max);
-		if (bytes <= 0) {
-		    *result = NULL;
-		    ret = errno;
-		    goto all_done;
-		}
-		dir->dd_size = bytes;
-		dir->dd_nextloc = 0;
+			/* read dir->dd_max bytes of directory entries. */
+			bytes = __getdents(dir->dd_fd, dir->dd_buf, dir->dd_max);
+			if (bytes <= 0) {
+				*result = NULL;
+				ret = errno;
+				goto all_done;
+			}
+			dir->dd_size = bytes;
+			dir->dd_nextloc = 0;
 	    }
 
 	    de = (struct dirent *) (((char *) dir->dd_buf) + dir->dd_nextloc);
@@ -52,10 +49,8 @@ int readdir_r(DIR *dir, struct dirent *e
 	}
 	ret = 0;
 
-all_done:
+ all_done:
 
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
-        return((de != NULL)? 0 : ret);
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
+	return((de != NULL)? 0 : ret);
 }
diff --git a/libc/misc/dirent/rewinddir.c b/libc/misc/dirent/rewinddir.c
index 60ef71d..fe8fc2a 100644
--- a/libc/misc/dirent/rewinddir.c
+++ b/libc/misc/dirent/rewinddir.c
@@ -3,7 +3,6 @@
 #include <unistd.h>
 #include "dirstream.h"
 
-
 /* rewinddir() just does an lseek(fd,0,0) - see close for comments */
 void rewinddir(DIR * dir)
 {
@@ -11,12 +10,8 @@ void rewinddir(DIR * dir)
 		__set_errno(EBADF);
 		return;
 	}
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 	lseek(dir->dd_fd, 0, SEEK_SET);
 	dir->dd_nextoff = dir->dd_nextloc = dir->dd_size = 0;
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
 }
diff --git a/libc/misc/dirent/seekdir.c b/libc/misc/dirent/seekdir.c
index 139f1e1..6d6f5f0 100644
--- a/libc/misc/dirent/seekdir.c
+++ b/libc/misc/dirent/seekdir.c
@@ -3,19 +3,14 @@
 #include <unistd.h>
 #include "dirstream.h"
 
-
 void seekdir(DIR * dir, long int offset)
 {
 	if (!dir) {
 		__set_errno(EBADF);
 		return;
 	}
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_lock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_LOCK(dir->dd_lock);
 	dir->dd_nextoff = lseek(dir->dd_fd, offset, SEEK_SET);
 	dir->dd_size = dir->dd_nextloc = 0;
-#ifdef __UCLIBC_HAS_THREADS__
-	__pthread_mutex_unlock(&(dir->dd_lock));
-#endif
+	__UCLIBC_MUTEX_UNLOCK(dir->dd_lock);
 }
diff --git a/libc/misc/mntent/mntent.c b/libc/misc/mntent/mntent.c
index d98a687..af6d848 100644
--- a/libc/misc/mntent/mntent.c
+++ b/libc/misc/mntent/mntent.c
@@ -3,15 +3,9 @@
 #include <string.h>
 #include <mntent.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 /* Reentrant version of getmntent.  */
 struct mntent *getmntent_r (FILE *filep, 
@@ -67,7 +61,7 @@ struct mntent *getmntent(FILE * filep)
     struct mntent *tmp;
     static char *buff = NULL;
     static struct mntent mnt;
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     
     if (!buff) {
             buff = malloc(BUFSIZ);
@@ -76,7 +70,7 @@ struct mntent *getmntent(FILE * filep)
     }
     
     tmp = getmntent_r(filep, &mnt, buff, BUFSIZ);
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return(tmp);
 }
 
diff --git a/libc/misc/pthread/weaks.c b/libc/misc/pthread/weaks.c
index 89c2611..c27bd10 100644
--- a/libc/misc/pthread/weaks.c
+++ b/libc/misc/pthread/weaks.c
@@ -21,6 +21,7 @@
 #include <limits.h>
 #include <stdlib.h>
 
+static void __pthread_return_void __P ((void));
 static int __pthread_return_0 __P ((void));
 static int __pthread_return_1 __P ((void));
 
@@ -104,8 +105,17 @@ weak_alias (__pthread_return_0, __pthrea
 weak_alias (__pthread_return_0, __pthread_mutex_trylock)
 weak_alias (__pthread_return_0, __pthread_mutex_unlock)
 
+weak_alias (__pthread_return_void, _pthread_cleanup_push_defer)
+weak_alias (__pthread_return_void, _pthread_cleanup_pop_restore)
+
 /**********************************************************************/
 
+static void
+__pthread_return_void (void)
+{
+  return;
+}
+
 static int
 __pthread_return_0 (void)
 {
diff --git a/libc/misc/syslog/syslog.c b/libc/misc/syslog/syslog.c
index 2b478e1..9e9ddbf 100644
--- a/libc/misc/syslog/syslog.c
+++ b/libc/misc/syslog/syslog.c
@@ -80,17 +80,9 @@
 #include <ctype.h>
 #include <signal.h>
 
+#include <bits/uClibc_mutex.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 static int	LogFile = -1;		/* fd for log */
 static int	connected;		/* have done connect */
@@ -110,26 +102,26 @@ int setlogmask(int pmask);
 static void 
 closelog_intern(int to_default)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (LogFile != -1) {
 	    (void) close(LogFile);
 	}
 	LogFile = -1;
 	connected = 0;
 	if (to_default)
-	{
-		LogStat = 0;
-		LogTag = "syslog";
-		LogFacility = LOG_USER;
-		LogMask = 0xff;
-	}
-	UNLOCK;
+		{
+			LogStat = 0;
+			LogTag = "syslog";
+			LogFacility = LOG_USER;
+			LogMask = 0xff;
+		}
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 static void
 sigpipe_handler (int sig)
 {
-  closelog_intern (0);
+	closelog_intern (0);
 }
 
 /*
@@ -165,7 +157,7 @@ vsyslog( int pri, const char *fmt, va_li
 
 	saved_errno = errno;
 
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
 	/* See if we should just throw out this message. */
 	if (!(LogMask & LOG_MASK(LOG_PRI(pri))) || (pri &~ (LOG_PRIMASK|LOG_FACMASK)))
@@ -208,7 +200,7 @@ vsyslog( int pri, const char *fmt, va_li
 	if (p >= end || p < head_end) {	/* Returned -1 in case of error... */
 		static const char truncate_msg[12] = "[truncated] ";
 		memmove(head_end + sizeof(truncate_msg), head_end,
-			end - head_end - sizeof(truncate_msg));
+				end - head_end - sizeof(truncate_msg));
 		memcpy(head_end, truncate_msg, sizeof(truncate_msg));
 		if (p < head_end) {
 			while (p < end && *p) {
@@ -261,11 +253,11 @@ vsyslog( int pri, const char *fmt, va_li
 		(void)close(fd);
 	}
 
-getout:
-	UNLOCK;
+ getout:
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 	if (sigpipe == 0)
 		sigaction (SIGPIPE, &oldaction,
-			(struct sigaction *) NULL);
+				   (struct sigaction *) NULL);
 }
 
 /*
@@ -276,48 +268,48 @@ openlog( const char *ident, int logstat,
 {
     int logType = SOCK_DGRAM;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
 
     if (ident != NULL)
-	LogTag = ident;
+		LogTag = ident;
     LogStat = logstat;
     if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0)
-	LogFacility = logfac;
+		LogFacility = logfac;
     if (LogFile == -1) {
-	SyslogAddr.sa_family = AF_UNIX;
-	(void)strncpy(SyslogAddr.sa_data, _PATH_LOG,
-		      sizeof(SyslogAddr.sa_data));
-retry:
-	if (LogStat & LOG_NDELAY) {
-	    if ((LogFile = socket(AF_UNIX, logType, 0)) == -1){
-		UNLOCK;
-		return;
-	    }
-	    /*			fcntl(LogFile, F_SETFD, 1); */
-	}
+		SyslogAddr.sa_family = AF_UNIX;
+		(void)strncpy(SyslogAddr.sa_data, _PATH_LOG,
+					  sizeof(SyslogAddr.sa_data));
+	retry:
+		if (LogStat & LOG_NDELAY) {
+			if ((LogFile = socket(AF_UNIX, logType, 0)) == -1){
+				goto DONE;
+			}
+			/*			fcntl(LogFile, F_SETFD, 1); */
+		}
     }
 
     if (LogFile != -1 && !connected) {
-	if (connect(LogFile, &SyslogAddr, sizeof(SyslogAddr) - 
-		    sizeof(SyslogAddr.sa_data) + strlen(SyslogAddr.sa_data)) != -1)
-	{
-	    connected = 1;
-	} else if (logType == SOCK_DGRAM) {
-	    logType = SOCK_STREAM;
-	    if (LogFile != -1) {
-		close(LogFile);
-		LogFile = -1;
-	    }
-	    goto retry;
-	} else {
-	    if (LogFile != -1) {
-		close(LogFile);
-		LogFile = -1;
-	    }
-	}
+		if (connect(LogFile, &SyslogAddr, sizeof(SyslogAddr) - 
+					sizeof(SyslogAddr.sa_data) + strlen(SyslogAddr.sa_data)) != -1)
+			{
+				connected = 1;
+			} else if (logType == SOCK_DGRAM) {
+				logType = SOCK_STREAM;
+				if (LogFile != -1) {
+					close(LogFile);
+					LogFile = -1;
+				}
+				goto retry;
+			} else {
+				if (LogFile != -1) {
+					close(LogFile);
+					LogFile = -1;
+				}
+			}
     }
 
-    UNLOCK;
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 /*
@@ -335,10 +327,10 @@ int setlogmask(int pmask)
     int omask;
 
     omask = LogMask;
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (pmask != 0)
-	LogMask = pmask;
-    UNLOCK;
+		LogMask = pmask;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return (omask);
 }
 
diff --git a/libc/misc/time/time.c b/libc/misc/time/time.c
index f43bb8a..6165a52 100644
--- a/libc/misc/time/time.c
+++ b/libc/misc/time/time.c
@@ -143,6 +143,8 @@
 #include <locale.h>
 #include <bits/uClibc_uintmaxtostr.h>
 
+#include <bits/uClibc_mutex.h>
+
 #ifdef __UCLIBC_HAS_XLOCALE__
 #include <xlocale.h>
 #endif
@@ -191,21 +193,7 @@ typedef struct {
 	char tzname[TZNAME_MAX+1];
 } rule_struct;
 
-#ifdef __UCLIBC_HAS_THREADS__
-
-#include <pthread.h>
-
-extern pthread_mutex_t _time_tzlock;
-
-#define TZLOCK		__pthread_mutex_lock(&_time_tzlock)
-#define TZUNLOCK	__pthread_mutex_unlock(&_time_tzlock)
-
-#else
-
-#define TZLOCK		((void) 0)
-#define TZUNLOCK	((void) 0)
-
-#endif
+__UCLIBC_MUTEX_EXTERN(_time_tzlock);
 
 extern rule_struct _time_tzinfo[2];
 
@@ -542,13 +530,13 @@ struct tm *localtime(const time_t *timer
 struct tm *localtime_r(register const time_t *__restrict timer,
 					   register struct tm *__restrict result)
 {
-	TZLOCK;
+	__UCLIBC_MUTEX_LOCK(_time_tzlock);
 
 	tzset();
 
 	__time_localtime_tzi(timer, result, _time_tzinfo);
 
-	TZUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(_time_tzlock);
 
 	return result;
 }
@@ -1037,7 +1025,7 @@ size_t __XL(strftime)(char *__restrict s
 			goto LOOP;
 		}
 
-		o = spec + 26;		/* set to "????" */
+		o = ((const char *) spec) + 26;	/* set to "????" */
 		if ((code & MASK_SPEC) == CALC_SPEC) {
 
 			if (*p == 's') {
@@ -1073,17 +1061,15 @@ size_t __XL(strftime)(char *__restrict s
 
 #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
 
-#define RSP_TZUNLOCK	((void) 0)
 #define RSP_TZNAME		timeptr->tm_zone
 #define RSP_GMT_OFFSET	(-timeptr->tm_gmtoff)
 
 #else
 
-#define RSP_TZUNLOCK	TZUNLOCK
 #define RSP_TZNAME		rsp->tzname
 #define RSP_GMT_OFFSET	rsp->gmt_offset
 
-				TZLOCK;
+				__UCLIBC_MUTEX_LOCK(_time_tzlock);
 
 				rsp = _time_tzinfo;
 				if (timeptr->tm_isdst > 0) {
@@ -1114,15 +1100,17 @@ size_t __XL(strftime)(char *__restrict s
 					}
 #endif
 					o_count = SIZE_MAX;
-					RSP_TZUNLOCK;
+/* 					RSP_TZUNLOCK; */
+#ifdef __UCLIBC_HAS_TM_EXTENSIONS__
 					goto OUTPUT;
+#endif
 				} else {		/* z */
 					*s = '+';
 					if ((tzo = -RSP_GMT_OFFSET) < 0) {
 						tzo = -tzo;
 						*s = '-';
 					}
-					RSP_TZUNLOCK;
+/* 					RSP_TZUNLOCK; */
 					++s;
 					--count;
 
@@ -1131,7 +1119,13 @@ size_t __XL(strftime)(char *__restrict s
 			
 					i = 16 + 6;	/* 0-fill, width = 4 */
 				}
-
+#ifdef __UCLIBC_HAS_TM_EXTENSIONS__
+#else
+				__UCLIBC_MUTEX_UNLOCK(_time_tzlock);
+				if (*p == 'Z') {
+					goto OUTPUT;
+				}
+#endif
 			} else {
 				/* TODO: don't need year for U, W */
 				for (i=0 ; i < 3 ; i++) {
@@ -1664,9 +1658,7 @@ int daylight = 0;
 long timezone = 0;
 char *tzname[2] = { (char *) UTC, (char *) (UTC-1) };
 
-#ifdef __UCLIBC_HAS_THREADS__
-pthread_mutex_t _time_tzlock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-#endif
+__UCLIBC_MUTEX_INIT(_time_tzlock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 rule_struct _time_tzinfo[2];
 
@@ -1796,7 +1788,7 @@ void tzset(void)
 	static char oldval[TZ_BUFLEN]; /* BSS-zero'd. */
 #endif /* __UCLIBC_HAS_TZ_CACHING__ */
 
-	TZLOCK;
+	__UCLIBC_MUTEX_LOCK(_time_tzlock);
 
 	e = getenv(TZ);				/* TZ env var always takes precedence. */
 
@@ -1962,10 +1954,10 @@ void tzset(void)
 	daylight = !!_time_tzinfo[1].tzname[0];
 	timezone = _time_tzinfo[0].gmt_offset;
 
-#if defined(__UCLIBC_HAS_TZ_FILE__)
+#if defined(__UCLIBC_HAS_TZ_FILE__) || defined(__UCLIBC_HAS_TZ_CACHING__)
  FAST_DONE:
 #endif
-	TZUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(_time_tzlock);
 }
 
 #endif
@@ -2167,13 +2159,13 @@ time_t _time_mktime(struct tm *timeptr, 
 {
 	time_t t;
 
-	TZLOCK;
+	__UCLIBC_MUTEX_LOCK(_time_tzlock);
 
 	tzset();
 
 	t = _time_mktime_tzi(timeptr, store_on_success, _time_tzinfo);
 
-	TZUNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(_time_tzlock);
 
 	return t;
 }
diff --git a/libc/misc/ttyent/getttyent.c b/libc/misc/ttyent/getttyent.c
index 6e2fbd2..c85c73a 100644
--- a/libc/misc/ttyent/getttyent.c
+++ b/libc/misc/ttyent/getttyent.c
@@ -35,9 +35,6 @@
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-#endif
 
 static char zapchar;
 static FILE *tf;
@@ -50,8 +47,8 @@ struct ttyent * getttynam(const char *tt
 
     setttyent();
     while ((t = getttyent()))
-	if (!strcmp(tty, t->ty_name))
-	    break;
+		if (!strcmp(tty, t->ty_name))
+			break;
     endttyent();
     return (t);
 }
@@ -67,27 +64,27 @@ static char * skip(register char *p)
     register int c, q;
 
     for (q = 0, t = p; (c = *p) != '\0'; p++) {
-	if (c == '"') {
-	    q ^= QUOTED;	/* obscure, but nice */
-	    continue;
-	}
-	if (q == QUOTED && *p == '\\' && *(p+1) == '"')
-	    p++;
-	*t++ = *p;
-	if (q == QUOTED)
-	    continue;
-	if (c == '#') {
-	    zapchar = c;
-	    *p = 0;
-	    break;
-	}
-	if (c == '\t' || c == ' ' || c == '\n') {
-	    zapchar = c;
-	    *p++ = 0;
-	    while ((c = *p) == '\t' || c == ' ' || c == '\n')
-		p++;
-	    break;
-	}
+		if (c == '"') {
+			q ^= QUOTED;	/* obscure, but nice */
+			continue;
+		}
+		if (q == QUOTED && *p == '\\' && *(p+1) == '"')
+			p++;
+		*t++ = *p;
+		if (q == QUOTED)
+			continue;
+		if (c == '#') {
+			zapchar = c;
+			*p = 0;
+			break;
+		}
+		if (c == '\t' || c == ' ' || c == '\n') {
+			zapchar = c;
+			*p++ = 0;
+			while ((c = *p) == '\t' || c == ' ' || c == '\n')
+				p++;
+			break;
+		}
     }
     *--t = '\0';
     return (p);
@@ -104,46 +101,46 @@ struct ttyent * getttyent(void)
     register int c;
     register char *p;
     static char *line = NULL;
+    struct ttyent *retval = NULL;
 
     if (!tf && !setttyent())
-	return (NULL);
+		return (NULL);
 
     if (!line) {
-            line = malloc(BUFSIZ);
+		line = malloc(BUFSIZ);
 		if (!line)
 		    abort();
     }
 
-	__STDIO_ALWAYS_THREADLOCK(tf);
+    __STDIO_ALWAYS_THREADLOCK(tf);
 
     for (;;) {
-	if (!fgets_unlocked(p = line, BUFSIZ, tf)) {
-		__STDIO_ALWAYS_THREADUNLOCK(tf);
-	    return (NULL);
-	}
-	/* skip lines that are too big */
-	if (!index(p, '\n')) {
-	    while ((c = getc_unlocked(tf)) != '\n' && c != EOF)
-		;
-	    continue;
-	}
-	while (isspace(*p))
-	    ++p;
-	if (*p && *p != '#')
-	    break;
+		if (!fgets_unlocked(p = line, BUFSIZ, tf)) {
+			goto DONE;
+		}
+		/* skip lines that are too big */
+		if (!index(p, '\n')) {
+			while ((c = getc_unlocked(tf)) != '\n' && c != EOF)
+				;
+			continue;
+		}
+		while (isspace(*p))
+			++p;
+		if (*p && *p != '#')
+			break;
     }
 
     zapchar = 0;
     tty.ty_name = p;
     p = skip(p);
     if (!*(tty.ty_getty = p))
-	tty.ty_getty = tty.ty_type = NULL;
+		tty.ty_getty = tty.ty_type = NULL;
     else {
-	p = skip(p);
-	if (!*(tty.ty_type = p))
-	    tty.ty_type = NULL;
-	else
-	    p = skip(p);
+		p = skip(p);
+		if (!*(tty.ty_type = p))
+			tty.ty_type = NULL;
+		else
+			p = skip(p);
     }
     tty.ty_status = 0;
     tty.ty_window = NULL;
@@ -151,43 +148,45 @@ struct ttyent * getttyent(void)
 #define	scmp(e)	!strncmp(p, e, sizeof(e) - 1) && isspace(p[sizeof(e) - 1])
 #define	vcmp(e)	!strncmp(p, e, sizeof(e) - 1) && p[sizeof(e) - 1] == '='
     for (; *p; p = skip(p)) {
-	if (scmp(_TTYS_OFF))
-	    tty.ty_status &= ~TTY_ON;
-	else if (scmp(_TTYS_ON))
-	    tty.ty_status |= TTY_ON;
-	else if (scmp(_TTYS_SECURE))
-	    tty.ty_status |= TTY_SECURE;
-	else if (vcmp(_TTYS_WINDOW))
-	    tty.ty_window = value(p);
-	else
-	    break;
+		if (scmp(_TTYS_OFF))
+			tty.ty_status &= ~TTY_ON;
+		else if (scmp(_TTYS_ON))
+			tty.ty_status |= TTY_ON;
+		else if (scmp(_TTYS_SECURE))
+			tty.ty_status |= TTY_SECURE;
+		else if (vcmp(_TTYS_WINDOW))
+			tty.ty_window = value(p);
+		else
+			break;
     }
-    /* We can release the lock only here since `zapchar' is global.  */
-	__STDIO_ALWAYS_THREADUNLOCK(tf);
 
     if (zapchar == '#' || *p == '#')
-	while ((c = *++p) == ' ' || c == '\t')
-	    ;
+		while ((c = *++p) == ' ' || c == '\t')
+			;
     tty.ty_comment = p;
     if (*p == 0)
-	tty.ty_comment = 0;
+		tty.ty_comment = 0;
     if ((p = index(p, '\n')))
-	*p = '\0';
-    return (&tty);
+		*p = '\0';
+    retval = &tty;
+
+ DONE:
+    __STDIO_ALWAYS_THREADUNLOCK(tf);
+    return retval;
 }
 
 int setttyent(void)
 {
 
     if (tf) {
-	rewind(tf);
-	return (1);
+		rewind(tf);
+		return (1);
     } else if ((tf = fopen(_PATH_TTYS, "r"))) {
-	/* We do the locking ourselves.  */
+		/* We do the locking ourselves.  */
 #ifdef __UCLIBC_HAS_THREADS__
-	__fsetlocking (tf, FSETLOCKING_BYCALLER);
+		__fsetlocking (tf, FSETLOCKING_BYCALLER);
 #endif
-	return (1);
+		return (1);
     }
     return (0);
 }
@@ -197,9 +196,9 @@ int endttyent(void)
     int rval;
 
     if (tf) {
-	rval = !(fclose(tf) == EOF);
-	tf = NULL;
-	return (rval);
+		rval = !(fclose(tf) == EOF);
+		tf = NULL;
+		return (rval);
     }
     return (1);
 }
diff --git a/libc/misc/utmp/utent.c b/libc/misc/utmp/utent.c
index c1d8d6f..0fc6df4 100644
--- a/libc/misc/utmp/utent.c
+++ b/libc/misc/utmp/utent.c
@@ -20,19 +20,9 @@
 #include <string.h>
 #include <utmp.h>
 
+#include <bits/uClibc_mutex.h>
 
-
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t utmplock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&utmplock)
-# define UNLOCK	__pthread_mutex_unlock(&utmplock)
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
-
+__UCLIBC_MUTEX_STATIC(utmplock, PTHREAD_MUTEX_INITIALIZER);
 
 /* Some global crap */
 static int static_fd = -1;
@@ -46,19 +36,19 @@ static struct utmp *__getutent(int utmp_
 
 {
     if (utmp_fd == -1) {
-	setutent();
+		setutent();
     }
     if (utmp_fd == -1) {
-	return NULL;
+		return NULL;
     }
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(utmplock);
     if (read(utmp_fd, (char *) &static_utmp, sizeof(struct utmp)) != sizeof(struct utmp)) 
-    {
-	return NULL;
-    }
+		{
+			return NULL;
+		}
 
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(utmplock);
     return &static_utmp;
 }
 
@@ -66,39 +56,39 @@ void setutent(void)
 {
     int ret;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(utmplock);
     if (static_fd == -1) {
-	if ((static_fd = open(static_ut_name, O_RDWR)) < 0) {
-	    if ((static_fd = open(static_ut_name, O_RDONLY)) < 0) {
-		goto bummer;
-	    }
-	}
-	/* Make sure the file will be closed on exec()  */
-	ret = fcntl(static_fd, F_GETFD, 0);
-	if (ret >= 0) {
-	    ret = fcntl(static_fd, F_GETFD, 0);
-	}
-	if (ret < 0) {
-bummer:
-	    UNLOCK;
-	    static_fd = -1;
-	    close(static_fd);
-	    return;
-	}
+		if ((static_fd = open(static_ut_name, O_RDWR)) < 0) {
+			if ((static_fd = open(static_ut_name, O_RDONLY)) < 0) {
+				goto bummer;
+			}
+		}
+		/* Make sure the file will be closed on exec()  */
+		ret = fcntl(static_fd, F_GETFD, 0);
+		if (ret >= 0) {
+			ret = fcntl(static_fd, F_GETFD, 0);
+		}
+		if (ret < 0) {
+		bummer:
+			close(static_fd);
+			static_fd = -1;
+			goto DONE;
+		}
     }
     lseek(static_fd, 0, SEEK_SET);
-    UNLOCK;
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(utmplock);
     return;
 }
 
 void endutent(void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(utmplock);
     if (static_fd != -1) {
-	close(static_fd);
+		close(static_fd);
     }
     static_fd = -1;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(utmplock);
 }
 
 /* Locking is done in __getutent */
@@ -113,22 +103,22 @@ struct utmp *getutid (const struct utmp 
     struct utmp *lutmp;
 
     while ((lutmp = __getutent(static_fd)) != NULL) {
-	if (	(utmp_entry->ut_type == RUN_LVL ||
-		 utmp_entry->ut_type == BOOT_TIME ||
-		 utmp_entry->ut_type == NEW_TIME ||
-		 utmp_entry->ut_type == OLD_TIME) &&
-		lutmp->ut_type == utmp_entry->ut_type)  
-	{
-	    return lutmp;
-	}
-	if (	(utmp_entry->ut_type == INIT_PROCESS ||
-		 utmp_entry->ut_type == DEAD_PROCESS ||
-		 utmp_entry->ut_type == LOGIN_PROCESS ||
-		 utmp_entry->ut_type == USER_PROCESS) &&
-		!strncmp(lutmp->ut_id, utmp_entry->ut_id, sizeof(lutmp->ut_id))) 
-	{
-	    return lutmp;
-	}
+		if (	(utmp_entry->ut_type == RUN_LVL ||
+				 utmp_entry->ut_type == BOOT_TIME ||
+				 utmp_entry->ut_type == NEW_TIME ||
+				 utmp_entry->ut_type == OLD_TIME) &&
+				lutmp->ut_type == utmp_entry->ut_type)  
+			{
+				return lutmp;
+			}
+		if (	(utmp_entry->ut_type == INIT_PROCESS ||
+				 utmp_entry->ut_type == DEAD_PROCESS ||
+				 utmp_entry->ut_type == LOGIN_PROCESS ||
+				 utmp_entry->ut_type == USER_PROCESS) &&
+				!strncmp(lutmp->ut_id, utmp_entry->ut_id, sizeof(lutmp->ut_id))) 
+			{
+				return lutmp;
+			}
     }
 
     return NULL;
@@ -140,11 +130,11 @@ struct utmp *getutline(const struct utmp
     struct utmp *lutmp;
 
     while ((lutmp = __getutent(static_fd)) != NULL) {
-	if ((lutmp->ut_type == USER_PROCESS || lutmp->ut_type == LOGIN_PROCESS) &&
-		!strcmp(lutmp->ut_line, utmp_entry->ut_line))
-	{
-	    return lutmp;
-	}
+		if ((lutmp->ut_type == USER_PROCESS || lutmp->ut_type == LOGIN_PROCESS) &&
+			!strcmp(lutmp->ut_line, utmp_entry->ut_line))
+			{
+				return lutmp;
+			}
     }
 
     return NULL;
@@ -152,42 +142,42 @@ struct utmp *getutline(const struct utmp
 
 struct utmp *pututline (const struct utmp *utmp_entry)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(utmplock);
     /* Ignore the return value.  That way, if they've already positioned
        the file pointer where they want it, everything will work out. */
     lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
 
     if (getutid(utmp_entry) != NULL) {
-	lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
-	if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
-	    return NULL;
+		lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
+		if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
+			return NULL;
     } else {
-	lseek(static_fd, (off_t) 0, SEEK_END);
-	if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
-	    return NULL;
+		lseek(static_fd, (off_t) 0, SEEK_END);
+		if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
+			return NULL;
     }
 
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(utmplock);
     return (struct utmp *)utmp_entry;
 }
 
 int utmpname (const char *new_ut_name)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(utmplock);
     if (new_ut_name != NULL) {
-	if (static_ut_name != default_file_name)
-	    free((char *)static_ut_name);
-	static_ut_name = strdup(new_ut_name);
-	if (static_ut_name == NULL) {
-	    /* We should probably whine about out-of-memory 
-	     * errors here...  Instead just reset to the default */
-	    static_ut_name = default_file_name;
-	}
+		if (static_ut_name != default_file_name)
+			free((char *)static_ut_name);
+		static_ut_name = strdup(new_ut_name);
+		if (static_ut_name == NULL) {
+			/* We should probably whine about out-of-memory 
+			 * errors here...  Instead just reset to the default */
+			static_ut_name = default_file_name;
+		}
     }
 
     if (static_fd != -1)
-	close(static_fd);
-    UNLOCK;
+		close(static_fd);
+    __UCLIBC_MUTEX_UNLOCK(utmplock);
     return 0;
 }
 
diff --git a/libc/misc/wchar/wstdio.c b/libc/misc/wchar/wstdio.c
index b49494f..408c57a 100644
--- a/libc/misc/wchar/wstdio.c
+++ b/libc/misc/wchar/wstdio.c
@@ -82,9 +82,6 @@ strong_alias(NAME,NAME##_unlocked) \
 void NAME PARAMS
 #endif
 
-#define __STDIO_THREADLOCK_OPENLIST
-#define __STDIO_THREADUNLOCK_OPENLIST
-
 #else  /* __UCLIBC_HAS_THREADS__ */
 
 #include <pthread.h>
@@ -112,15 +109,6 @@ void NAME PARAMS \
 } \
 void NAME##_unlocked PARAMS
 
-#define __STDIO_THREADLOCK_OPENLIST \
-	__pthread_mutex_lock(&_stdio_openlist_lock)
-
-#define __STDIO_THREADUNLOCK_OPENLIST \
-	__pthread_mutex_unlock(&_stdio_openlist_lock)
-
-#define __STDIO_THREADTRYLOCK_OPENLIST \
-	__pthread_mutex_trylock(&_stdio_openlist_lock)
-
 #endif /* __UCLIBC_HAS_THREADS__ */
 
 #ifndef __STDIO_BUFFERS
diff --git a/libc/pwd_grp/lckpwdf.c b/libc/pwd_grp/lckpwdf.c
index 6b9c251..063fed4 100644
--- a/libc/pwd_grp/lckpwdf.c
+++ b/libc/pwd_grp/lckpwdf.c
@@ -27,15 +27,9 @@
 #include <sys/file.h>
 #include <paths.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK   __pthread_mutex_lock(&mylock)
-# define UNLOCK __pthread_mutex_unlock(&mylock);
-#else       
-# define LOCK
-# define UNLOCK
-#endif      
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 /* How long to wait for getting the lock before returning with an
    error.  */
@@ -57,18 +51,18 @@ int lckpwdf (void)
 	struct sigaction new_act;   /* New signal action.  */
 	struct flock fl;            /* Information struct for locking.  */
 	int result;
+	int rv = -1;
 
 	if (lock_fd != -1)
 		/* Still locked by own process.  */
 		return -1;
 
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
 	lock_fd = open (_PATH_PASSWD, O_WRONLY);
 	if (lock_fd == -1) {
 		/* Cannot create lock file.  */
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 
 	/* Make sure file gets correctly closed when process finished.  */
@@ -77,16 +71,14 @@ int lckpwdf (void)
 		/* Cannot get file flags.  */
 		close(lock_fd);
 		lock_fd = -1;
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 	flags |= FD_CLOEXEC;		/* Close on exit.  */
 	if (fcntl (lock_fd, F_SETFD, flags) < 0) {
 		/* Cannot set new flags.  */
 		close(lock_fd);
 		lock_fd = -1;
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 
 	/* Now we have to get exclusive write access.  Since multiple
@@ -107,8 +99,7 @@ int lckpwdf (void)
 		/* Cannot install signal handler.  */
 		close(lock_fd);
 		lock_fd = -1;
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 
 	/* Now make sure the alarm signal is not blocked.  */
@@ -118,8 +109,7 @@ int lckpwdf (void)
 		sigaction (SIGALRM, &saved_act, NULL);
 		close(lock_fd);
 		lock_fd = -1;
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 
 	/* Start timer.  If we cannot get the lock in the specified time we
@@ -146,12 +136,14 @@ int lckpwdf (void)
 	if (result < 0) {
 		close(lock_fd);
 		lock_fd = -1;
-		UNLOCK;
-		return -1;
+		goto DONE;
 	}
 
-	UNLOCK;
-	return 0;
+	rv = 0;
+
+ DONE:
+	__UCLIBC_MUTEX_UNLOCK(mylock);
+	return rv;
 }
 
 
@@ -164,11 +156,11 @@ int ulckpwdf (void)
 		result = -1;
 	}
 	else {
-		LOCK;
+		__UCLIBC_MUTEX_LOCK(mylock);
 		result = close (lock_fd);
 		/* Mark descriptor as unused.  */
 		lock_fd = -1;
-		UNLOCK;
+		__UCLIBC_MUTEX_UNLOCK(mylock);
 	}
 
 	return result;
diff --git a/libc/pwd_grp/pwd_grp.c b/libc/pwd_grp/pwd_grp.c
index 91c0d83..a302c7c 100644
--- a/libc/pwd_grp/pwd_grp.c
+++ b/libc/pwd_grp/pwd_grp.c
@@ -42,9 +42,8 @@
 #include <pwd.h>
 #include <grp.h>
 #include <shadow.h>
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-#endif
+
+#include <bits/uClibc_mutex.h>
 
 /**********************************************************************/
 /* Sizes for staticly allocated buffers. */
@@ -445,34 +444,27 @@ int getpw(uid_t uid, char *buf)
 /**********************************************************************/
 #ifdef L_getpwent_r
 
-#ifdef __UCLIBC_HAS_THREADS__
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK		__pthread_mutex_lock(&mylock)
-# define UNLOCK		__pthread_mutex_unlock(&mylock);
-#else       
-# define LOCK		((void) 0)
-# define UNLOCK		((void) 0)
-#endif      
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 static FILE *pwf /*= NULL*/;
 
 void setpwent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (pwf) {
 		rewind(pwf);
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void endpwent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (pwf) {
 		fclose(pwf);
 		pwf = NULL;
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 
@@ -482,7 +474,7 @@ int getpwent_r(struct passwd *__restrict
 {
 	int rv;
 
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
 	*result = NULL;				/* In case of error... */
 
@@ -500,7 +492,7 @@ int getpwent_r(struct passwd *__restrict
 	}
 
  ERR:
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
 	return rv;
 }
@@ -509,34 +501,27 @@ int getpwent_r(struct passwd *__restrict
 /**********************************************************************/
 #ifdef L_getgrent_r
 
-#ifdef __UCLIBC_HAS_THREADS__
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK		__pthread_mutex_lock(&mylock)
-# define UNLOCK		__pthread_mutex_unlock(&mylock);
-#else       
-# define LOCK		((void) 0)
-# define UNLOCK		((void) 0)
-#endif      
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 static FILE *grf /*= NULL*/;
 
 void setgrent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (grf) {
 		rewind(grf);
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void endgrent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (grf) {
 		fclose(grf);
 		grf = NULL;
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 int getgrent_r(struct group *__restrict resultbuf,
@@ -545,7 +530,7 @@ int getgrent_r(struct group *__restrict 
 {
 	int rv;
 
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
 	*result = NULL;				/* In case of error... */
 
@@ -563,7 +548,7 @@ int getgrent_r(struct group *__restrict 
 	}
 
  ERR:
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
 	return rv;
 }
@@ -572,34 +557,27 @@ int getgrent_r(struct group *__restrict 
 /**********************************************************************/
 #ifdef L_getspent_r
 
-#ifdef __UCLIBC_HAS_THREADS__
-static pthread_mutex_t mylock =  PTHREAD_MUTEX_INITIALIZER;
-# define LOCK		__pthread_mutex_lock(&mylock)
-# define UNLOCK		__pthread_mutex_unlock(&mylock);
-#else       
-# define LOCK		((void) 0)
-# define UNLOCK		((void) 0)
-#endif      
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 static FILE *spf /*= NULL*/;
 
 void setspent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (spf) {
 		rewind(spf);
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 void endspent(void)
 {
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if (spf) {
 		fclose(spf);
 		spf = NULL;
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 }
 
 int getspent_r(struct spwd *resultbuf, char *buffer, 
@@ -607,7 +585,7 @@ int getspent_r(struct spwd *resultbuf, c
 {
 	int rv;
 
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 
 	*result = NULL;				/* In case of error... */
 
@@ -625,7 +603,7 @@ int getspent_r(struct spwd *resultbuf, c
 	}
 
  ERR:
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
 	return rv;
 }
diff --git a/libc/stdio/_READ.c b/libc/stdio/_READ.c
index 7d3c38c..fe1bc91 100644
--- a/libc/stdio/_READ.c
+++ b/libc/stdio/_READ.c
@@ -41,7 +41,7 @@ size_t __stdio_READ(register FILE *strea
 #warning EINTR?
 #endif
 /* 	RETRY: */
-		if ((rv = __READ(stream, buf, bufsize)) <= 0) {
+		if ((rv = __READ(stream, (char *) buf, bufsize)) <= 0) {
 			if (rv == 0) {
 				__STDIO_STREAM_SET_EOF(stream);
 			} else {
diff --git a/libc/stdio/_WRITE.c b/libc/stdio/_WRITE.c
index d300d39..4131eb7 100644
--- a/libc/stdio/_WRITE.c
+++ b/libc/stdio/_WRITE.c
@@ -47,7 +47,7 @@ size_t __stdio_WRITE(register FILE *stre
 			return bufsize;
 		}
 		stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX;
-		if ((rv = __WRITE(stream, buf, stodo)) >= 0) {
+		if ((rv = __WRITE(stream, (char *) buf, stodo)) >= 0) {
 #ifdef __UCLIBC_MJN3_ONLY__
 #warning TODO: Make custom stream write return check optional.
 #endif
diff --git a/libc/stdio/_fopen.c b/libc/stdio/_fopen.c
index f7f5bb6..4984f11 100644
--- a/libc/stdio/_fopen.c
+++ b/libc/stdio/_fopen.c
@@ -194,10 +194,23 @@ FILE *_stdio_fopen(intptr_t fname_or_mod
 #endif
 
 #ifdef __STDIO_HAS_OPENLIST
-	__STDIO_THREADLOCK_OPENLIST;
-	stream->__nextopen = _stdio_openlist; /* New files are inserted at */
-	_stdio_openlist = stream;			  /*   the head of the list. */
-	__STDIO_THREADUNLOCK_OPENLIST;
+#if defined(__UCLIBC_HAS_THREADS__) && defined(__STDIO_BUFFERS)
+	if (!(stream->__modeflags & __FLAG_FREEFILE))
+	{
+		/* An freopen call so the file was never removed from the list. */
+	}
+	else
+#endif
+	{
+		/* We have to lock the del mutex in case another thread wants to fclose()
+		 * the last file. */
+		__STDIO_THREADLOCK_OPENLIST_DEL;
+		__STDIO_THREADLOCK_OPENLIST_ADD;
+		stream->__nextopen = _stdio_openlist; /* New files are inserted at */
+		_stdio_openlist = stream;			  /*   the head of the list. */
+		__STDIO_THREADUNLOCK_OPENLIST_ADD;
+		__STDIO_THREADUNLOCK_OPENLIST_DEL;
+	}
 #endif
 
 	__STDIO_STREAM_VALIDATE(stream);
diff --git a/libc/stdio/_stdio.c b/libc/stdio/_stdio.c
index 4aae3c4..9cfe02c 100644
--- a/libc/stdio/_stdio.c
+++ b/libc/stdio/_stdio.c
@@ -151,8 +151,12 @@ FILE *__stdout = _stdio_streams + 1; /* 
 FILE *_stdio_openlist = _stdio_streams;
 
 # ifdef __UCLIBC_HAS_THREADS__
-pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-int _stdio_openlist_delflag = 0;
+__UCLIBC_MUTEX_INIT(_stdio_openlist_add_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
+#ifdef __STDIO_BUFFERS
+__UCLIBC_MUTEX_INIT(_stdio_openlist_del_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
+volatile int _stdio_openlist_use_count = 0;
+int _stdio_openlist_del_count = 0;
+#endif
 # endif
 
 #endif
@@ -162,10 +166,10 @@ int _stdio_openlist_delflag = 0;
 /* 2 if threading not initialized and 0 otherwise; */
 int _stdio_user_locking = 2;
 
-void __stdio_init_mutex(pthread_mutex_t *m)
+void __stdio_init_mutex(__UCLIBC_MUTEX_TYPE *m)
 {
-	static const pthread_mutex_t __stdio_mutex_initializer
-		= PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+	const __UCLIBC_MUTEX_STATIC(__stdio_mutex_initializer,
+								PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 	memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
 }
@@ -184,7 +188,11 @@ void _stdio_term(void)
 	 * locked, then I suppose there is a chance that a pointer in the
 	 * chain might be corrupt due to a partial store.
 	 */ 
-	__stdio_init_mutex(&_stdio_openlist_lock);
+	__stdio_init_mutex(&_stdio_openlist_add_lock);
+#warning check
+#ifdef __STDIO_BUFFERS
+	__stdio_init_mutex(&_stdio_openlist_del_lock);
+#endif
 
 	/* Next we need to worry about the streams themselves.  If a stream
 	 * is currently locked, then it may be in an invalid state.  So we
@@ -192,7 +200,7 @@ void _stdio_term(void)
 	 * Then we reinitialize the locks.
 	 */
 	for (ptr = _stdio_openlist ; ptr ; ptr = ptr->__nextopen ) {
-		if (__STDIO_ALWAYS_THREADTRYLOCK(ptr)) {
+		if (__STDIO_ALWAYS_THREADTRYLOCK_CANCEL_UNSAFE(ptr)) {
 			/* The stream is already locked, so we don't want to touch it.
 			 * However, if we have custom streams, we can't just close it
 			 * or leave it locked since a custom stream may be stacked
@@ -258,10 +266,6 @@ void _stdio_init(void)
 #error Assumption violated about __MASK_READING and __FLAG_UNGOT
 #endif
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-#endif
-
 #ifndef NDEBUG
 
 void _stdio_validate_FILE(const FILE *stream)
diff --git a/libc/stdio/_stdio.h b/libc/stdio/_stdio.h
index e3c2c58..decf57d 100644
--- a/libc/stdio/_stdio.h
+++ b/libc/stdio/_stdio.h
@@ -22,23 +22,57 @@
 #include <wchar.h>
 #endif
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
+#include <bits/uClibc_mutex.h>
 
-#define __STDIO_THREADLOCK_OPENLIST \
-	__pthread_mutex_lock(&_stdio_openlist_lock)
+#define __STDIO_THREADLOCK_OPENLIST_ADD										\
+        __UCLIBC_MUTEX_LOCK(_stdio_openlist_add_lock)
 
-#define __STDIO_THREADUNLOCK_OPENLIST \
-	__pthread_mutex_unlock(&_stdio_openlist_lock)
+#define __STDIO_THREADUNLOCK_OPENLIST_ADD									\
+        __UCLIBC_MUTEX_UNLOCK(_stdio_openlist_add_lock)
 
-#define __STDIO_THREADTRYLOCK_OPENLIST \
-	__pthread_mutex_trylock(&_stdio_openlist_lock)
+#ifdef __STDIO_BUFFERS
 
-#else
+#define __STDIO_THREADLOCK_OPENLIST_DEL										\
+        __UCLIBC_MUTEX_LOCK(_stdio_openlist_del_lock)
+
+#define __STDIO_THREADUNLOCK_OPENLIST_DEL									\
+        __UCLIBC_MUTEX_UNLOCK(_stdio_openlist_del_lock)
 
-#define	__STDIO_THREADLOCK_OPENLIST     ((void)0)
-#define	__STDIO_THREADUNLOCK_OPENLIST   ((void)0)
+#define __STDIO_OPENLIST_INC_USE \
+do { \
+	__STDIO_THREADLOCK_OPENLIST_DEL; \
+	++_stdio_openlist_use_count; \
+	__STDIO_THREADUNLOCK_OPENLIST_DEL; \
+} while (0)
+
+extern void _stdio_openlist_dec_use(void);
+
+#define __STDIO_OPENLIST_DEC_USE \
+	_stdio_openlist_dec_use()
+
+#define __STDIO_OPENLIST_INC_DEL_CNT \
+do { \
+	__STDIO_THREADLOCK_OPENLIST_DEL; \
+	++_stdio_openlist_del_count; \
+	__STDIO_THREADUNLOCK_OPENLIST_DEL; \
+} while (0)
+
+#define __STDIO_OPENLIST_DEC_DEL_CNT \
+do { \
+	__STDIO_THREADLOCK_OPENLIST_DEL; \
+	--_stdio_openlist_del_count; \
+	__STDIO_THREADUNLOCK_OPENLIST_DEL; \
+} while (0)
+
+#endif /* __STDIO_BUFFERS */
 
+#ifndef __STDIO_THREADLOCK_OPENLIST_DEL
+#define	__STDIO_THREADLOCK_OPENLIST_DEL     ((void)0)
+#define	__STDIO_THREADUNLOCK_OPENLIST_DEL   ((void)0)
+#define __STDIO_OPENLIST_INC_USE            ((void)0)
+#define __STDIO_OPENLIST_DEC_USE            ((void)0)
+#define __STDIO_OPENLIST_INC_DEL_CNT        ((void)0)
+#define __STDIO_OPENLIST_DEC_DEL_CNT        ((void)0)
 #endif
 
 #define __UNDEFINED_OR_NONPORTABLE ((void)0)
diff --git a/libc/stdio/fclose.c b/libc/stdio/fclose.c
index 4df2e42..dfababc 100644
--- a/libc/stdio/fclose.c
+++ b/libc/stdio/fclose.c
@@ -12,30 +12,34 @@ int fclose(register FILE *stream)
 	int rv = 0;
 	__STDIO_AUTO_THREADLOCK_VAR;
 
-	/* First, remove the file from the open file list. */
-#ifdef __STDIO_HAS_OPENLIST
-	{
-		register FILE *ptr;
-
-		__STDIO_THREADLOCK_OPENLIST;
-		if ((ptr = _stdio_openlist) == stream) {
-			_stdio_openlist = stream->__nextopen;
-		} else {
-			while (ptr) {
-				if (ptr->__nextopen == stream) {
-					ptr->__nextopen = stream->__nextopen;
-					break;
-				}
-				ptr = ptr->__nextopen;
-			}
-		}
-		__STDIO_THREADUNLOCK_OPENLIST;
-
-		if (!ptr) {	  /* Did not find stream in the open file list! */
-			return EOF;
-		}
-	}
-#endif
+#warning dead code... but may want to simply check and not remove
+/* #ifdef __STDIO_HAS_OPENLIST */
+/* #if !defined(__UCLIBC_HAS_THREADS__) || !defined(__STDIO_BUFFERS) */
+/* 	/\* First, remove the file from the open file list. *\/ */
+/* 	{ */
+/* 		register FILE *ptr; */
+
+/* 		__STDIO_THREADLOCK_OPENLIST; */
+/* 		if ((ptr = _stdio_openlist) == stream) { */
+/* #warning does a mod!!! */
+/* 			_stdio_openlist = stream->__nextopen; */
+/* 		} else { */
+/* 			while (ptr) { */
+/* 				if (ptr->__nextopen == stream) { */
+/* 					ptr->__nextopen = stream->__nextopen; */
+/* 					break; */
+/* 				} */
+/* 				ptr = ptr->__nextopen; */
+/* 			} */
+/* 		} */
+/* 		__STDIO_THREADUNLOCK_OPENLIST; */
+
+/* 		if (!ptr) {	  /\* Did not find stream in the open file list! *\/ */
+/* 			return EOF; */
+/* 		} */
+/* 	} */
+/* #endif */
+/* #endif */
 
 	__STDIO_AUTO_THREADLOCK(stream);
 
@@ -80,7 +84,15 @@ int fclose(register FILE *stream)
 	__STDIO_AUTO_THREADUNLOCK(stream);
 
 	__STDIO_STREAM_FREE_BUFFER(stream);
+#warning... inefficient - locks and unlocks twice and walks whole list
+#if defined(__UCLIBC_HAS_THREADS__) && defined(__STDIO_BUFFERS)
+	/* inefficient - locks/unlocks twice and walks whole list */
+	__STDIO_OPENLIST_INC_USE;
+	__STDIO_OPENLIST_INC_DEL_CNT;
+	__STDIO_OPENLIST_DEC_USE;	/* This with free the file if necessary. */
+#else
 	__STDIO_STREAM_FREE_FILE(stream);
+#endif
 
 	return rv;
 }
diff --git a/libc/stdio/fcloseall.c b/libc/stdio/fcloseall.c
index dbb6000..f62281a 100644
--- a/libc/stdio/fcloseall.c
+++ b/libc/stdio/fcloseall.c
@@ -19,14 +19,34 @@ int fcloseall (void)
 #ifdef __STDIO_HAS_OPENLIST
 
 	int retval = 0;
+	FILE *f;
 
-	__STDIO_THREADLOCK_OPENLIST;
-	while (_stdio_openlist) {
-		if (fclose(_stdio_openlist)) {
+#warning remove dead code
+/* 	__STDIO_THREADLOCK_OPENLIST; */
+/* 	while (_stdio_openlist) { */
+/* 		if (fclose(_stdio_openlist)) { */
+/* 			retval = EOF; */
+/* 		} */
+/* 	} */
+/* 	__STDIO_THREADUNLOCK_OPENLIST; */
+
+	__STDIO_OPENLIST_INC_USE;
+
+#warning should probably have a get_head() operation
+	__STDIO_THREADLOCK_OPENLIST_ADD;
+	f = _stdio_openlist;
+	__STDIO_THREADUNLOCK_OPENLIST_ADD;
+
+	while (f) {
+#warning should probably have a get_next() operation
+		FILE *n = f->__nextopen;
+		if (fclose(f)) {
 			retval = EOF;
 		}
+		f = n;
 	}
-	__STDIO_THREADUNLOCK_OPENLIST;
+
+	__STDIO_OPENLIST_DEC_USE;
 
 	return retval;
 
diff --git a/libc/stdio/fflush.c b/libc/stdio/fflush.c
index 6baa0ec..66b65cd 100644
--- a/libc/stdio/fflush.c
+++ b/libc/stdio/fflush.c
@@ -20,23 +20,50 @@ weak_alias(__fflush_unlocked,fflush_unlo
 weak_alias(__fflush_unlocked,fflush);
 #endif
 
-#ifdef __UCLIBC_HAS_THREADS__
 /* Even if the stream is set to user-locking, we still need to lock
  * when all (lbf) writing streams are flushed. */
-#define MY_STDIO_THREADLOCK(STREAM) \
-	if (_stdio_user_locking != 2) { \
-		__STDIO_ALWAYS_THREADLOCK(STREAM); \
-	}
 
-#define MY_STDIO_THREADUNLOCK(STREAM) \
-	if (_stdio_user_locking != 2) { \
-		__STDIO_ALWAYS_THREADUNLOCK(STREAM); \
-	}
-#else
-#define MY_STDIO_THREADLOCK(STREAM)		((void)0)
-#define MY_STDIO_THREADUNLOCK(STREAM)	((void)0)
-#endif
+#define __MY_STDIO_THREADLOCK(__stream)										\
+        __UCLIBC_MUTEX_CONDITIONAL_LOCK((__stream)->__lock,					\
+										(_stdio_user_locking != 2))
+
+#define __MY_STDIO_THREADUNLOCK(__stream)									\
+        __UCLIBC_MUTEX_CONDITIONAL_UNLOCK((__stream)->__lock,				\
+										  (_stdio_user_locking != 2))
 
+#if defined(__UCLIBC_HAS_THREADS__) && defined(__STDIO_BUFFERS)
+void _stdio_openlist_dec_use(void)
+{
+	__STDIO_THREADLOCK_OPENLIST_DEL;
+	if ((_stdio_openlist_use_count == 1) && (_stdio_openlist_del_count > 0)) {
+		FILE *p = NULL;
+		FILE *n;
+		FILE *stream;
+
+		__STDIO_THREADLOCK_OPENLIST_ADD;
+		for (stream = _stdio_openlist; stream; stream = n) {
+#warning walk the list and clear out all fclosed()d files
+			n = stream->__nextopen;
+#warning fix for nonatomic
+			if ((stream->__modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY))
+				== (__FLAG_READONLY|__FLAG_WRITEONLY)
+				) {		 /* The file was closed so remove from the list. */
+				if (!p) {
+					_stdio_openlist = n;
+				} else {
+					p->__nextopen = n;
+				}
+				__STDIO_STREAM_FREE_FILE(stream);
+			} else {
+				p = stream;
+			}
+		}
+		__STDIO_THREADUNLOCK_OPENLIST_DEL;
+	}
+	--_stdio_openlist_use_count;
+	__STDIO_THREADUNLOCK_OPENLIST_DEL;
+}
+#endif
 
 int __fflush_unlocked(register FILE *stream)
 {
@@ -60,23 +87,39 @@ int __fflush_unlocked(register FILE *str
 	}
 
 	if (!stream) {				/* Flush all (lbf) writing streams. */
-		__STDIO_THREADLOCK_OPENLIST;
-		for (stream = _stdio_openlist; stream ; stream = stream->__nextopen) {
-			MY_STDIO_THREADLOCK(stream);
-			if (!(((stream->__modeflags | bufmask)
-				   ^ (__FLAG_WRITING|__FLAG_LBF)
-				   ) & (__FLAG_WRITING|__MASK_BUFMODE))
-				) {
-				if (!__STDIO_COMMIT_WRITE_BUFFER(stream)) {
-					__STDIO_STREAM_DISABLE_PUTC(stream);
-					__STDIO_STREAM_CLEAR_WRITING(stream);
-				} else {
-					retval = EOF;
+
+		__STDIO_OPENLIST_INC_USE;
+
+		__STDIO_THREADLOCK_OPENLIST_ADD;
+		stream = _stdio_openlist;
+		__STDIO_THREADUNLOCK_OPENLIST_ADD;
+
+		while(stream) {
+			/* We only care about currently writing streams and do not want to
+			 * block trying to obtain mutexes on non-writing streams. */
+#warning fix for nonatomic
+#warning unnecessary check if no threads
+			if (__STDIO_STREAM_IS_WRITING(stream)) { /* ONLY IF ATOMIC!!! */
+				__MY_STDIO_THREADLOCK(stream);
+				/* Need to check again once we have the lock. */
+				if (!(((stream->__modeflags | bufmask)
+					   ^ (__FLAG_WRITING|__FLAG_LBF)
+					   ) & (__FLAG_WRITING|__MASK_BUFMODE))
+					) {
+					if (!__STDIO_COMMIT_WRITE_BUFFER(stream)) {
+						__STDIO_STREAM_DISABLE_PUTC(stream);
+						__STDIO_STREAM_CLEAR_WRITING(stream);
+					} else {
+						retval = EOF;
+					}
 				}
+				__MY_STDIO_THREADUNLOCK(stream);
 			}
-			MY_STDIO_THREADUNLOCK(stream);
+			stream = stream->__nextopen;
 		}
-		__STDIO_THREADUNLOCK_OPENLIST;
+
+		__STDIO_OPENLIST_DEC_USE;
+
 	} else if (__STDIO_STREAM_IS_WRITING(stream)) {
 		if (!__STDIO_COMMIT_WRITE_BUFFER(stream)) {
 			__STDIO_STREAM_DISABLE_PUTC(stream);
diff --git a/libc/stdio/flockfile.c b/libc/stdio/flockfile.c
index 0dcc7c2..3fad711 100644
--- a/libc/stdio/flockfile.c
+++ b/libc/stdio/flockfile.c
@@ -11,6 +11,6 @@ void flockfile(FILE *stream)
 {
 	__STDIO_STREAM_VALIDATE(stream);
 
-	__STDIO_ALWAYS_THREADLOCK(stream);
+	__STDIO_ALWAYS_THREADLOCK_CANCEL_UNSAFE(stream);
 }
 
diff --git a/libc/stdio/freopen.c b/libc/stdio/freopen.c
index 0eccaac..36b8488 100644
--- a/libc/stdio/freopen.c
+++ b/libc/stdio/freopen.c
@@ -42,6 +42,8 @@ FILE *freopen(const char * __restrict fi
 
 	__STDIO_STREAM_VALIDATE(stream);
 
+	__STDIO_OPENLIST_INC_USE;	/* Do not remove the file from the list. */
+
 	/* First, flush and close, but don't deallocate, the stream. */
 	/* This also removes the stream for the open file list. */
 	dynmode = (stream->__modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));
@@ -57,9 +59,16 @@ FILE *freopen(const char * __restrict fi
 
 	fp = _stdio_fopen(((intptr_t) filename), mode, stream, FILEDES_ARG);
 
+#warning if fp is NULL, then we do not free file (but beware stdin,stdout,stderr)
+	if (fp) {
+		__STDIO_OPENLIST_DEC_DEL_CNT;
+	}
+
 	/* Reset the allocation flags. */
 	stream->__modeflags |= dynmode;
 
+	__STDIO_OPENLIST_DEC_USE;
+
 	__STDIO_AUTO_THREADUNLOCK(stream);
 
 	return fp;
diff --git a/libc/stdio/ftello.c b/libc/stdio/ftello.c
index 7092f34..69385ce 100644
--- a/libc/stdio/ftello.c
+++ b/libc/stdio/ftello.c
@@ -48,7 +48,10 @@ OFFSET_TYPE FTELL(register FILE *stream)
 
 	__STDIO_STREAM_VALIDATE(stream);
 
-	if ((__SEEK(stream, &pos, SEEK_CUR) < 0)
+	if ((__SEEK(stream, &pos,
+				((__STDIO_STREAM_IS_WRITING(stream)
+				  && (stream->__modeflags & __FLAG_APPEND))
+				 ? SEEK_END : SEEK_CUR)) < 0)
 		|| (__stdio_adjust_position(stream, &pos) < 0)) {
 		pos = -1;
 	}
diff --git a/libc/stdio/ftrylockfile.c b/libc/stdio/ftrylockfile.c
index d85b8ff..0d2e156 100644
--- a/libc/stdio/ftrylockfile.c
+++ b/libc/stdio/ftrylockfile.c
@@ -15,5 +15,5 @@ int ftrylockfile(FILE *stream)
 {
 	__STDIO_STREAM_VALIDATE(stream);
 
-	return __STDIO_ALWAYS_THREADTRYLOCK(stream);
+	return __STDIO_ALWAYS_THREADTRYLOCK_CANCEL_UNSAFE(stream);
 }
diff --git a/libc/stdio/funlockfile.c b/libc/stdio/funlockfile.c
index 048c093..2ddf097 100644
--- a/libc/stdio/funlockfile.c
+++ b/libc/stdio/funlockfile.c
@@ -11,5 +11,5 @@ void funlockfile(FILE *stream)
 {
 	__STDIO_STREAM_VALIDATE(stream);
 
-	__STDIO_ALWAYS_THREADUNLOCK(stream);
+	__STDIO_ALWAYS_THREADUNLOCK_CANCEL_UNSAFE(stream);
 }
diff --git a/libc/stdio/popen.c b/libc/stdio/popen.c
index c7887ad..ab8d296 100644
--- a/libc/stdio/popen.c
+++ b/libc/stdio/popen.c
@@ -14,6 +14,7 @@
  *   Fix failure exit code for failed execve().
  */
 
+#warning hmm... susv3 says "Pipe streams are byte-oriented."
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -21,6 +22,8 @@
 #include <unistd.h>
 #include <sys/wait.h>
 
+#include <bits/uClibc_mutex.h>
+
 /* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
 #include <sys/syscall.h>
 #if ! defined __NR_vfork
@@ -29,19 +32,11 @@
 # define VFORK_UNLOCK	((void) 0)
 #endif
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK			__pthread_mutex_lock(&mylock)
-# define UNLOCK			__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK			((void) 0)
-# define UNLOCK			((void) 0)
-#endif      
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 #ifndef VFORK_LOCK
-# define VFORK_LOCK		LOCK
-# define VFORK_UNLOCK	UNLOCK
+# define VFORK_LOCK		__UCLIBC_MUTEX_LOCK(mylock)
+# define VFORK_UNLOCK	__UCLIBC_MUTEX_UNLOCK(mylock)
 #endif
 
 struct popen_list_item {
@@ -118,10 +113,10 @@ FILE *popen(const char *command, const c
 	if (pid > 0) {				/* Parent of vfork... */
 		pi->pid = pid;
 		pi->f = fp;
-		LOCK;
+		__UCLIBC_MUTEX_LOCK(mylock);
 		pi->next = popen_list;
 		popen_list = pi;
-		UNLOCK;
+		__UCLIBC_MUTEX_UNLOCK(mylock);
 		
 		return fp;
 	}
@@ -136,6 +131,8 @@ FILE *popen(const char *command, const c
 	return NULL;
 }
 
+#warning is pclose correct wrt the new mutex semantics?
+
 int pclose(FILE *stream)
 {
 	struct popen_list_item *p;
@@ -144,7 +141,7 @@ int pclose(FILE *stream)
 
 	/* First, find the list entry corresponding to stream and remove it
 	 * from the list.  Set p to the list item (NULL if not found). */
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(mylock);
 	if ((p = popen_list) != NULL) {
 		if (p->f == stream) {
 			popen_list = p->next;
@@ -163,7 +160,7 @@ int pclose(FILE *stream)
 			} while (1);
 		}
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(mylock);
 
 	if (p) {
 		pid = p->pid;			/* Save the pid we need */
diff --git a/libc/stdio/setvbuf.c b/libc/stdio/setvbuf.c
index 3fe62c6..6d53ab1 100644
--- a/libc/stdio/setvbuf.c
+++ b/libc/stdio/setvbuf.c
@@ -75,8 +75,8 @@ int setvbuf(register FILE * __restrict s
 	}
 
 	stream->__modeflags |= alloc_flag;
-	stream->__bufstart = buf;
-	stream->__bufend = buf + size;
+	stream->__bufstart = (unsigned char *) buf;
+	stream->__bufend = (unsigned char *) buf + size;
 	__STDIO_STREAM_INIT_BUFREAD_BUFPOS(stream);
 	__STDIO_STREAM_DISABLE_GETC(stream);
 	__STDIO_STREAM_DISABLE_PUTC(stream);
diff --git a/libc/stdio/vasprintf.c b/libc/stdio/vasprintf.c
index 688ab7c..6d7664d 100644
--- a/libc/stdio/vasprintf.c
+++ b/libc/stdio/vasprintf.c
@@ -63,6 +63,8 @@ int vasprintf(char **__restrict buf, con
 				free(*buf);
 				*buf = NULL;
 			}
+		} else {
+			rv = -1;
 		}
 	}
 
diff --git a/libc/stdio/vdprintf.c b/libc/stdio/vdprintf.c
index de8362c..7cb707f 100644
--- a/libc/stdio/vdprintf.c
+++ b/libc/stdio/vdprintf.c
@@ -15,8 +15,8 @@ int vdprintf(int filedes, const char * _
 #ifdef __STDIO_BUFFERS
 	char buf[64];				/* TODO: provide _optional_ buffering? */
 
-	f.__bufend = buf + sizeof(buf);
-	f.__bufstart = buf;
+	f.__bufend = (unsigned char *) buf + sizeof(buf);
+	f.__bufstart = (unsigned char *) buf;
 	__STDIO_STREAM_DISABLE_GETC(&f);
 	__STDIO_STREAM_DISABLE_PUTC(&f);
 	__STDIO_STREAM_INIT_BUFREAD_BUFPOS(&f);
diff --git a/libc/stdio/vfprintf.c b/libc/stdio/vfprintf.c
index 10114f0..9214e3b 100644
--- a/libc/stdio/vfprintf.c
+++ b/libc/stdio/vfprintf.c
@@ -569,7 +569,7 @@ int _ppfs_init(register ppfs_t *ppfs, co
 		ppfs->fmtpos = fmt0;		/* rewind */
 	}
 
-#ifdef NL_MAX_ARG
+#ifdef NL_ARGMAX
 	/* If we have positional args, make sure we know all the types. */
 	{
 		register int *p = ppfs->argtype;
@@ -581,7 +581,7 @@ int _ppfs_init(register ppfs_t *ppfs, co
 			++p;
 		}
 	}
-#endif /* NL_MAX_ARG */
+#endif /* NL_ARGMAX */
 
 	return 0;
 }
@@ -1214,7 +1214,7 @@ static size_t _fp_out_narrow(FILE *fp, i
 		}
 		len = buflen;
 	}
-	return r + OUTNSTR(fp, (const char *) buf, len);
+	return r + OUTNSTR(fp, (const unsigned char *) buf, len);
 }
 
 #endif /* __STDIO_PRINTF_FLOAT */
diff --git a/libc/stdlib/abort.c b/libc/stdlib/abort.c
index 77c2cdc..9f69918 100644
--- a/libc/stdlib/abort.c
+++ b/libc/stdlib/abort.c
@@ -70,16 +70,9 @@ extern void _exit __P((int __status)) __
 static int been_there_done_that = 0;
 
 /* Be prepared in case multiple threads try to abort() */
-#ifdef __UCLIBC_HAS_THREADS__
-# include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock)
-#else
-# define LOCK
-# define UNLOCK
-#endif
+#include <bits/uClibc_mutex.h>
 
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 /* Cause an abnormal program termination with core-dump */
 void abort(void)
@@ -87,7 +80,7 @@ void abort(void)
 	sigset_t sigset;
 
 	/* Make sure we acquire the lock before proceeding */
-	LOCK;
+	__UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(mylock);
 
 	/* Unmask SIGABRT to be sure we can get it */
 	if (__sigemptyset(&sigset) == 0 && __sigaddset(&sigset, SIGABRT) == 0) {
@@ -110,9 +103,9 @@ void abort(void)
 #endif
 
 abort_it:
-			UNLOCK;
+			__UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(mylock);
 			raise(SIGABRT);
-			LOCK;
+			__UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(mylock);
 		}
 
 		/* Still here?  Try to remove any signal handlers */
diff --git a/libc/stdlib/atexit.c b/libc/stdlib/atexit.c
index 280f42c..b028068 100644
--- a/libc/stdlib/atexit.c
+++ b/libc/stdlib/atexit.c
@@ -40,17 +40,9 @@
 #include <stdlib.h>
 #include <errno.h>
 
+#include <bits/uClibc_mutex.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-extern pthread_mutex_t mylock;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
-
+__UCLIBC_MUTEX_EXTERN(__atexit_lock);
 
 typedef void (*aefuncp) (void);         /* atexit function pointer */
 typedef void (*oefuncp) (int, void *);  /* on_exit function pointer */
@@ -90,8 +82,9 @@ extern struct exit_function __exit_funct
 int atexit(aefuncp func)
 {
     struct exit_function *efp;
+    int rv = -1;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(__atexit_lock);
     if (func) {
 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
 	/* If we are out of function table slots, make some more */
@@ -99,18 +92,16 @@ int atexit(aefuncp func)
 	    efp=realloc(__exit_function_table, 
 					(__exit_slots+20)*sizeof(struct exit_function));
 	    if (efp==NULL) {
-		UNLOCK;
 		__set_errno(ENOMEM);
-		return -1;
+		goto DONE;
 	    }
 		__exit_function_table = efp;
 	    __exit_slots+=20;
 	}
 #else
 	if (__exit_count >= __UCLIBC_MAX_ATEXIT) {
-	    UNLOCK;
 	    __set_errno(ENOMEM);
-	    return -1;
+	    goto DONE;
 	}
 #endif
 	__exit_cleanup = __exit_handler; /* enable cleanup */
@@ -118,8 +109,12 @@ int atexit(aefuncp func)
 	efp->type = ef_atexit;
 	efp->funcs.atexit = func;
     }
-    UNLOCK;
-    return 0;
+
+    rv = 0;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(__atexit_lock);
+    return rv;
 }
 #endif
 
@@ -133,8 +128,9 @@ int atexit(aefuncp func)
 int on_exit(oefuncp func, void *arg)
 {
     struct exit_function *efp;
+    int rv = -1;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(__atexit_lock);
     if (func) {
 #ifdef __UCLIBC_DYNAMIC_ATEXIT__
 	/* If we are out of function table slots, make some more */
@@ -142,18 +138,16 @@ int on_exit(oefuncp func, void *arg)
 	    efp=realloc(__exit_function_table, 
 					(__exit_slots+20)*sizeof(struct exit_function));
 	    if (efp==NULL) {
-		UNLOCK;
 		__set_errno(ENOMEM);
-		return -1;
+		goto DONE;
 	    }
 		__exit_function_table=efp;
 	    __exit_slots+=20;
 	}
 #else
 	if (__exit_count >= __UCLIBC_MAX_ATEXIT) {
-	    UNLOCK;
 	    __set_errno(ENOMEM);
-	    return -1;
+	    goto DONE;
 	}
 #endif
 
@@ -163,8 +157,12 @@ int on_exit(oefuncp func, void *arg)
 	efp->funcs.on_exit.func = func;
 	efp->funcs.on_exit.arg = arg;
     }
-    UNLOCK;
-    return 0;
+
+    rv = 0;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(__atexit_lock);
+    return rv;
 }
 #endif
 
@@ -214,9 +212,8 @@ void __exit_handler(int status)
 #ifdef L_exit
 extern void weak_function _stdio_term(void);
 void (*__exit_cleanup) (int) = 0;
-#ifdef __UCLIBC_HAS_THREADS__
-pthread_mutex_t mylock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-#endif
+
+__UCLIBC_MUTEX_INIT(__atexit_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 #ifdef __UCLIBC_CTOR_DTOR__
 extern void (*__app_fini)(void);
@@ -229,11 +226,11 @@ extern void (*__rtld_fini)(void);
 void exit(int rv)
 {
 	/* Perform exit-specific cleanup (atexit and on_exit) */
-	LOCK;
+	__UCLIBC_MUTEX_LOCK(__atexit_lock);
 	if (__exit_cleanup) {
 		__exit_cleanup(rv);
 	}
-	UNLOCK;
+	__UCLIBC_MUTEX_UNLOCK(__atexit_lock);
 
 #ifdef __UCLIBC_CTOR_DTOR__
 	if (__app_fini != NULL)
diff --git a/libc/stdlib/malloc-simple/alloc.c b/libc/stdlib/malloc-simple/alloc.c
index ed14c37..519a875 100644
--- a/libc/stdlib/malloc-simple/alloc.c
+++ b/libc/stdlib/malloc-simple/alloc.c
@@ -108,15 +108,14 @@ void free(void *ptr)
 #endif
 
 #ifdef L_memalign
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-pthread_mutex_t __malloc_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-# define LOCK	__pthread_mutex_lock(&__malloc_lock)
-# define UNLOCK	__pthread_mutex_unlock(&__malloc_lock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_EXTERN(__malloc_lock);
+
+#define __MALLOC_LOCK		__UCLIBC_MUTEX_LOCK(__malloc_lock)
+#define __MALLOC_UNLOCK		__UCLIBC_MUTEX_UNLOCK(__malloc_lock)
+
 
 /* List of blocks allocated with memalign or valloc */
 struct alignlist
@@ -135,7 +134,7 @@ int __libc_free_aligned(void *ptr)
 	if (ptr == NULL)
 		return 0;
 
-	LOCK;
+	__MALLOC_LOCK;
 	for (l = _aligned_blocks; l != NULL; l = l->next) {
 		if (l->aligned == ptr) {
 			/* Mark the block as free */
@@ -146,7 +145,7 @@ int __libc_free_aligned(void *ptr)
 			return 1;
 		}
 	}
-	UNLOCK;
+	__MALLOC_UNLOCK;
 	return 0;
 }
 void * memalign (size_t alignment, size_t size)
@@ -159,10 +158,10 @@ void * memalign (size_t alignment, size_
 		return NULL;
 
 	adj = (unsigned long int) ((unsigned long int) ((char *) result -
-	      (char *) NULL)) % alignment;
+													(char *) NULL)) % alignment;
 	if (adj != 0) {
 		struct alignlist *l;
-		LOCK;
+		__MALLOC_LOCK;
 		for (l = _aligned_blocks; l != NULL; l = l->next)
 			if (l->aligned == NULL)
 				/* This slot is free.  Use it.  */
@@ -171,15 +170,16 @@ void * memalign (size_t alignment, size_
 			l = (struct alignlist *) malloc (sizeof (struct alignlist));
 			if (l == NULL) {
 				free(result);
-				UNLOCK;
-				return NULL;
+				result = NULL;
+				goto DONE;
 			}
 			l->next = _aligned_blocks;
 			_aligned_blocks = l;
 		}
 		l->exact = result;
 		result = l->aligned = (char *) result + alignment - adj;
-		UNLOCK;
+	DONE:
+		__MALLOC_UNLOCK;
 	}
 
 	return result;
diff --git a/libc/stdlib/malloc-standard/calloc.c b/libc/stdlib/malloc-standard/calloc.c
index a67dad7..4277954 100644
--- a/libc/stdlib/malloc-standard/calloc.c
+++ b/libc/stdlib/malloc-standard/calloc.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -31,63 +31,63 @@ void* calloc(size_t n_elements, size_t e
      * to fall through and call malloc(0) */
     size = n_elements * elem_size;
     if (n_elements && elem_size != (size / n_elements)) {
-	__set_errno(ENOMEM);
-	return NULL;
+		__set_errno(ENOMEM);
+		return NULL;
     }
 
-    LOCK;
+    __MALLOC_LOCK;
     mem = malloc(size);
     if (mem != 0) {
-	p = mem2chunk(mem);
+		p = mem2chunk(mem);
 
-	if (!chunk_is_mmapped(p))
-	{
-	    /*
-	       Unroll clear of <= 36 bytes (72 if 8byte sizes)
-	       We know that contents have an odd number of
-	       size_t-sized words; minimally 3.
-	       */
-
-	    d = (size_t*)mem;
-	    clearsize = chunksize(p) - (sizeof(size_t));
-	    nclears = clearsize / sizeof(size_t);
-	    assert(nclears >= 3);
-
-	    if (nclears > 9)
-		memset(d, 0, clearsize);
-
-	    else {
-		*(d+0) = 0;
-		*(d+1) = 0;
-		*(d+2) = 0;
-		if (nclears > 4) {
-		    *(d+3) = 0;
-		    *(d+4) = 0;
-		    if (nclears > 6) {
-			*(d+5) = 0;
-			*(d+6) = 0;
-			if (nclears > 8) {
-			    *(d+7) = 0;
-			    *(d+8) = 0;
+		if (!chunk_is_mmapped(p))
+			{
+				/*
+				  Unroll clear of <= 36 bytes (72 if 8byte sizes)
+				  We know that contents have an odd number of
+				  size_t-sized words; minimally 3.
+				*/
+
+				d = (size_t*)mem;
+				clearsize = chunksize(p) - (sizeof(size_t));
+				nclears = clearsize / sizeof(size_t);
+				assert(nclears >= 3);
+
+				if (nclears > 9)
+					memset(d, 0, clearsize);
+
+				else {
+					*(d+0) = 0;
+					*(d+1) = 0;
+					*(d+2) = 0;
+					if (nclears > 4) {
+						*(d+3) = 0;
+						*(d+4) = 0;
+						if (nclears > 6) {
+							*(d+5) = 0;
+							*(d+6) = 0;
+							if (nclears > 8) {
+								*(d+7) = 0;
+								*(d+8) = 0;
+							}
+						}
+					}
+				}
 			}
-		    }
-		}
-	    }
-	}
 #if 0
-	else
-	{
-	/* Standard unix mmap using /dev/zero clears memory so calloc
-	 * doesn't need to actually zero anything....
-	 */
-	    d = (size_t*)mem;
-	    /* Note the additional (sizeof(size_t)) */
-	    clearsize = chunksize(p) - 2*(sizeof(size_t));
-	    memset(d, 0, clearsize);
-	}
+		else
+			{
+				/* Standard unix mmap using /dev/zero clears memory so calloc
+				 * doesn't need to actually zero anything....
+				 */
+				d = (size_t*)mem;
+				/* Note the additional (sizeof(size_t)) */
+				clearsize = chunksize(p) - 2*(sizeof(size_t));
+				memset(d, 0, clearsize);
+			}
 #endif
     }
-    UNLOCK;
+    __MALLOC_UNLOCK;
     return mem;
 }
 
diff --git a/libc/stdlib/malloc-standard/free.c b/libc/stdlib/malloc-standard/free.c
index 94e1d65..4e08ef7 100644
--- a/libc/stdlib/malloc-standard/free.c
+++ b/libc/stdlib/malloc-standard/free.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -42,71 +42,71 @@ static int __malloc_trim(size_t pad, mst
 
     if (extra > 0) {
 
-	/*
-	   Only proceed if end of memory is where we last set it.
-	   This avoids problems if there were foreign sbrk calls.
-	   */
-	current_brk = (char*)(MORECORE(0));
-	if (current_brk == (char*)(av->top) + top_size) {
-
-	    /*
-	       Attempt to release memory. We ignore MORECORE return value,
-	       and instead call again to find out where new end of memory is.
-	       This avoids problems if first call releases less than we asked,
-	       of if failure somehow altered brk value. (We could still
-	       encounter problems if it altered brk in some very bad way,
-	       but the only thing we can do is adjust anyway, which will cause
-	       some downstream failure.)
-	       */
-
-	    MORECORE(-extra);
-	    new_brk = (char*)(MORECORE(0));
-
-	    if (new_brk != (char*)MORECORE_FAILURE) {
-		released = (long)(current_brk - new_brk);
-
-		if (released != 0) {
-		    /* Success. Adjust top. */
-		    av->sbrked_mem -= released;
-		    set_head(av->top, (top_size - released) | PREV_INUSE);
-		    check_malloc_state();
-		    return 1;
+		/*
+		  Only proceed if end of memory is where we last set it.
+		  This avoids problems if there were foreign sbrk calls.
+		*/
+		current_brk = (char*)(MORECORE(0));
+		if (current_brk == (char*)(av->top) + top_size) {
+
+			/*
+			  Attempt to release memory. We ignore MORECORE return value,
+			  and instead call again to find out where new end of memory is.
+			  This avoids problems if first call releases less than we asked,
+			  of if failure somehow altered brk value. (We could still
+			  encounter problems if it altered brk in some very bad way,
+			  but the only thing we can do is adjust anyway, which will cause
+			  some downstream failure.)
+			*/
+
+			MORECORE(-extra);
+			new_brk = (char*)(MORECORE(0));
+
+			if (new_brk != (char*)MORECORE_FAILURE) {
+				released = (long)(current_brk - new_brk);
+
+				if (released != 0) {
+					/* Success. Adjust top. */
+					av->sbrked_mem -= released;
+					set_head(av->top, (top_size - released) | PREV_INUSE);
+					check_malloc_state();
+					return 1;
+				}
+			}
 		}
-	    }
-	}
     }
     return 0;
 }
 
 /* ------------------------- malloc_trim -------------------------
-  malloc_trim(size_t pad);
+   malloc_trim(size_t pad);
 
-  If possible, gives memory back to the system (via negative
-  arguments to sbrk) if there is unused memory at the `high' end of
-  the malloc pool. You can call this after freeing large blocks of
-  memory to potentially reduce the system-level memory requirements
-  of a program. However, it cannot guarantee to reduce memory. Under
-  some allocation patterns, some large free blocks of memory will be
-  locked between two used chunks, so they cannot be given back to
-  the system.
-
-  The `pad' argument to malloc_trim represents the amount of free
-  trailing space to leave untrimmed. If this argument is zero,
-  only the minimum amount of memory to maintain internal data
-  structures will be left (one page or less). Non-zero arguments
-  can be supplied to maintain enough trailing space to service
-  future expected allocations without having to re-obtain memory
-  from the system.
-
-  Malloc_trim returns 1 if it actually released any memory, else 0.
-  On systems that do not support "negative sbrks", it will always
-  return 0.
+   If possible, gives memory back to the system (via negative
+   arguments to sbrk) if there is unused memory at the `high' end of
+   the malloc pool. You can call this after freeing large blocks of
+   memory to potentially reduce the system-level memory requirements
+   of a program. However, it cannot guarantee to reduce memory. Under
+   some allocation patterns, some large free blocks of memory will be
+   locked between two used chunks, so they cannot be given back to
+   the system.
+
+   The `pad' argument to malloc_trim represents the amount of free
+   trailing space to leave untrimmed. If this argument is zero,
+   only the minimum amount of memory to maintain internal data
+   structures will be left (one page or less). Non-zero arguments
+   can be supplied to maintain enough trailing space to service
+   future expected allocations without having to re-obtain memory
+   from the system.
+
+   Malloc_trim returns 1 if it actually released any memory, else 0.
+   On systems that do not support "negative sbrks", it will always
+   return 0.
 */
 int malloc_trim(size_t pad)
 {
-  mstate av = get_malloc_state();
-  __malloc_consolidate(av);
-  return __malloc_trim(pad, av);
+	mstate av = get_malloc_state();
+	__malloc_consolidate(av);
+	return __malloc_trim(pad, av);
 }
 
 /*
@@ -125,8 +125,8 @@ static void malloc_init_state(mstate av)
 
     /* Establish circular links for normal bins */
     for (i = 1; i < NBINS; ++i) {
-	bin = bin_at(av,i);
-	bin->fd = bin->bk = bin;
+		bin = bin_at(av,i);
+		bin->fd = bin->bk = bin;
     }
 
     av->top_pad        = DEFAULT_TOP_PAD;
@@ -157,15 +157,15 @@ static void malloc_init_state(mstate av)
 
 /* ------------------------- __malloc_consolidate -------------------------
 
-  __malloc_consolidate is a specialized version of free() that tears
-  down chunks held in fastbins.  Free itself cannot be used for this
-  purpose since, among other things, it might place chunks back onto
-  fastbins.  So, instead, we need to use a minor variant of the same
-  code.
-
-  Also, because this routine needs to be called the first time through
-  malloc anyway, it turns out to be the perfect place to trigger
-  initialization code.
+__malloc_consolidate is a specialized version of free() that tears
+down chunks held in fastbins.  Free itself cannot be used for this
+purpose since, among other things, it might place chunks back onto
+fastbins.  So, instead, we need to use a minor variant of the same
+code.
+
+Also, because this routine needs to be called the first time through
+malloc anyway, it turns out to be the perfect place to trigger
+initialization code.
 */
 void __malloc_consolidate(mstate av)
 {
@@ -186,78 +186,78 @@ void __malloc_consolidate(mstate av)
     mchunkptr       fwd;
 
     /*
-       If max_fast is 0, we know that av hasn't
-       yet been initialized, in which case do so below
-       */
+	  If max_fast is 0, we know that av hasn't
+	  yet been initialized, in which case do so below
+	*/
 
     if (av->max_fast != 0) {
-	clear_fastchunks(av);
+		clear_fastchunks(av);
 
-	unsorted_bin = unsorted_chunks(av);
+		unsorted_bin = unsorted_chunks(av);
 
-	/*
-	   Remove each chunk from fast bin and consolidate it, placing it
-	   then in unsorted bin. Among other reasons for doing this,
-	   placing in unsorted bin avoids needing to calculate actual bins
-	   until malloc is sure that chunks aren't immediately going to be
-	   reused anyway.
-	   */
-
-	maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
-	fb = &(av->fastbins[0]);
-	do {
-	    if ( (p = *fb) != 0) {
-		*fb = 0;
+		/*
+		  Remove each chunk from fast bin and consolidate it, placing it
+		  then in unsorted bin. Among other reasons for doing this,
+		  placing in unsorted bin avoids needing to calculate actual bins
+		  until malloc is sure that chunks aren't immediately going to be
+		  reused anyway.
+		*/
 
+		maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
+		fb = &(av->fastbins[0]);
 		do {
-		    check_inuse_chunk(p);
-		    nextp = p->fd;
+			if ( (p = *fb) != 0) {
+				*fb = 0;
 
-		    /* Slightly streamlined version of consolidation code in free() */
-		    size = p->size & ~PREV_INUSE;
-		    nextchunk = chunk_at_offset(p, size);
-		    nextsize = chunksize(nextchunk);
+				do {
+					check_inuse_chunk(p);
+					nextp = p->fd;
+
+					/* Slightly streamlined version of consolidation code in free() */
+					size = p->size & ~PREV_INUSE;
+					nextchunk = chunk_at_offset(p, size);
+					nextsize = chunksize(nextchunk);
+
+					if (!prev_inuse(p)) {
+						prevsize = p->prev_size;
+						size += prevsize;
+						p = chunk_at_offset(p, -((long) prevsize));
+						unlink(p, bck, fwd);
+					}
+
+					if (nextchunk != av->top) {
+						nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
+						set_head(nextchunk, nextsize);
+
+						if (!nextinuse) {
+							size += nextsize;
+							unlink(nextchunk, bck, fwd);
+						}
+
+						first_unsorted = unsorted_bin->fd;
+						unsorted_bin->fd = p;
+						first_unsorted->bk = p;
+
+						set_head(p, size | PREV_INUSE);
+						p->bk = unsorted_bin;
+						p->fd = first_unsorted;
+						set_foot(p, size);
+					}
+
+					else {
+						size += nextsize;
+						set_head(p, size | PREV_INUSE);
+						av->top = p;
+					}
 
-		    if (!prev_inuse(p)) {
-			prevsize = p->prev_size;
-			size += prevsize;
-			p = chunk_at_offset(p, -((long) prevsize));
-			unlink(p, bck, fwd);
-		    }
+				} while ( (p = nextp) != 0);
 
-		    if (nextchunk != av->top) {
-			nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-			set_head(nextchunk, nextsize);
-
-			if (!nextinuse) {
-			    size += nextsize;
-			    unlink(nextchunk, bck, fwd);
 			}
-
-			first_unsorted = unsorted_bin->fd;
-			unsorted_bin->fd = p;
-			first_unsorted->bk = p;
-
-			set_head(p, size | PREV_INUSE);
-			p->bk = unsorted_bin;
-			p->fd = first_unsorted;
-			set_foot(p, size);
-		    }
-
-		    else {
-			size += nextsize;
-			set_head(p, size | PREV_INUSE);
-			av->top = p;
-		    }
-
-		} while ( (p = nextp) != 0);
-
-	    }
-	} while (fb++ != maxfb);
+		} while (fb++ != maxfb);
     }
     else {
-	malloc_init_state(av);
-	check_malloc_state();
+		malloc_init_state(av);
+		check_malloc_state();
     }
 }
 
@@ -279,9 +279,9 @@ void free(void* mem)
 
     /* free(0) has no effect */
     if (mem == NULL)
-	return;
+		return;
 
-    LOCK;
+    __MALLOC_LOCK;
     av = get_malloc_state();
     p = mem2chunk(mem);
     size = chunksize(p);
@@ -289,9 +289,9 @@ void free(void* mem)
     check_inuse_chunk(p);
 
     /*
-       If eligible, place chunk on a fastbin so it can be found
-       and used quickly in malloc.
-       */
+	  If eligible, place chunk on a fastbin so it can be found
+	  and used quickly in malloc.
+	*/
 
     if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
 
@@ -300,114 +300,114 @@ void free(void* mem)
 	       bordering top into fastbins */
 	    && (chunk_at_offset(p, size) != av->top)
 #endif
-       ) {
+		) {
 
-	set_fastchunks(av);
-	fb = &(av->fastbins[fastbin_index(size)]);
-	p->fd = *fb;
-	*fb = p;
+		set_fastchunks(av);
+		fb = &(av->fastbins[fastbin_index(size)]);
+		p->fd = *fb;
+		*fb = p;
     }
 
     /*
-       Consolidate other non-mmapped chunks as they arrive.
-       */
+	  Consolidate other non-mmapped chunks as they arrive.
+	*/
 
     else if (!chunk_is_mmapped(p)) {
-	set_anychunks(av);
+		set_anychunks(av);
+
+		nextchunk = chunk_at_offset(p, size);
+		nextsize = chunksize(nextchunk);
+
+		/* consolidate backward */
+		if (!prev_inuse(p)) {
+			prevsize = p->prev_size;
+			size += prevsize;
+			p = chunk_at_offset(p, -((long) prevsize));
+			unlink(p, bck, fwd);
+		}
+
+		if (nextchunk != av->top) {
+			/* get and clear inuse bit */
+			nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
+			set_head(nextchunk, nextsize);
+
+			/* consolidate forward */
+			if (!nextinuse) {
+				unlink(nextchunk, bck, fwd);
+				size += nextsize;
+			}
+
+			/*
+			  Place the chunk in unsorted chunk list. Chunks are
+			  not placed into regular bins until after they have
+			  been given one chance to be used in malloc.
+			*/
+
+			bck = unsorted_chunks(av);
+			fwd = bck->fd;
+			p->bk = bck;
+			p->fd = fwd;
+			bck->fd = p;
+			fwd->bk = p;
 
-	nextchunk = chunk_at_offset(p, size);
-	nextsize = chunksize(nextchunk);
+			set_head(p, size | PREV_INUSE);
+			set_foot(p, size);
+
+			check_free_chunk(p);
+		}
+
+		/*
+		  If the chunk borders the current high end of memory,
+		  consolidate into top
+		*/
 
-	/* consolidate backward */
-	if (!prev_inuse(p)) {
-	    prevsize = p->prev_size;
-	    size += prevsize;
-	    p = chunk_at_offset(p, -((long) prevsize));
-	    unlink(p, bck, fwd);
-	}
-
-	if (nextchunk != av->top) {
-	    /* get and clear inuse bit */
-	    nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-	    set_head(nextchunk, nextsize);
-
-	    /* consolidate forward */
-	    if (!nextinuse) {
-		unlink(nextchunk, bck, fwd);
-		size += nextsize;
-	    }
-
-	    /*
-	       Place the chunk in unsorted chunk list. Chunks are
-	       not placed into regular bins until after they have
-	       been given one chance to be used in malloc.
-	       */
-
-	    bck = unsorted_chunks(av);
-	    fwd = bck->fd;
-	    p->bk = bck;
-	    p->fd = fwd;
-	    bck->fd = p;
-	    fwd->bk = p;
-
-	    set_head(p, size | PREV_INUSE);
-	    set_foot(p, size);
-
-	    check_free_chunk(p);
-	}
-
-	/*
-	   If the chunk borders the current high end of memory,
-	   consolidate into top
-	   */
-
-	else {
-	    size += nextsize;
-	    set_head(p, size | PREV_INUSE);
-	    av->top = p;
-	    check_chunk(p);
-	}
-
-	/*
-	   If freeing a large space, consolidate possibly-surrounding
-	   chunks. Then, if the total unused topmost memory exceeds trim
-	   threshold, ask malloc_trim to reduce top.
-
-	   Unless max_fast is 0, we don't know if there are fastbins
-	   bordering top, so we cannot tell for sure whether threshold
-	   has been reached unless fastbins are consolidated.  But we
-	   don't want to consolidate on each free.  As a compromise,
-	   consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
-	   is reached.
-	   */
-
-	if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
-	    if (have_fastchunks(av))
-		__malloc_consolidate(av);
-
-	    if ((unsigned long)(chunksize(av->top)) >=
-		    (unsigned long)(av->trim_threshold))
-		__malloc_trim(av->top_pad, av);
-	}
+		else {
+			size += nextsize;
+			set_head(p, size | PREV_INUSE);
+			av->top = p;
+			check_chunk(p);
+		}
+
+		/*
+		  If freeing a large space, consolidate possibly-surrounding
+		  chunks. Then, if the total unused topmost memory exceeds trim
+		  threshold, ask malloc_trim to reduce top.
+
+		  Unless max_fast is 0, we don't know if there are fastbins
+		  bordering top, so we cannot tell for sure whether threshold
+		  has been reached unless fastbins are consolidated.  But we
+		  don't want to consolidate on each free.  As a compromise,
+		  consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
+		  is reached.
+		*/
+
+		if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
+			if (have_fastchunks(av))
+				__malloc_consolidate(av);
+
+			if ((unsigned long)(chunksize(av->top)) >=
+				(unsigned long)(av->trim_threshold))
+				__malloc_trim(av->top_pad, av);
+		}
 
     }
     /*
-       If the chunk was allocated via mmap, release via munmap()
-       Note that if HAVE_MMAP is false but chunk_is_mmapped is
-       true, then user must have overwritten memory. There's nothing
-       we can do to catch this error unless DEBUG is set, in which case
-       check_inuse_chunk (above) will have triggered error.
-       */
+	  If the chunk was allocated via mmap, release via munmap()
+	  Note that if HAVE_MMAP is false but chunk_is_mmapped is
+	  true, then user must have overwritten memory. There's nothing
+	  we can do to catch this error unless DEBUG is set, in which case
+	  check_inuse_chunk (above) will have triggered error.
+	*/
 
     else {
-	int ret;
-	size_t offset = p->prev_size;
-	av->n_mmaps--;
-	av->mmapped_mem -= (size + offset);
-	ret = munmap((char*)p - offset, size + offset);
-	/* munmap returns non-zero on failure */
-	assert(ret == 0);
+		int ret;
+		size_t offset = p->prev_size;
+		av->n_mmaps--;
+		av->mmapped_mem -= (size + offset);
+		ret = munmap((char*)p - offset, size + offset);
+		/* munmap returns non-zero on failure */
+		assert(ret == 0);
     }
-    UNLOCK;
+    __MALLOC_UNLOCK;
 }
 
diff --git a/libc/stdlib/malloc-standard/mallinfo.c b/libc/stdlib/malloc-standard/mallinfo.c
index 51ac423..1e0875c 100644
--- a/libc/stdlib/malloc-standard/mallinfo.c
+++ b/libc/stdlib/malloc-standard/mallinfo.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -30,11 +30,11 @@ struct mallinfo mallinfo(void)
     int nblocks;
     int nfastblocks;
 
-    LOCK;
+    __MALLOC_LOCK;
     av = get_malloc_state();
     /* Ensure initialization */
     if (av->top == 0)  {
-	__malloc_consolidate(av);
+		__malloc_consolidate(av);
     }
 
     check_malloc_state();
@@ -48,21 +48,21 @@ struct mallinfo mallinfo(void)
     fastavail = 0;
 
     for (i = 0; i < NFASTBINS; ++i) {
-	for (p = av->fastbins[i]; p != 0; p = p->fd) {
-	    ++nfastblocks;
-	    fastavail += chunksize(p);
-	}
+		for (p = av->fastbins[i]; p != 0; p = p->fd) {
+			++nfastblocks;
+			fastavail += chunksize(p);
+		}
     }
 
     avail += fastavail;
 
     /* traverse regular bins */
     for (i = 1; i < NBINS; ++i) {
-	b = bin_at(av, i);
-	for (p = last(b); p != b; p = p->bk) {
-	    ++nblocks;
-	    avail += chunksize(p);
-	}
+		b = bin_at(av, i);
+		for (p = last(b); p != b; p = p->bk) {
+			++nblocks;
+			avail += chunksize(p);
+		}
     }
 
     mi.smblks = nfastblocks;
@@ -75,7 +75,7 @@ struct mallinfo mallinfo(void)
     mi.fsmblks = fastavail;
     mi.keepcost = chunksize(av->top);
     mi.usmblks = av->max_total_mem;
-    UNLOCK;
+    __MALLOC_UNLOCK;
     return mi;
 }
 
@@ -84,23 +84,40 @@ void malloc_stats(FILE *file)
     struct mallinfo mi;
 
     if (file==NULL) {
-	file = stderr;
+		file = stderr;
     }
 
     mi = mallinfo();
-    fprintf(file, "total bytes allocated             = %10u\n", (unsigned int)(mi.arena + mi.hblkhd));
-    fprintf(file, "total bytes in use bytes          = %10u\n", (unsigned int)(mi.uordblks + mi.hblkhd));
-    fprintf(file, "total non-mmapped bytes allocated = %10d\n", mi.arena);
-    fprintf(file, "number of mmapped regions         = %10d\n", mi.hblks);
-    fprintf(file, "total allocated mmap space        = %10d\n", mi.hblkhd);
-    fprintf(file, "total allocated sbrk space        = %10d\n", mi.uordblks);
+    fprintf(file,
+			"total bytes allocated             = %10u\n"
+			"total bytes in use bytes          = %10u\n"
+			"total non-mmapped bytes allocated = %10d\n"
+			"number of mmapped regions         = %10d\n"
+			"total allocated mmap space        = %10d\n"
+			"total allocated sbrk space        = %10d\n"
 #if 0
-    fprintf(file, "number of free chunks             = %10d\n", mi.ordblks);
-    fprintf(file, "number of fastbin blocks          = %10d\n", mi.smblks);
-    fprintf(file, "space in freed fastbin blocks     = %10d\n", mi.fsmblks);
+			"number of free chunks             = %10d\n"
+			"number of fastbin blocks          = %10d\n"
+			"space in freed fastbin blocks     = %10d\n"
 #endif
-    fprintf(file, "maximum total allocated space     = %10d\n", mi.usmblks);
-    fprintf(file, "total free space                  = %10d\n", mi.fordblks);
-    fprintf(file, "memory releasable via malloc_trim = %10d\n", mi.keepcost);
+			"maximum total allocated space     = %10d\n"
+			"total free space                  = %10d\n"
+			"memory releasable via malloc_trim = %10d\n",
+
+			(unsigned int)(mi.arena + mi.hblkhd),
+			(unsigned int)(mi.uordblks + mi.hblkhd),
+			mi.arena,
+			mi.hblks,
+			mi.hblkhd,
+			mi.uordblks,
+#if 0
+			mi.ordblks,
+			mi.smblks,
+			mi.fsmblks,
+#endif
+			mi.usmblks,
+			mi.fordblks,
+			mi.keepcost
+			);
 }
 
diff --git a/libc/stdlib/malloc-standard/malloc.c b/libc/stdlib/malloc-standard/malloc.c
index 7025e83..60494a0 100644
--- a/libc/stdlib/malloc-standard/malloc.c
+++ b/libc/stdlib/malloc-standard/malloc.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -17,17 +17,14 @@
 #define _GNU_SOURCE
 #include "malloc.h"
 
-
-#ifdef __UCLIBC_HAS_THREADS__
-pthread_mutex_t __malloc_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-#endif
+__UCLIBC_MUTEX_INIT(__malloc_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 /*
-   There is exactly one instance of this struct in this malloc.
-   If you are adapting this malloc in a way that does NOT use a static
-   malloc_state, you MUST explicitly zero-fill it before using. This
-   malloc relies on the property that malloc_state is initialized to
-   all zeroes (as is true of C statics).
+  There is exactly one instance of this struct in this malloc.
+  If you are adapting this malloc in a way that does NOT use a static
+  malloc_state, you MUST explicitly zero-fill it before using. This
+  malloc relies on the property that malloc_state is initialized to
+  all zeroes (as is true of C statics).
 */
 struct malloc_state __malloc_state;  /* never directly referenced */
 
@@ -77,30 +74,30 @@ void __do_check_chunk(mchunkptr p)
 
     if (!chunk_is_mmapped(p)) {
 
-	/* Has legal address ... */
-	if (p != av->top) {
-	    if (contiguous(av)) {
-		assert(((char*)p) >= min_address);
-		assert(((char*)p + sz) <= ((char*)(av->top)));
-	    }
-	}
-	else {
-	    /* top size is always at least MINSIZE */
-	    assert((unsigned long)(sz) >= MINSIZE);
-	    /* top predecessor always marked inuse */
-	    assert(prev_inuse(p));
-	}
+		/* Has legal address ... */
+		if (p != av->top) {
+			if (contiguous(av)) {
+				assert(((char*)p) >= min_address);
+				assert(((char*)p + sz) <= ((char*)(av->top)));
+			}
+		}
+		else {
+			/* top size is always at least MINSIZE */
+			assert((unsigned long)(sz) >= MINSIZE);
+			/* top predecessor always marked inuse */
+			assert(prev_inuse(p));
+		}
 
     }
     else {
-	/* address is outside main heap  */
-	if (contiguous(av) && av->top != initial_top(av)) {
-	    assert(((char*)p) < min_address || ((char*)p) > max_address);
-	}
-	/* chunk is page-aligned */
-	assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
-	/* mem is aligned */
-	assert(aligned_OK(chunk2mem(p)));
+		/* address is outside main heap  */
+		if (contiguous(av) && av->top != initial_top(av)) {
+			assert(((char*)p) < min_address || ((char*)p) > max_address);
+		}
+		/* chunk is page-aligned */
+		assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
+		/* mem is aligned */
+		assert(aligned_OK(chunk2mem(p)));
     }
 }
 
@@ -121,21 +118,21 @@ void __do_check_free_chunk(mchunkptr p)
 
     /* Unless a special marker, must have OK fields */
     if ((unsigned long)(sz) >= MINSIZE)
-    {
-	assert((sz & MALLOC_ALIGN_MASK) == 0);
-	assert(aligned_OK(chunk2mem(p)));
-	/* ... matching footer field */
-	assert(next->prev_size == sz);
-	/* ... and is fully consolidated */
-	assert(prev_inuse(p));
-	assert (next == av->top || inuse(next));
-
-	/* ... and has minimally sane links */
-	assert(p->fd->bk == p);
-	assert(p->bk->fd == p);
-    }
+		{
+			assert((sz & MALLOC_ALIGN_MASK) == 0);
+			assert(aligned_OK(chunk2mem(p)));
+			/* ... matching footer field */
+			assert(next->prev_size == sz);
+			/* ... and is fully consolidated */
+			assert(prev_inuse(p));
+			assert (next == av->top || inuse(next));
+
+			/* ... and has minimally sane links */
+			assert(p->fd->bk == p);
+			assert(p->bk->fd == p);
+		}
     else /* markers are always of size (sizeof(size_t)) */
-	assert(sz == (sizeof(size_t)));
+		assert(sz == (sizeof(size_t)));
 }
 
 /* Properties of inuse chunks */
@@ -146,7 +143,7 @@ void __do_check_inuse_chunk(mchunkptr p)
     __do_check_chunk(p);
 
     if (chunk_is_mmapped(p))
-	return; /* mmapped chunks have no next/prev */
+		return; /* mmapped chunks have no next/prev */
 
     /* Check whether it claims to be in use ... */
     assert(inuse(p));
@@ -156,20 +153,20 @@ void __do_check_inuse_chunk(mchunkptr p)
     /* ... and is surrounded by OK chunks.
        Since more things can be checked with free chunks than inuse ones,
        if an inuse chunk borders them and debug is on, it's worth doing them.
-       */
+	*/
     if (!prev_inuse(p))  {
-	/* Note that we cannot even look at prev unless it is not inuse */
-	mchunkptr prv = prev_chunk(p);
-	assert(next_chunk(prv) == p);
-	__do_check_free_chunk(prv);
+		/* Note that we cannot even look at prev unless it is not inuse */
+		mchunkptr prv = prev_chunk(p);
+		assert(next_chunk(prv) == p);
+		__do_check_free_chunk(prv);
     }
 
     if (next == av->top) {
-	assert(prev_inuse(next));
-	assert(chunksize(next) >= MINSIZE);
+		assert(prev_inuse(next));
+		assert(chunksize(next) >= MINSIZE);
     }
     else if (!inuse(next))
-	__do_check_free_chunk(next);
+		__do_check_free_chunk(next);
 }
 
 /* Properties of chunks recycled from fastbins */
@@ -198,14 +195,14 @@ void __do_check_malloced_chunk(mchunkptr
     __do_check_remalloced_chunk(p, s);
 
     /*
-       ... plus,  must obey implementation invariant that prev_inuse is
-       always true of any allocated chunk; i.e., that each allocated
-       chunk borders either a previously allocated and still in-use
-       chunk, or the base of its memory arena. This is ensured
-       by making all allocations from the the `lowest' part of any found
-       chunk.  This does not necessarily hold however for chunks
-       recycled via fastbins.
-       */
+	  ... plus,  must obey implementation invariant that prev_inuse is
+	  always true of any allocated chunk; i.e., that each allocated
+	  chunk borders either a previously allocated and still in-use
+	  chunk, or the base of its memory arena. This is ensured
+	  by making all allocations from the the `lowest' part of any found
+	  chunk.  This does not necessarily hold however for chunks
+	  recycled via fastbins.
+	*/
 
     assert(prev_inuse(p));
 }
@@ -243,7 +240,7 @@ void __do_check_malloc_state(void)
 
     /* cannot run remaining checks until fully initialized */
     if (av->top == 0 || av->top == initial_top(av))
-	return;
+		return;
 
     /* pagesize is a power of 2 */
     assert((av->pagesize & (av->pagesize-1)) == 0);
@@ -256,64 +253,64 @@ void __do_check_malloc_state(void)
     max_fast_bin = fastbin_index(av->max_fast);
 
     for (i = 0; i < NFASTBINS; ++i) {
-	p = av->fastbins[i];
+		p = av->fastbins[i];
 
-	/* all bins past max_fast are empty */
-	if (i > max_fast_bin)
-	    assert(p == 0);
-
-	while (p != 0) {
-	    /* each chunk claims to be inuse */
-	    __do_check_inuse_chunk(p);
-	    total += chunksize(p);
-	    /* chunk belongs in this bin */
-	    assert(fastbin_index(chunksize(p)) == i);
-	    p = p->fd;
-	}
+		/* all bins past max_fast are empty */
+		if (i > max_fast_bin)
+			assert(p == 0);
+
+		while (p != 0) {
+			/* each chunk claims to be inuse */
+			__do_check_inuse_chunk(p);
+			total += chunksize(p);
+			/* chunk belongs in this bin */
+			assert(fastbin_index(chunksize(p)) == i);
+			p = p->fd;
+		}
     }
 
     if (total != 0)
-	assert(have_fastchunks(av));
+		assert(have_fastchunks(av));
     else if (!have_fastchunks(av))
-	assert(total == 0);
+		assert(total == 0);
 
     /* check normal bins */
     for (i = 1; i < NBINS; ++i) {
-	b = bin_at(av,i);
+		b = bin_at(av,i);
 
-	/* binmap is accurate (except for bin 1 == unsorted_chunks) */
-	if (i >= 2) {
-	    binbit = get_binmap(av,i);
-	    empty = last(b) == b;
-	    if (!binbit)
-		assert(empty);
-	    else if (!empty)
-		assert(binbit);
-	}
-
-	for (p = last(b); p != b; p = p->bk) {
-	    /* each chunk claims to be free */
-	    __do_check_free_chunk(p);
-	    size = chunksize(p);
-	    total += size;
-	    if (i >= 2) {
-		/* chunk belongs in bin */
-		idx = bin_index(size);
-		assert(idx == i);
-		/* lists are sorted */
-		if ((unsigned long) size >= (unsigned long)(FIRST_SORTED_BIN_SIZE)) {
-		    assert(p->bk == b ||
-			    (unsigned long)chunksize(p->bk) >=
-			    (unsigned long)chunksize(p));
-		}
-	    }
-	    /* chunk is followed by a legal chain of inuse chunks */
-	    for (q = next_chunk(p);
-		    (q != av->top && inuse(q) &&
-		     (unsigned long)(chunksize(q)) >= MINSIZE);
-		    q = next_chunk(q))
-		__do_check_inuse_chunk(q);
-	}
+		/* binmap is accurate (except for bin 1 == unsorted_chunks) */
+		if (i >= 2) {
+			binbit = get_binmap(av,i);
+			empty = last(b) == b;
+			if (!binbit)
+				assert(empty);
+			else if (!empty)
+				assert(binbit);
+		}
+
+		for (p = last(b); p != b; p = p->bk) {
+			/* each chunk claims to be free */
+			__do_check_free_chunk(p);
+			size = chunksize(p);
+			total += size;
+			if (i >= 2) {
+				/* chunk belongs in bin */
+				idx = bin_index(size);
+				assert(idx == i);
+				/* lists are sorted */
+				if ((unsigned long) size >= (unsigned long)(FIRST_SORTED_BIN_SIZE)) {
+					assert(p->bk == b ||
+						   (unsigned long)chunksize(p->bk) >=
+						   (unsigned long)chunksize(p));
+				}
+			}
+			/* chunk is followed by a legal chain of inuse chunks */
+			for (q = next_chunk(p);
+				 (q != av->top && inuse(q) &&
+				  (unsigned long)(chunksize(q)) >= MINSIZE);
+				 q = next_chunk(q))
+				__do_check_inuse_chunk(q);
+		}
     }
 
     /* top chunk is OK */
@@ -326,13 +323,13 @@ void __do_check_malloc_state(void)
     assert(av->n_mmaps <= av->max_n_mmaps);
 
     assert((unsigned long)(av->sbrked_mem) <=
-	    (unsigned long)(av->max_sbrked_mem));
+		   (unsigned long)(av->max_sbrked_mem));
 
     assert((unsigned long)(av->mmapped_mem) <=
-	    (unsigned long)(av->max_mmapped_mem));
+		   (unsigned long)(av->max_mmapped_mem));
 
     assert((unsigned long)(av->max_total_mem) >=
-	    (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
+		   (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
 }
 #endif
 
@@ -370,84 +367,84 @@ static void* __malloc_alloc(size_t nb, m
     size_t          pagemask  = av->pagesize - 1;
 
     /*
-       If there is space available in fastbins, consolidate and retry
-       malloc from scratch rather than getting memory from system.  This
-       can occur only if nb is in smallbin range so we didn't consolidate
-       upon entry to malloc. It is much easier to handle this case here
-       than in malloc proper.
-       */
+	  If there is space available in fastbins, consolidate and retry
+	  malloc from scratch rather than getting memory from system.  This
+	  can occur only if nb is in smallbin range so we didn't consolidate
+	  upon entry to malloc. It is much easier to handle this case here
+	  than in malloc proper.
+	*/
 
     if (have_fastchunks(av)) {
-	assert(in_smallbin_range(nb));
-	__malloc_consolidate(av);
-	return malloc(nb - MALLOC_ALIGN_MASK);
+		assert(in_smallbin_range(nb));
+		__malloc_consolidate(av);
+		return malloc(nb - MALLOC_ALIGN_MASK);
     }
 
 
     /*
-       If have mmap, and the request size meets the mmap threshold, and
-       the system supports mmap, and there are few enough currently
-       allocated mmapped regions, try to directly map this request
-       rather than expanding top.
-       */
+	  If have mmap, and the request size meets the mmap threshold, and
+	  the system supports mmap, and there are few enough currently
+	  allocated mmapped regions, try to directly map this request
+	  rather than expanding top.
+	*/
 
     if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
 	    (av->n_mmaps < av->n_mmaps_max)) {
 
-	char* mm;             /* return value from mmap call*/
-
-	/*
-	   Round up size to nearest page.  For mmapped chunks, the overhead
-	   is one (sizeof(size_t)) unit larger than for normal chunks, because there
-	   is no following chunk whose prev_size field could be used.
-	   */
-	size = (nb + (sizeof(size_t)) + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
-
-	/* Don't try if size wraps around 0 */
-	if ((unsigned long)(size) > (unsigned long)(nb)) {
-
-	    mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE));
-
-	    if (mm != (char*)(MORECORE_FAILURE)) {
+		char* mm;             /* return value from mmap call*/
 
 		/*
-		   The offset to the start of the mmapped region is stored
-		   in the prev_size field of the chunk. This allows us to adjust
-		   returned start address to meet alignment requirements here
-		   and in memalign(), and still be able to compute proper
-		   address argument for later munmap in free() and realloc().
-		   */
-
-		front_misalign = (size_t)chunk2mem(mm) & MALLOC_ALIGN_MASK;
-		if (front_misalign > 0) {
-		    correction = MALLOC_ALIGNMENT - front_misalign;
-		    p = (mchunkptr)(mm + correction);
-		    p->prev_size = correction;
-		    set_head(p, (size - correction) |IS_MMAPPED);
-		}
-		else {
-		    p = (mchunkptr)mm;
-		    p->prev_size = 0;
-		    set_head(p, size|IS_MMAPPED);
-		}
+		  Round up size to nearest page.  For mmapped chunks, the overhead
+		  is one (sizeof(size_t)) unit larger than for normal chunks, because there
+		  is no following chunk whose prev_size field could be used.
+		*/
+		size = (nb + (sizeof(size_t)) + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
+
+		/* Don't try if size wraps around 0 */
+		if ((unsigned long)(size) > (unsigned long)(nb)) {
+
+			mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE));
+
+			if (mm != (char*)(MORECORE_FAILURE)) {
+
+				/*
+				  The offset to the start of the mmapped region is stored
+				  in the prev_size field of the chunk. This allows us to adjust
+				  returned start address to meet alignment requirements here
+				  and in memalign(), and still be able to compute proper
+				  address argument for later munmap in free() and realloc().
+				*/
+
+				front_misalign = (size_t)chunk2mem(mm) & MALLOC_ALIGN_MASK;
+				if (front_misalign > 0) {
+					correction = MALLOC_ALIGNMENT - front_misalign;
+					p = (mchunkptr)(mm + correction);
+					p->prev_size = correction;
+					set_head(p, (size - correction) |IS_MMAPPED);
+				}
+				else {
+					p = (mchunkptr)mm;
+					p->prev_size = 0;
+					set_head(p, size|IS_MMAPPED);
+				}
+
+				/* update statistics */
+
+				if (++av->n_mmaps > av->max_n_mmaps)
+					av->max_n_mmaps = av->n_mmaps;
+
+				sum = av->mmapped_mem += size;
+				if (sum > (unsigned long)(av->max_mmapped_mem))
+					av->max_mmapped_mem = sum;
+				sum += av->sbrked_mem;
+				if (sum > (unsigned long)(av->max_total_mem))
+					av->max_total_mem = sum;
 
-		/* update statistics */
+				check_chunk(p);
 
-		if (++av->n_mmaps > av->max_n_mmaps)
-		    av->max_n_mmaps = av->n_mmaps;
-
-		sum = av->mmapped_mem += size;
-		if (sum > (unsigned long)(av->max_mmapped_mem))
-		    av->max_mmapped_mem = sum;
-		sum += av->sbrked_mem;
-		if (sum > (unsigned long)(av->max_total_mem))
-		    av->max_total_mem = sum;
-
-		check_chunk(p);
-
-		return chunk2mem(p);
-	    }
-	}
+				return chunk2mem(p);
+			}
+		}
     }
 
     /* Record incoming configuration of top */
@@ -462,8 +459,8 @@ static void* __malloc_alloc(size_t nb, m
      * be at least MINSIZE and to have prev_inuse set.  */
 
     assert((old_top == initial_top(av) && old_size == 0) ||
-	    ((unsigned long) (old_size) >= MINSIZE &&
-	     prev_inuse(old_top)));
+		   ((unsigned long) (old_size) >= MINSIZE &&
+			prev_inuse(old_top)));
 
     /* Precondition: not enough current space to satisfy nb request */
     assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
@@ -477,272 +474,272 @@ static void* __malloc_alloc(size_t nb, m
     size = nb + av->top_pad + MINSIZE;
 
     /*
-       If contiguous, we can subtract out existing space that we hope to
-       combine with new space. We add it back later only if
-       we don't actually get contiguous space.
-       */
+	  If contiguous, we can subtract out existing space that we hope to
+	  combine with new space. We add it back later only if
+	  we don't actually get contiguous space.
+	*/
 
     if (contiguous(av))
-	size -= old_size;
+		size -= old_size;
 
     /*
-       Round to a multiple of page size.
-       If MORECORE is not contiguous, this ensures that we only call it
-       with whole-page arguments.  And if MORECORE is contiguous and
-       this is not first time through, this preserves page-alignment of
-       previous calls. Otherwise, we correct to page-align below.
-       */
+	  Round to a multiple of page size.
+	  If MORECORE is not contiguous, this ensures that we only call it
+	  with whole-page arguments.  And if MORECORE is contiguous and
+	  this is not first time through, this preserves page-alignment of
+	  previous calls. Otherwise, we correct to page-align below.
+	*/
 
     size = (size + pagemask) & ~pagemask;
 
     /*
-       Don't try to call MORECORE if argument is so big as to appear
-       negative. Note that since mmap takes size_t arg, it may succeed
-       below even if we cannot call MORECORE.
-       */
+	  Don't try to call MORECORE if argument is so big as to appear
+	  negative. Note that since mmap takes size_t arg, it may succeed
+	  below even if we cannot call MORECORE.
+	*/
 
     if (size > 0)
-	brk = (char*)(MORECORE(size));
+		brk = (char*)(MORECORE(size));
 
     /*
-       If have mmap, try using it as a backup when MORECORE fails or
-       cannot be used. This is worth doing on systems that have "holes" in
-       address space, so sbrk cannot extend to give contiguous space, but
-       space is available elsewhere.  Note that we ignore mmap max count
-       and threshold limits, since the space will not be used as a
-       segregated mmap region.
-       */
+	  If have mmap, try using it as a backup when MORECORE fails or
+	  cannot be used. This is worth doing on systems that have "holes" in
+	  address space, so sbrk cannot extend to give contiguous space, but
+	  space is available elsewhere.  Note that we ignore mmap max count
+	  and threshold limits, since the space will not be used as a
+	  segregated mmap region.
+	*/
 
     if (brk == (char*)(MORECORE_FAILURE)) {
 
-	/* Cannot merge with old top, so add its size back in */
-	if (contiguous(av))
-	    size = (size + old_size + pagemask) & ~pagemask;
-
-	/* If we are relying on mmap as backup, then use larger units */
-	if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
-	    size = MMAP_AS_MORECORE_SIZE;
-
-	/* Don't try if size wraps around 0 */
-	if ((unsigned long)(size) > (unsigned long)(nb)) {
-
-	    brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE));
-
-	    if (brk != (char*)(MORECORE_FAILURE)) {
-
-		/* We do not need, and cannot use, another sbrk call to find end */
-		snd_brk = brk + size;
-
-		/* Record that we no longer have a contiguous sbrk region.
-		   After the first time mmap is used as backup, we do not
-		   ever rely on contiguous space since this could incorrectly
-		   bridge regions.
-		   */
-		set_noncontiguous(av);
-	    }
-	}
+		/* Cannot merge with old top, so add its size back in */
+		if (contiguous(av))
+			size = (size + old_size + pagemask) & ~pagemask;
+
+		/* If we are relying on mmap as backup, then use larger units */
+		if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
+			size = MMAP_AS_MORECORE_SIZE;
+
+		/* Don't try if size wraps around 0 */
+		if ((unsigned long)(size) > (unsigned long)(nb)) {
+
+			brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE));
+
+			if (brk != (char*)(MORECORE_FAILURE)) {
+
+				/* We do not need, and cannot use, another sbrk call to find end */
+				snd_brk = brk + size;
+
+				/* Record that we no longer have a contiguous sbrk region.
+				   After the first time mmap is used as backup, we do not
+				   ever rely on contiguous space since this could incorrectly
+				   bridge regions.
+				*/
+				set_noncontiguous(av);
+			}
+		}
     }
 
     if (brk != (char*)(MORECORE_FAILURE)) {
-	av->sbrked_mem += size;
+		av->sbrked_mem += size;
 
-	/*
-	   If MORECORE extends previous space, we can likewise extend top size.
-	   */
-
-	if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
-	    set_head(old_top, (size + old_size) | PREV_INUSE);
-	}
-
-	/*
-	   Otherwise, make adjustments:
-
-	 * If the first time through or noncontiguous, we need to call sbrk
-	 just to find out where the end of memory lies.
-
-	 * We need to ensure that all returned chunks from malloc will meet
-	 MALLOC_ALIGNMENT
-
-	 * If there was an intervening foreign sbrk, we need to adjust sbrk
-	 request size to account for fact that we will not be able to
-	 combine new space with existing space in old_top.
-
-	 * Almost all systems internally allocate whole pages at a time, in
-	 which case we might as well use the whole last page of request.
-	 So we allocate enough more memory to hit a page boundary now,
-	 which in turn causes future contiguous calls to page-align.
-	 */
-
-	else {
-	    front_misalign = 0;
-	    end_misalign = 0;
-	    correction = 0;
-	    aligned_brk = brk;
-
-	    /*
-	       If MORECORE returns an address lower than we have seen before,
-	       we know it isn't really contiguous.  This and some subsequent
-	       checks help cope with non-conforming MORECORE functions and
-	       the presence of "foreign" calls to MORECORE from outside of
-	       malloc or by other threads.  We cannot guarantee to detect
-	       these in all cases, but cope with the ones we do detect.
-	       */
-	    if (contiguous(av) && old_size != 0 && brk < old_end) {
-		set_noncontiguous(av);
-	    }
-
-	    /* handle contiguous cases */
-	    if (contiguous(av)) {
-
-		/* We can tolerate forward non-contiguities here (usually due
-		   to foreign calls) but treat them as part of our space for
-		   stats reporting.  */
-		if (old_size != 0)
-		    av->sbrked_mem += brk - old_end;
-
-		/* Guarantee alignment of first new chunk made from this space */
-
-		front_misalign = (size_t)chunk2mem(brk) & MALLOC_ALIGN_MASK;
-		if (front_misalign > 0) {
-
-		    /*
-		       Skip over some bytes to arrive at an aligned position.
-		       We don't need to specially mark these wasted front bytes.
-		       They will never be accessed anyway because
-		       prev_inuse of av->top (and any chunk created from its start)
-		       is always true after initialization.
-		       */
+		/*
+		  If MORECORE extends previous space, we can likewise extend top size.
+		*/
 
-		    correction = MALLOC_ALIGNMENT - front_misalign;
-		    aligned_brk += correction;
+		if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
+			set_head(old_top, (size + old_size) | PREV_INUSE);
 		}
 
 		/*
-		   If this isn't adjacent to existing space, then we will not
-		   be able to merge with old_top space, so must add to 2nd request.
-		   */
-
-		correction += old_size;
-
-		/* Extend the end address to hit a page boundary */
-		end_misalign = (size_t)(brk + size + correction);
-		correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
-
-		assert(correction >= 0);
-		snd_brk = (char*)(MORECORE(correction));
-
-		if (snd_brk == (char*)(MORECORE_FAILURE)) {
-		    /*
-		       If can't allocate correction, try to at least find out current
-		       brk.  It might be enough to proceed without failing.
-		       */
-		    correction = 0;
-		    snd_brk = (char*)(MORECORE(0));
-		}
-		else if (snd_brk < brk) {
-		    /*
-		       If the second call gives noncontiguous space even though
-		       it says it won't, the only course of action is to ignore
-		       results of second call, and conservatively estimate where
-		       the first call left us. Also set noncontiguous, so this
-		       won't happen again, leaving at most one hole.
-
-		       Note that this check is intrinsically incomplete.  Because
-		       MORECORE is allowed to give more space than we ask for,
-		       there is no reliable way to detect a noncontiguity
-		       producing a forward gap for the second call.
-		       */
-		    snd_brk = brk + size;
-		    correction = 0;
-		    set_noncontiguous(av);
-		}
-
-	    }
-
-	    /* handle non-contiguous cases */
-	    else {
-		/* MORECORE/mmap must correctly align */
-		assert(aligned_OK(chunk2mem(brk)));
-
-		/* Find out current end of memory */
-		if (snd_brk == (char*)(MORECORE_FAILURE)) {
-		    snd_brk = (char*)(MORECORE(0));
-		    av->sbrked_mem += snd_brk - brk - size;
-		}
-	    }
-
-	    /* Adjust top based on results of second sbrk */
-	    if (snd_brk != (char*)(MORECORE_FAILURE)) {
-		av->top = (mchunkptr)aligned_brk;
-		set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
-		av->sbrked_mem += correction;
+		  Otherwise, make adjustments:
 
-		/*
-		   If not the first time through, we either have a
-		   gap due to foreign sbrk or a non-contiguous region.  Insert a
-		   double fencepost at old_top to prevent consolidation with space
-		   we don't own. These fenceposts are artificial chunks that are
-		   marked as inuse and are in any case too small to use.  We need
-		   two to make sizes and alignments work out.
-		   */
-
-		if (old_size != 0) {
-		    /* Shrink old_top to insert fenceposts, keeping size a
-		       multiple of MALLOC_ALIGNMENT. We know there is at least
-		       enough space in old_top to do this.
-		       */
-		    old_size = (old_size - 3*(sizeof(size_t))) & ~MALLOC_ALIGN_MASK;
-		    set_head(old_top, old_size | PREV_INUSE);
-
-		    /*
-		       Note that the following assignments completely overwrite
-		       old_top when old_size was previously MINSIZE.  This is
-		       intentional. We need the fencepost, even if old_top otherwise gets
-		       lost.
-		       */
-		    chunk_at_offset(old_top, old_size          )->size =
-			(sizeof(size_t))|PREV_INUSE;
-
-		    chunk_at_offset(old_top, old_size + (sizeof(size_t)))->size =
-			(sizeof(size_t))|PREV_INUSE;
-
-		    /* If possible, release the rest, suppressing trimming.  */
-		    if (old_size >= MINSIZE) {
-			size_t tt = av->trim_threshold;
-			av->trim_threshold = (size_t)(-1);
-			free(chunk2mem(old_top));
-			av->trim_threshold = tt;
-		    }
-		}
-	    }
-	}
-
-	/* Update statistics */
-	sum = av->sbrked_mem;
-	if (sum > (unsigned long)(av->max_sbrked_mem))
-	    av->max_sbrked_mem = sum;
-
-	sum += av->mmapped_mem;
-	if (sum > (unsigned long)(av->max_total_mem))
-	    av->max_total_mem = sum;
-
-	check_malloc_state();
-
-	/* finally, do the allocation */
-
-	p = av->top;
-	size = chunksize(p);
-
-	/* check that one of the above allocation paths succeeded */
-	if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-	    remainder_size = size - nb;
-	    remainder = chunk_at_offset(p, nb);
-	    av->top = remainder;
-	    set_head(p, nb | PREV_INUSE);
-	    set_head(remainder, remainder_size | PREV_INUSE);
-	    check_malloced_chunk(p, nb);
-	    return chunk2mem(p);
-	}
+		  * If the first time through or noncontiguous, we need to call sbrk
+		  just to find out where the end of memory lies.
+
+		  * We need to ensure that all returned chunks from malloc will meet
+		  MALLOC_ALIGNMENT
+
+		  * If there was an intervening foreign sbrk, we need to adjust sbrk
+		  request size to account for fact that we will not be able to
+		  combine new space with existing space in old_top.
+
+		  * Almost all systems internally allocate whole pages at a time, in
+		  which case we might as well use the whole last page of request.
+		  So we allocate enough more memory to hit a page boundary now,
+		  which in turn causes future contiguous calls to page-align.
+		*/
+
+		else {
+			front_misalign = 0;
+			end_misalign = 0;
+			correction = 0;
+			aligned_brk = brk;
+
+			/*
+			  If MORECORE returns an address lower than we have seen before,
+			  we know it isn't really contiguous.  This and some subsequent
+			  checks help cope with non-conforming MORECORE functions and
+			  the presence of "foreign" calls to MORECORE from outside of
+			  malloc or by other threads.  We cannot guarantee to detect
+			  these in all cases, but cope with the ones we do detect.
+			*/
+			if (contiguous(av) && old_size != 0 && brk < old_end) {
+				set_noncontiguous(av);
+			}
+
+			/* handle contiguous cases */
+			if (contiguous(av)) {
+
+				/* We can tolerate forward non-contiguities here (usually due
+				   to foreign calls) but treat them as part of our space for
+				   stats reporting.  */
+				if (old_size != 0)
+					av->sbrked_mem += brk - old_end;
+
+				/* Guarantee alignment of first new chunk made from this space */
+
+				front_misalign = (size_t)chunk2mem(brk) & MALLOC_ALIGN_MASK;
+				if (front_misalign > 0) {
+
+					/*
+					  Skip over some bytes to arrive at an aligned position.
+					  We don't need to specially mark these wasted front bytes.
+					  They will never be accessed anyway because
+					  prev_inuse of av->top (and any chunk created from its start)
+					  is always true after initialization.
+					*/
+
+					correction = MALLOC_ALIGNMENT - front_misalign;
+					aligned_brk += correction;
+				}
+
+				/*
+				  If this isn't adjacent to existing space, then we will not
+				  be able to merge with old_top space, so must add to 2nd request.
+				*/
+
+				correction += old_size;
+
+				/* Extend the end address to hit a page boundary */
+				end_misalign = (size_t)(brk + size + correction);
+				correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
+
+				assert(correction >= 0);
+				snd_brk = (char*)(MORECORE(correction));
+
+				if (snd_brk == (char*)(MORECORE_FAILURE)) {
+					/*
+					  If can't allocate correction, try to at least find out current
+					  brk.  It might be enough to proceed without failing.
+					*/
+					correction = 0;
+					snd_brk = (char*)(MORECORE(0));
+				}
+				else if (snd_brk < brk) {
+					/*
+					  If the second call gives noncontiguous space even though
+					  it says it won't, the only course of action is to ignore
+					  results of second call, and conservatively estimate where
+					  the first call left us. Also set noncontiguous, so this
+					  won't happen again, leaving at most one hole.
+
+					  Note that this check is intrinsically incomplete.  Because
+					  MORECORE is allowed to give more space than we ask for,
+					  there is no reliable way to detect a noncontiguity
+					  producing a forward gap for the second call.
+					*/
+					snd_brk = brk + size;
+					correction = 0;
+					set_noncontiguous(av);
+				}
+
+			}
+
+			/* handle non-contiguous cases */
+			else {
+				/* MORECORE/mmap must correctly align */
+				assert(aligned_OK(chunk2mem(brk)));
+
+				/* Find out current end of memory */
+				if (snd_brk == (char*)(MORECORE_FAILURE)) {
+					snd_brk = (char*)(MORECORE(0));
+					av->sbrked_mem += snd_brk - brk - size;
+				}
+			}
+
+			/* Adjust top based on results of second sbrk */
+			if (snd_brk != (char*)(MORECORE_FAILURE)) {
+				av->top = (mchunkptr)aligned_brk;
+				set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
+				av->sbrked_mem += correction;
+
+				/*
+				  If not the first time through, we either have a
+				  gap due to foreign sbrk or a non-contiguous region.  Insert a
+				  double fencepost at old_top to prevent consolidation with space
+				  we don't own. These fenceposts are artificial chunks that are
+				  marked as inuse and are in any case too small to use.  We need
+				  two to make sizes and alignments work out.
+				*/
+
+				if (old_size != 0) {
+					/* Shrink old_top to insert fenceposts, keeping size a
+					   multiple of MALLOC_ALIGNMENT. We know there is at least
+					   enough space in old_top to do this.
+					*/
+					old_size = (old_size - 3*(sizeof(size_t))) & ~MALLOC_ALIGN_MASK;
+					set_head(old_top, old_size | PREV_INUSE);
+
+					/*
+					  Note that the following assignments completely overwrite
+					  old_top when old_size was previously MINSIZE.  This is
+					  intentional. We need the fencepost, even if old_top otherwise gets
+					  lost.
+					*/
+					chunk_at_offset(old_top, old_size          )->size =
+						(sizeof(size_t))|PREV_INUSE;
+
+					chunk_at_offset(old_top, old_size + (sizeof(size_t)))->size =
+						(sizeof(size_t))|PREV_INUSE;
+
+					/* If possible, release the rest, suppressing trimming.  */
+					if (old_size >= MINSIZE) {
+						size_t tt = av->trim_threshold;
+						av->trim_threshold = (size_t)(-1);
+						free(chunk2mem(old_top));
+						av->trim_threshold = tt;
+					}
+				}
+			}
+		}
+
+		/* Update statistics */
+		sum = av->sbrked_mem;
+		if (sum > (unsigned long)(av->max_sbrked_mem))
+			av->max_sbrked_mem = sum;
+
+		sum += av->mmapped_mem;
+		if (sum > (unsigned long)(av->max_total_mem))
+			av->max_total_mem = sum;
+
+		check_malloc_state();
+
+		/* finally, do the allocation */
+
+		p = av->top;
+		size = chunksize(p);
+
+		/* check that one of the above allocation paths succeeded */
+		if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
+			remainder_size = size - nb;
+			remainder = chunk_at_offset(p, nb);
+			av->top = remainder;
+			set_head(p, nb | PREV_INUSE);
+			set_head(remainder, remainder_size | PREV_INUSE);
+			check_malloced_chunk(p, nb);
+			return chunk2mem(p);
+		}
 
     }
 
@@ -767,25 +764,25 @@ static int __malloc_largebin_index(unsig
 #if defined(__GNUC__) && defined(i386)
 
     __asm__("bsrl %1,%0\n\t"
-	    : "=r" (m)
-	    : "g"  (x));
+			: "=r" (m)
+			: "g"  (x));
 
 #else
     {
-	/*
-	   Based on branch-free nlz algorithm in chapter 5 of Henry
-	   S. Warren Jr's book "Hacker's Delight".
-	   */
-
-	unsigned int n = ((x - 0x100) >> 16) & 8;
-	x <<= n;
-	m = ((x - 0x1000) >> 16) & 4;
-	n += m;
-	x <<= m;
-	m = ((x - 0x4000) >> 16) & 2;
-	n += m;
-	x = (x << m) >> 14;
-	m = 13 - n + (x & ~(x>>1));
+		/*
+		  Based on branch-free nlz algorithm in chapter 5 of Henry
+		  S. Warren Jr's book "Hacker's Delight".
+		*/
+
+		unsigned int n = ((x - 0x100) >> 16) & 8;
+		x <<= n;
+		m = ((x - 0x1000) >> 16) & 4;
+		n += m;
+		x <<= m;
+		m = ((x - 0x4000) >> 16) & 2;
+		n += m;
+		x = (x << m) >> 14;
+		m = 13 - n + (x & ~(x>>1));
     }
 #endif
 
@@ -826,69 +823,70 @@ void* malloc(size_t bytes)
     mchunkptr       fwd;              /* misc temp for linking */
     mchunkptr       bck;              /* misc temp for linking */
     void *          sysmem;
+	void *          retval;
 
 #if !defined(__MALLOC_GLIBC_COMPAT__)
     if (!bytes) return NULL;
 #endif
 
-    LOCK;
+    __MALLOC_LOCK;
     av = get_malloc_state();
     /*
-       Convert request size to internal form by adding (sizeof(size_t)) bytes
-       overhead plus possibly more to obtain necessary alignment and/or
-       to obtain a size of at least MINSIZE, the smallest allocatable
-       size. Also, checked_request2size traps (returning 0) request sizes
-       that are so large that they wrap around zero when padded and
-       aligned.
-       */
+	  Convert request size to internal form by adding (sizeof(size_t)) bytes
+	  overhead plus possibly more to obtain necessary alignment and/or
+	  to obtain a size of at least MINSIZE, the smallest allocatable
+	  size. Also, checked_request2size traps (returning 0) request sizes
+	  that are so large that they wrap around zero when padded and
+	  aligned.
+	*/
 
     checked_request2size(bytes, nb);
 
     /*
-       Bypass search if no frees yet
-       */
+	  Bypass search if no frees yet
+	*/
     if (!have_anychunks(av)) {
-	if (av->max_fast == 0) /* initialization check */
-	    __malloc_consolidate(av);
-	goto use_top;
+		if (av->max_fast == 0) /* initialization check */
+			__malloc_consolidate(av);
+		goto use_top;
     }
 
     /*
-       If the size qualifies as a fastbin, first check corresponding bin.
-       */
+	  If the size qualifies as a fastbin, first check corresponding bin.
+	*/
 
     if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
-	fb = &(av->fastbins[(fastbin_index(nb))]);
-	if ( (victim = *fb) != 0) {
-	    *fb = victim->fd;
-	    check_remalloced_chunk(victim, nb);
-	    UNLOCK;
-	    return chunk2mem(victim);
-	}
+		fb = &(av->fastbins[(fastbin_index(nb))]);
+		if ( (victim = *fb) != 0) {
+			*fb = victim->fd;
+			check_remalloced_chunk(victim, nb);
+			retval = chunk2mem(victim);
+			goto DONE;
+		}
     }
 
     /*
-       If a small request, check regular bin.  Since these "smallbins"
-       hold one size each, no searching within bins is necessary.
-       (For a large request, we need to wait until unsorted chunks are
-       processed to find best fit. But for small ones, fits are exact
-       anyway, so we can check now, which is faster.)
-       */
+	  If a small request, check regular bin.  Since these "smallbins"
+	  hold one size each, no searching within bins is necessary.
+	  (For a large request, we need to wait until unsorted chunks are
+	  processed to find best fit. But for small ones, fits are exact
+	  anyway, so we can check now, which is faster.)
+	*/
 
     if (in_smallbin_range(nb)) {
-	idx = smallbin_index(nb);
-	bin = bin_at(av,idx);
+		idx = smallbin_index(nb);
+		bin = bin_at(av,idx);
 
-	if ( (victim = last(bin)) != bin) {
-	    bck = victim->bk;
-	    set_inuse_bit_at_offset(victim, nb);
-	    bin->bk = bck;
-	    bck->fd = bin;
-
-	    check_malloced_chunk(victim, nb);
-	    UNLOCK;
-	    return chunk2mem(victim);
-	}
+		if ( (victim = last(bin)) != bin) {
+			bck = victim->bk;
+			set_inuse_bit_at_offset(victim, nb);
+			bin->bk = bck;
+			bck->fd = bin;
+
+			check_malloced_chunk(victim, nb);
+			retval = chunk2mem(victim);
+			goto DONE;
+		}
     }
 
     /* If this is a large request, consolidate fastbins before continuing.
@@ -899,154 +897,154 @@ void* malloc(size_t bytes)
        large requests, but less often mixtures, so consolidation is not
        invoked all that often in most programs. And the programs that
        it is called frequently in otherwise tend to fragment.
-       */
+	*/
 
     else {
-	idx = __malloc_largebin_index(nb);
-	if (have_fastchunks(av)) 
-	    __malloc_consolidate(av);
+		idx = __malloc_largebin_index(nb);
+		if (have_fastchunks(av)) 
+			__malloc_consolidate(av);
     }
 
     /*
-       Process recently freed or remaindered chunks, taking one only if
-       it is exact fit, or, if this a small request, the chunk is remainder from
-       the most recent non-exact fit.  Place other traversed chunks in
-       bins.  Note that this step is the only place in any routine where
-       chunks are placed in bins.
-       */
+	  Process recently freed or remaindered chunks, taking one only if
+	  it is exact fit, or, if this a small request, the chunk is remainder from
+	  the most recent non-exact fit.  Place other traversed chunks in
+	  bins.  Note that this step is the only place in any routine where
+	  chunks are placed in bins.
+	*/
 
     while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
-	bck = victim->bk;
-	size = chunksize(victim);
+		bck = victim->bk;
+		size = chunksize(victim);
+
+		/* If a small request, try to use last remainder if it is the
+		   only chunk in unsorted bin.  This helps promote locality for
+		   runs of consecutive small requests. This is the only
+		   exception to best-fit, and applies only when there is
+		   no exact fit for a small chunk.
+		*/
+
+		if (in_smallbin_range(nb) &&
+			bck == unsorted_chunks(av) &&
+			victim == av->last_remainder &&
+			(unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
+
+			/* split and reattach remainder */
+			remainder_size = size - nb;
+			remainder = chunk_at_offset(victim, nb);
+			unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
+			av->last_remainder = remainder;
+			remainder->bk = remainder->fd = unsorted_chunks(av);
+
+			set_head(victim, nb | PREV_INUSE);
+			set_head(remainder, remainder_size | PREV_INUSE);
+			set_foot(remainder, remainder_size);
+
+			check_malloced_chunk(victim, nb);
+			retval = chunk2mem(victim);
+			goto DONE;
+		}
+
+		/* remove from unsorted list */
+		unsorted_chunks(av)->bk = bck;
+		bck->fd = unsorted_chunks(av);
+
+		/* Take now instead of binning if exact fit */
+
+		if (size == nb) {
+			set_inuse_bit_at_offset(victim, size);
+			check_malloced_chunk(victim, nb);
+			retval = chunk2mem(victim);
+			goto DONE;
+		}
+
+		/* place chunk in bin */
 
-	/* If a small request, try to use last remainder if it is the
-	   only chunk in unsorted bin.  This helps promote locality for
-	   runs of consecutive small requests. This is the only
-	   exception to best-fit, and applies only when there is
-	   no exact fit for a small chunk.
-	   */
-
-	if (in_smallbin_range(nb) &&
-		bck == unsorted_chunks(av) &&
-		victim == av->last_remainder &&
-		(unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-
-	    /* split and reattach remainder */
-	    remainder_size = size - nb;
-	    remainder = chunk_at_offset(victim, nb);
-	    unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-	    av->last_remainder = remainder;
-	    remainder->bk = remainder->fd = unsorted_chunks(av);
-
-	    set_head(victim, nb | PREV_INUSE);
-	    set_head(remainder, remainder_size | PREV_INUSE);
-	    set_foot(remainder, remainder_size);
-
-	    check_malloced_chunk(victim, nb);
-	    UNLOCK;
-	    return chunk2mem(victim);
-	}
-
-	/* remove from unsorted list */
-	unsorted_chunks(av)->bk = bck;
-	bck->fd = unsorted_chunks(av);
-
-	/* Take now instead of binning if exact fit */
-
-	if (size == nb) {
-	    set_inuse_bit_at_offset(victim, size);
-	    check_malloced_chunk(victim, nb);
-	    UNLOCK;
-	    return chunk2mem(victim);
-	}
-
-	/* place chunk in bin */
-
-	if (in_smallbin_range(size)) {
-	    victim_index = smallbin_index(size);
-	    bck = bin_at(av, victim_index);
-	    fwd = bck->fd;
-	}
-	else {
-	    victim_index = __malloc_largebin_index(size);
-	    bck = bin_at(av, victim_index);
-	    fwd = bck->fd;
-
-	    if (fwd != bck) {
-		/* if smaller than smallest, place first */
-		if ((unsigned long)(size) < (unsigned long)(bck->bk->size)) {
-		    fwd = bck;
-		    bck = bck->bk;
-		}
-		else if ((unsigned long)(size) >=
-			(unsigned long)(FIRST_SORTED_BIN_SIZE)) {
-
-		    /* maintain large bins in sorted order */
-		    size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
-		    while ((unsigned long)(size) < (unsigned long)(fwd->size))
-			fwd = fwd->fd;
-		    bck = fwd->bk;
-		}
-	    }
-	}
-
-	mark_bin(av, victim_index);
-	victim->bk = bck;
-	victim->fd = fwd;
-	fwd->bk = victim;
-	bck->fd = victim;
+		if (in_smallbin_range(size)) {
+			victim_index = smallbin_index(size);
+			bck = bin_at(av, victim_index);
+			fwd = bck->fd;
+		}
+		else {
+			victim_index = __malloc_largebin_index(size);
+			bck = bin_at(av, victim_index);
+			fwd = bck->fd;
+
+			if (fwd != bck) {
+				/* if smaller than smallest, place first */
+				if ((unsigned long)(size) < (unsigned long)(bck->bk->size)) {
+					fwd = bck;
+					bck = bck->bk;
+				}
+				else if ((unsigned long)(size) >=
+						 (unsigned long)(FIRST_SORTED_BIN_SIZE)) {
+
+					/* maintain large bins in sorted order */
+					size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
+					while ((unsigned long)(size) < (unsigned long)(fwd->size))
+						fwd = fwd->fd;
+					bck = fwd->bk;
+				}
+			}
+		}
+
+		mark_bin(av, victim_index);
+		victim->bk = bck;
+		victim->fd = fwd;
+		fwd->bk = victim;
+		bck->fd = victim;
     }
 
     /*
-       If a large request, scan through the chunks of current bin to
-       find one that fits.  (This will be the smallest that fits unless
-       FIRST_SORTED_BIN_SIZE has been changed from default.)  This is
-       the only step where an unbounded number of chunks might be
-       scanned without doing anything useful with them. However the
-       lists tend to be short.
-       */
+	  If a large request, scan through the chunks of current bin to
+	  find one that fits.  (This will be the smallest that fits unless
+	  FIRST_SORTED_BIN_SIZE has been changed from default.)  This is
+	  the only step where an unbounded number of chunks might be
+	  scanned without doing anything useful with them. However the
+	  lists tend to be short.
+	*/
 
     if (!in_smallbin_range(nb)) {
-	bin = bin_at(av, idx);
-
-	for (victim = last(bin); victim != bin; victim = victim->bk) {
-	    size = chunksize(victim);
+		bin = bin_at(av, idx);
 
-	    if ((unsigned long)(size) >= (unsigned long)(nb)) {
-		remainder_size = size - nb;
-		unlink(victim, bck, fwd);
+		for (victim = last(bin); victim != bin; victim = victim->bk) {
+			size = chunksize(victim);
 
-		/* Exhaust */
-		if (remainder_size < MINSIZE)  {
-		    set_inuse_bit_at_offset(victim, size);
-		    check_malloced_chunk(victim, nb);
-		    UNLOCK;
-		    return chunk2mem(victim);
-		}
-		/* Split */
-		else {
-		    remainder = chunk_at_offset(victim, nb);
-		    unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-		    remainder->bk = remainder->fd = unsorted_chunks(av);
-		    set_head(victim, nb | PREV_INUSE);
-		    set_head(remainder, remainder_size | PREV_INUSE);
-		    set_foot(remainder, remainder_size);
-		    check_malloced_chunk(victim, nb);
-		    UNLOCK;
-		    return chunk2mem(victim);
+			if ((unsigned long)(size) >= (unsigned long)(nb)) {
+				remainder_size = size - nb;
+				unlink(victim, bck, fwd);
+
+				/* Exhaust */
+				if (remainder_size < MINSIZE)  {
+					set_inuse_bit_at_offset(victim, size);
+					check_malloced_chunk(victim, nb);
+					retval = chunk2mem(victim);
+					goto DONE;
+				}
+				/* Split */
+				else {
+					remainder = chunk_at_offset(victim, nb);
+					unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
+					remainder->bk = remainder->fd = unsorted_chunks(av);
+					set_head(victim, nb | PREV_INUSE);
+					set_head(remainder, remainder_size | PREV_INUSE);
+					set_foot(remainder, remainder_size);
+					check_malloced_chunk(victim, nb);
+					retval = chunk2mem(victim);
+					goto DONE;
+				}
+			}
 		}
-	    }
-	}
     }
 
     /*
-       Search for a chunk by scanning bins, starting with next largest
-       bin. This search is strictly by best-fit; i.e., the smallest
-       (with ties going to approximately the least recently used) chunk
-       that fits is selected.
+	  Search for a chunk by scanning bins, starting with next largest
+	  bin. This search is strictly by best-fit; i.e., the smallest
+	  (with ties going to approximately the least recently used) chunk
+	  that fits is selected.
 
-       The bitmap avoids needing to check that most blocks are nonempty.
-       */
+	  The bitmap avoids needing to check that most blocks are nonempty.
+	*/
 
     ++idx;
     bin = bin_at(av,idx);
@@ -1056,109 +1054,111 @@ void* malloc(size_t bytes)
 
     for (;;) {
 
-	/* Skip rest of block if there are no more set bits in this block.  */
-	if (bit > map || bit == 0) {
-	    do {
-		if (++block >= BINMAPSIZE)  /* out of bins */
-		    goto use_top;
-	    } while ( (map = av->binmap[block]) == 0);
-
-	    bin = bin_at(av, (block << BINMAPSHIFT));
-	    bit = 1;
-	}
-
-	/* Advance to bin with set bit. There must be one. */
-	while ((bit & map) == 0) {
-	    bin = next_bin(bin);
-	    bit <<= 1;
-	    assert(bit != 0);
-	}
-
-	/* Inspect the bin. It is likely to be non-empty */
-	victim = last(bin);
-
-	/*  If a false alarm (empty bin), clear the bit. */
-	if (victim == bin) {
-	    av->binmap[block] = map &= ~bit; /* Write through */
-	    bin = next_bin(bin);
-	    bit <<= 1;
-	}
-
-	else {
-	    size = chunksize(victim);
-
-	    /*  We know the first chunk in this bin is big enough to use. */
-	    assert((unsigned long)(size) >= (unsigned long)(nb));
-
-	    remainder_size = size - nb;
-
-	    /* unlink */
-	    bck = victim->bk;
-	    bin->bk = bck;
-	    bck->fd = bin;
-
-	    /* Exhaust */
-	    if (remainder_size < MINSIZE) {
-		set_inuse_bit_at_offset(victim, size);
-		check_malloced_chunk(victim, nb);
-		UNLOCK;
-		return chunk2mem(victim);
-	    }
+		/* Skip rest of block if there are no more set bits in this block.  */
+		if (bit > map || bit == 0) {
+			do {
+				if (++block >= BINMAPSIZE)  /* out of bins */
+					goto use_top;
+			} while ( (map = av->binmap[block]) == 0);
 
-	    /* Split */
-	    else {
-		remainder = chunk_at_offset(victim, nb);
+			bin = bin_at(av, (block << BINMAPSHIFT));
+			bit = 1;
+		}
 
-		unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-		remainder->bk = remainder->fd = unsorted_chunks(av);
-		/* advertise as last remainder */
-		if (in_smallbin_range(nb))
-		    av->last_remainder = remainder;
+		/* Advance to bin with set bit. There must be one. */
+		while ((bit & map) == 0) {
+			bin = next_bin(bin);
+			bit <<= 1;
+			assert(bit != 0);
+		}
 
-		set_head(victim, nb | PREV_INUSE);
-		set_head(remainder, remainder_size | PREV_INUSE);
-		set_foot(remainder, remainder_size);
-		check_malloced_chunk(victim, nb);
-		UNLOCK;
-		return chunk2mem(victim);
-	    }
-	}
+		/* Inspect the bin. It is likely to be non-empty */
+		victim = last(bin);
+
+		/*  If a false alarm (empty bin), clear the bit. */
+		if (victim == bin) {
+			av->binmap[block] = map &= ~bit; /* Write through */
+			bin = next_bin(bin);
+			bit <<= 1;
+		}
+
+		else {
+			size = chunksize(victim);
+
+			/*  We know the first chunk in this bin is big enough to use. */
+			assert((unsigned long)(size) >= (unsigned long)(nb));
+
+			remainder_size = size - nb;
+
+			/* unlink */
+			bck = victim->bk;
+			bin->bk = bck;
+			bck->fd = bin;
+
+			/* Exhaust */
+			if (remainder_size < MINSIZE) {
+				set_inuse_bit_at_offset(victim, size);
+				check_malloced_chunk(victim, nb);
+				retval = chunk2mem(victim);
+				goto DONE;
+			}
+
+			/* Split */
+			else {
+				remainder = chunk_at_offset(victim, nb);
+
+				unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
+				remainder->bk = remainder->fd = unsorted_chunks(av);
+				/* advertise as last remainder */
+				if (in_smallbin_range(nb))
+					av->last_remainder = remainder;
+
+				set_head(victim, nb | PREV_INUSE);
+				set_head(remainder, remainder_size | PREV_INUSE);
+				set_foot(remainder, remainder_size);
+				check_malloced_chunk(victim, nb);
+				retval = chunk2mem(victim);
+				goto DONE;
+			}
+		}
     }
 
-use_top:
+ use_top:
     /*
-       If large enough, split off the chunk bordering the end of memory
-       (held in av->top). Note that this is in accord with the best-fit
-       search rule.  In effect, av->top is treated as larger (and thus
-       less well fitting) than any other available chunk since it can
-       be extended to be as large as necessary (up to system
-       limitations).
-
-       We require that av->top always exists (i.e., has size >=
-       MINSIZE) after initialization, so if it would otherwise be
-       exhuasted by current request, it is replenished. (The main
-       reason for ensuring it exists is that we may need MINSIZE space
-       to put in fenceposts in sysmalloc.)
-       */
+	  If large enough, split off the chunk bordering the end of memory
+	  (held in av->top). Note that this is in accord with the best-fit
+	  search rule.  In effect, av->top is treated as larger (and thus
+	  less well fitting) than any other available chunk since it can
+	  be extended to be as large as necessary (up to system
+	  limitations).
+
+	  We require that av->top always exists (i.e., has size >=
+	  MINSIZE) after initialization, so if it would otherwise be
+	  exhuasted by current request, it is replenished. (The main
+	  reason for ensuring it exists is that we may need MINSIZE space
+	  to put in fenceposts in sysmalloc.)
+	*/
 
     victim = av->top;
     size = chunksize(victim);
 
     if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-	remainder_size = size - nb;
-	remainder = chunk_at_offset(victim, nb);
-	av->top = remainder;
-	set_head(victim, nb | PREV_INUSE);
-	set_head(remainder, remainder_size | PREV_INUSE);
-
-	check_malloced_chunk(victim, nb);
-	UNLOCK;
-	return chunk2mem(victim);
+		remainder_size = size - nb;
+		remainder = chunk_at_offset(victim, nb);
+		av->top = remainder;
+		set_head(victim, nb | PREV_INUSE);
+		set_head(remainder, remainder_size | PREV_INUSE);
+
+		check_malloced_chunk(victim, nb);
+		retval = chunk2mem(victim);
+		goto DONE;
     }
 
     /* If no space in top, relay to handle system-dependent cases */
     sysmem = __malloc_alloc(nb, av);
-    UNLOCK;
-    return sysmem;
+    retval = sysmem;
+ DONE:
+	__MALLOC_UNLOCK;
+	return retval;
 }
 
diff --git a/libc/stdlib/malloc-standard/malloc.h b/libc/stdlib/malloc-standard/malloc.h
index fbc1492..14a0dd9 100644
--- a/libc/stdlib/malloc-standard/malloc.h
+++ b/libc/stdlib/malloc-standard/malloc.h
@@ -22,16 +22,12 @@
 #include <malloc.h>
 #include <stdlib.h>
 
+#include <bits/uClibc_mutex.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-extern pthread_mutex_t __malloc_lock;
-# define LOCK	__pthread_mutex_lock(&__malloc_lock)
-# define UNLOCK	__pthread_mutex_unlock(&__malloc_lock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+__UCLIBC_MUTEX_EXTERN(__malloc_lock);
+
+#define __MALLOC_LOCK		__UCLIBC_MUTEX_LOCK(__malloc_lock)
+#define __MALLOC_UNLOCK		__UCLIBC_MUTEX_UNLOCK(__malloc_lock)
 
 
 
diff --git a/libc/stdlib/malloc-standard/mallopt.c b/libc/stdlib/malloc-standard/mallopt.c
index e287920..41aa614 100644
--- a/libc/stdlib/malloc-standard/mallopt.c
+++ b/libc/stdlib/malloc-standard/mallopt.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -25,40 +25,40 @@ int mallopt(int param_number, int value)
 
     ret = 0;
 
-    LOCK;
+    __MALLOC_LOCK;
     av = get_malloc_state();
     /* Ensure initialization/consolidation */
     __malloc_consolidate(av);
 
     switch(param_number) {
-	case M_MXFAST:
-	    if (value >= 0 && value <= MAX_FAST_SIZE) {
-		set_max_fast(av, value);
-		ret = 1;
-	    }
-	    break;
-
-	case M_TRIM_THRESHOLD:
-	    av->trim_threshold = value;
-	    ret = 1;
-	    break;
-
-	case M_TOP_PAD:
-	    av->top_pad = value;
-	    ret = 1;
-	    break;
-
-	case M_MMAP_THRESHOLD:
-	    av->mmap_threshold = value;
-	    ret = 1;
-	    break;
-
-	case M_MMAP_MAX:
-	    av->n_mmaps_max = value;
-	    ret = 1;
-	    break;
+		case M_MXFAST:
+			if (value >= 0 && value <= MAX_FAST_SIZE) {
+				set_max_fast(av, value);
+				ret = 1;
+			}
+			break;
+
+		case M_TRIM_THRESHOLD:
+			av->trim_threshold = value;
+			ret = 1;
+			break;
+
+		case M_TOP_PAD:
+			av->top_pad = value;
+			ret = 1;
+			break;
+
+		case M_MMAP_THRESHOLD:
+			av->mmap_threshold = value;
+			ret = 1;
+			break;
+
+		case M_MMAP_MAX:
+			av->n_mmaps_max = value;
+			ret = 1;
+			break;
     }
-    UNLOCK;
+    __MALLOC_UNLOCK;
     return ret;
 }
 
diff --git a/libc/stdlib/malloc-standard/memalign.c b/libc/stdlib/malloc-standard/memalign.c
index bd95362..e78d752 100644
--- a/libc/stdlib/malloc-standard/memalign.c
+++ b/libc/stdlib/malloc-standard/memalign.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -35,6 +35,7 @@ void* memalign(size_t alignment, size_t 
     mchunkptr       remainder;      /* spare room at end to split off */
     unsigned long    remainder_size; /* its size */
     size_t size;
+	void *retval;
 
     /* If need less alignment than we give anyway, just relay to malloc */
 
@@ -46,12 +47,12 @@ void* memalign(size_t alignment, size_t 
 
     /* Make sure alignment is power of 2 (in case MINSIZE is not).  */
     if ((alignment & (alignment - 1)) != 0) {
-	size_t a = MALLOC_ALIGNMENT * 2;
-	while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
-	alignment = a;
+		size_t a = MALLOC_ALIGNMENT * 2;
+		while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
+		alignment = a;
     }
 
-    LOCK;
+    __MALLOC_LOCK;
     checked_request2size(bytes, nb);
 
     /* Strategy: find a spot within that chunk that meets the alignment
@@ -63,64 +64,67 @@ void* memalign(size_t alignment, size_t 
     m  = (char*)(malloc(nb + alignment + MINSIZE));
 
     if (m == 0) {
-	UNLOCK;
-	return 0; /* propagate failure */
+		retval = 0; /* propagate failure */
+		goto DONE;
     }
 
     p = mem2chunk(m);
 
     if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
 
-	/*
-	   Find an aligned spot inside chunk.  Since we need to give back
-	   leading space in a chunk of at least MINSIZE, if the first
-	   calculation places us at a spot with less than MINSIZE leader,
-	   we can move to the next aligned spot -- we've allocated enough
-	   total room so that this is always possible.
-	   */
-
-	brk = (char*)mem2chunk((unsigned long)(((unsigned long)(m + alignment - 1)) &
-		    -((signed long) alignment)));
-	if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
-	    brk += alignment;
-
-	newp = (mchunkptr)brk;
-	leadsize = brk - (char*)(p);
-	newsize = chunksize(p) - leadsize;
-
-	/* For mmapped chunks, just adjust offset */
-	if (chunk_is_mmapped(p)) {
-	    newp->prev_size = p->prev_size + leadsize;
-	    set_head(newp, newsize|IS_MMAPPED);
-	    UNLOCK;
-	    return chunk2mem(newp);
-	}
-
-	/* Otherwise, give back leader, use the rest */
-	set_head(newp, newsize | PREV_INUSE);
-	set_inuse_bit_at_offset(newp, newsize);
-	set_head_size(p, leadsize);
-	free(chunk2mem(p));
-	p = newp;
+		/*
+		  Find an aligned spot inside chunk.  Since we need to give back
+		  leading space in a chunk of at least MINSIZE, if the first
+		  calculation places us at a spot with less than MINSIZE leader,
+		  we can move to the next aligned spot -- we've allocated enough
+		  total room so that this is always possible.
+		*/
+
+		brk = (char*)mem2chunk((unsigned long)(((unsigned long)(m + alignment - 1)) &
+											   -((signed long) alignment)));
+		if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
+			brk += alignment;
+
+		newp = (mchunkptr)brk;
+		leadsize = brk - (char*)(p);
+		newsize = chunksize(p) - leadsize;
+
+		/* For mmapped chunks, just adjust offset */
+		if (chunk_is_mmapped(p)) {
+			newp->prev_size = p->prev_size + leadsize;
+			set_head(newp, newsize|IS_MMAPPED);
+			retval = chunk2mem(newp);
+			goto DONE;
+		}
+
+		/* Otherwise, give back leader, use the rest */
+		set_head(newp, newsize | PREV_INUSE);
+		set_inuse_bit_at_offset(newp, newsize);
+		set_head_size(p, leadsize);
+		free(chunk2mem(p));
+		p = newp;
 
-	assert (newsize >= nb &&
-		(((unsigned long)(chunk2mem(p))) % alignment) == 0);
+		assert (newsize >= nb &&
+				(((unsigned long)(chunk2mem(p))) % alignment) == 0);
     }
 
     /* Also give back spare room at the end */
     if (!chunk_is_mmapped(p)) {
-	size = chunksize(p);
-	if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-	    remainder_size = size - nb;
-	    remainder = chunk_at_offset(p, nb);
-	    set_head(remainder, remainder_size | PREV_INUSE);
-	    set_head_size(p, nb);
-	    free(chunk2mem(remainder));
-	}
+		size = chunksize(p);
+		if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
+			remainder_size = size - nb;
+			remainder = chunk_at_offset(p, nb);
+			set_head(remainder, remainder_size | PREV_INUSE);
+			set_head_size(p, nb);
+			free(chunk2mem(remainder));
+		}
     }
 
     check_inuse_chunk(p);
-    UNLOCK;
-    return chunk2mem(p);
+    retval = chunk2mem(p);
+
+ DONE:
+    __MALLOC_UNLOCK;
+	return retval;
 }
 
diff --git a/libc/stdlib/malloc-standard/realloc.c b/libc/stdlib/malloc-standard/realloc.c
index 1950130..9ca4b26 100644
--- a/libc/stdlib/malloc-standard/realloc.c
+++ b/libc/stdlib/malloc-standard/realloc.c
@@ -8,7 +8,7 @@
   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
 
   Note: There may be an updated version of this malloc obtainable at
-           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+  ftp://gee.cs.oswego.edu/pub/misc/malloc.c
   Check before installing!
 
   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
@@ -23,14 +23,14 @@ void* realloc(void* oldmem, size_t bytes
 {
     mstate av;
 
-    size_t  nb;              /* padded request size */
+    size_t  nb;                       /* padded request size */
 
     mchunkptr        oldp;            /* chunk corresponding to oldmem */
-    size_t  oldsize;         /* its size */
+    size_t  oldsize;                  /* its size */
 
     mchunkptr        newp;            /* chunk to return */
-    size_t  newsize;         /* its size */
-    void*          newmem;          /* corresponding user mem */
+    size_t  newsize;                  /* its size */
+    void*          newmem;            /* corresponding user mem */
 
     mchunkptr        next;            /* next contiguous chunk after oldp */
 
@@ -40,21 +40,23 @@ void* realloc(void* oldmem, size_t bytes
     mchunkptr        bck;             /* misc temp for linking */
     mchunkptr        fwd;             /* misc temp for linking */
 
-    unsigned long     copysize;        /* bytes to copy */
+    unsigned long     copysize;       /* bytes to copy */
     unsigned int     ncopies;         /* size_t words to copy */
-    size_t* s;               /* copy source */
-    size_t* d;               /* copy destination */
+    size_t* s;                        /* copy source */
+    size_t* d;                        /* copy destination */
+
+	void *retval;
 
 
     /* Check for special cases.  */
     if (! oldmem)
-	return malloc(bytes);
+		return malloc(bytes);
     if (! bytes) {
-	free (oldmem);
-	return malloc(bytes);
+		free (oldmem);
+		return malloc(bytes);
     }
 
-    LOCK;
+    __MALLOC_LOCK;
     av = get_malloc_state();
     checked_request2size(bytes, nb);
 
@@ -65,173 +67,176 @@ void* realloc(void* oldmem, size_t bytes
 
     if (!chunk_is_mmapped(oldp)) {
 
-	if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
-	    /* already big enough; split below */
-	    newp = oldp;
-	    newsize = oldsize;
-	}
-
-	else {
-	    next = chunk_at_offset(oldp, oldsize);
-
-	    /* Try to expand forward into top */
-	    if (next == av->top &&
-		    (unsigned long)(newsize = oldsize + chunksize(next)) >=
-		    (unsigned long)(nb + MINSIZE)) {
-		set_head_size(oldp, nb);
-		av->top = chunk_at_offset(oldp, nb);
-		set_head(av->top, (newsize - nb) | PREV_INUSE);
-		UNLOCK;
-		return chunk2mem(oldp);
-	    }
-
-	    /* Try to expand forward into next chunk;  split off remainder below */
-	    else if (next != av->top &&
-		    !inuse(next) &&
-		    (unsigned long)(newsize = oldsize + chunksize(next)) >=
-		    (unsigned long)(nb)) {
-		newp = oldp;
-		unlink(next, bck, fwd);
-	    }
-
-	    /* allocate, copy, free */
-	    else {
-		newmem = malloc(nb - MALLOC_ALIGN_MASK);
-		if (newmem == 0) {
-		    UNLOCK;
-		    return 0; /* propagate failure */
-		}
-
-		newp = mem2chunk(newmem);
-		newsize = chunksize(newp);
-
-		/*
-		   Avoid copy if newp is next chunk after oldp.
-		   */
-		if (newp == next) {
-		    newsize += oldsize;
-		    newp = oldp;
+		if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
+			/* already big enough; split below */
+			newp = oldp;
+			newsize = oldsize;
 		}
+
 		else {
-		    /*
-		       Unroll copy of <= 36 bytes (72 if 8byte sizes)
-		       We know that contents have an odd number of
-		       size_t-sized words; minimally 3.
-		       */
-
-		    copysize = oldsize - (sizeof(size_t));
-		    s = (size_t*)(oldmem);
-		    d = (size_t*)(newmem);
-		    ncopies = copysize / sizeof(size_t);
-		    assert(ncopies >= 3);
-
-		    if (ncopies > 9)
-			memcpy(d, s, copysize);
-
-		    else {
-			*(d+0) = *(s+0);
-			*(d+1) = *(s+1);
-			*(d+2) = *(s+2);
-			if (ncopies > 4) {
-			    *(d+3) = *(s+3);
-			    *(d+4) = *(s+4);
-			    if (ncopies > 6) {
-				*(d+5) = *(s+5);
-				*(d+6) = *(s+6);
-				if (ncopies > 8) {
-				    *(d+7) = *(s+7);
-				    *(d+8) = *(s+8);
+			next = chunk_at_offset(oldp, oldsize);
+
+			/* Try to expand forward into top */
+			if (next == av->top &&
+				(unsigned long)(newsize = oldsize + chunksize(next)) >=
+				(unsigned long)(nb + MINSIZE)) {
+				set_head_size(oldp, nb);
+				av->top = chunk_at_offset(oldp, nb);
+				set_head(av->top, (newsize - nb) | PREV_INUSE);
+				retval = chunk2mem(oldp);
+				goto DONE;
+			}
+
+			/* Try to expand forward into next chunk;  split off remainder below */
+			else if (next != av->top &&
+					 !inuse(next) &&
+					 (unsigned long)(newsize = oldsize + chunksize(next)) >=
+					 (unsigned long)(nb)) {
+				newp = oldp;
+				unlink(next, bck, fwd);
+			}
+
+			/* allocate, copy, free */
+			else {
+				newmem = malloc(nb - MALLOC_ALIGN_MASK);
+				if (newmem == 0) {
+					retval = 0; /* propagate failure */
+					goto DONE;
+				}
+
+				newp = mem2chunk(newmem);
+				newsize = chunksize(newp);
+
+				/*
+				  Avoid copy if newp is next chunk after oldp.
+				*/
+				if (newp == next) {
+					newsize += oldsize;
+					newp = oldp;
+				}
+				else {
+					/*
+					  Unroll copy of <= 36 bytes (72 if 8byte sizes)
+					  We know that contents have an odd number of
+					  size_t-sized words; minimally 3.
+					*/
+
+					copysize = oldsize - (sizeof(size_t));
+					s = (size_t*)(oldmem);
+					d = (size_t*)(newmem);
+					ncopies = copysize / sizeof(size_t);
+					assert(ncopies >= 3);
+
+					if (ncopies > 9)
+						memcpy(d, s, copysize);
+
+					else {
+						*(d+0) = *(s+0);
+						*(d+1) = *(s+1);
+						*(d+2) = *(s+2);
+						if (ncopies > 4) {
+							*(d+3) = *(s+3);
+							*(d+4) = *(s+4);
+							if (ncopies > 6) {
+								*(d+5) = *(s+5);
+								*(d+6) = *(s+6);
+								if (ncopies > 8) {
+									*(d+7) = *(s+7);
+									*(d+8) = *(s+8);
+								}
+							}
+						}
+					}
+
+					free(oldmem);
+					check_inuse_chunk(newp);
+					retval = chunk2mem(newp);
+					goto DONE;
 				}
-			    }
 			}
-		    }
+		}
+
+		/* If possible, free extra space in old or extended chunk */
+
+		assert((unsigned long)(newsize) >= (unsigned long)(nb));
+
+		remainder_size = newsize - nb;
 
-		    free(oldmem);
-		    check_inuse_chunk(newp);
-		    UNLOCK;
-		    return chunk2mem(newp);
-		}
-	    }
-	}
-
-	/* If possible, free extra space in old or extended chunk */
-
-	assert((unsigned long)(newsize) >= (unsigned long)(nb));
-
-	remainder_size = newsize - nb;
-
-	if (remainder_size < MINSIZE) { /* not enough extra to split off */
-	    set_head_size(newp, newsize);
-	    set_inuse_bit_at_offset(newp, newsize);
-	}
-	else { /* split remainder */
-	    remainder = chunk_at_offset(newp, nb);
-	    set_head_size(newp, nb);
-	    set_head(remainder, remainder_size | PREV_INUSE);
-	    /* Mark remainder as inuse so free() won't complain */
-	    set_inuse_bit_at_offset(remainder, remainder_size);
-	    free(chunk2mem(remainder));
-	}
-
-	check_inuse_chunk(newp);
-	UNLOCK;
-	return chunk2mem(newp);
+		if (remainder_size < MINSIZE) { /* not enough extra to split off */
+			set_head_size(newp, newsize);
+			set_inuse_bit_at_offset(newp, newsize);
+		}
+		else { /* split remainder */
+			remainder = chunk_at_offset(newp, nb);
+			set_head_size(newp, nb);
+			set_head(remainder, remainder_size | PREV_INUSE);
+			/* Mark remainder as inuse so free() won't complain */
+			set_inuse_bit_at_offset(remainder, remainder_size);
+			free(chunk2mem(remainder));
+		}
+
+		check_inuse_chunk(newp);
+		retval = chunk2mem(newp);
+		goto DONE;
     }
 
     /*
-       Handle mmap cases
-       */
+	  Handle mmap cases
+	*/
 
     else {
-	size_t offset = oldp->prev_size;
-	size_t pagemask = av->pagesize - 1;
-	char *cp;
-	unsigned long  sum;
-
-	/* Note the extra (sizeof(size_t)) overhead */
-	newsize = (nb + offset + (sizeof(size_t)) + pagemask) & ~pagemask;
-
-	/* don't need to remap if still within same page */
-	if (oldsize == newsize - offset) {
-	    UNLOCK;
-	    return oldmem;
-	}
-
-	cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
-
-	if (cp != (char*)MORECORE_FAILURE) {
-
-	    newp = (mchunkptr)(cp + offset);
-	    set_head(newp, (newsize - offset)|IS_MMAPPED);
-
-	    assert(aligned_OK(chunk2mem(newp)));
-	    assert((newp->prev_size == offset));
-
-	    /* update statistics */
-	    sum = av->mmapped_mem += newsize - oldsize;
-	    if (sum > (unsigned long)(av->max_mmapped_mem))
-		av->max_mmapped_mem = sum;
-	    sum += av->sbrked_mem;
-	    if (sum > (unsigned long)(av->max_total_mem))
-		av->max_total_mem = sum;
-
-	    UNLOCK;
-	    return chunk2mem(newp);
-	}
-
-	/* Note the extra (sizeof(size_t)) overhead. */
-	if ((unsigned long)(oldsize) >= (unsigned long)(nb + (sizeof(size_t))))
-	    newmem = oldmem; /* do nothing */
-	else {
-	    /* Must alloc, copy, free. */
-	    newmem = malloc(nb - MALLOC_ALIGN_MASK);
-	    if (newmem != 0) {
-		memcpy(newmem, oldmem, oldsize - 2*(sizeof(size_t)));
-		free(oldmem);
-	    }
-	}
-	UNLOCK;
-	return newmem;
+		size_t offset = oldp->prev_size;
+		size_t pagemask = av->pagesize - 1;
+		char *cp;
+		unsigned long  sum;
+
+		/* Note the extra (sizeof(size_t)) overhead */
+		newsize = (nb + offset + (sizeof(size_t)) + pagemask) & ~pagemask;
+
+		/* don't need to remap if still within same page */
+		if (oldsize == newsize - offset) {
+			retval = oldmem;
+			goto DONE;
+		}
+
+		cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
+
+		if (cp != (char*)MORECORE_FAILURE) {
+
+			newp = (mchunkptr)(cp + offset);
+			set_head(newp, (newsize - offset)|IS_MMAPPED);
+
+			assert(aligned_OK(chunk2mem(newp)));
+			assert((newp->prev_size == offset));
+
+			/* update statistics */
+			sum = av->mmapped_mem += newsize - oldsize;
+			if (sum > (unsigned long)(av->max_mmapped_mem))
+				av->max_mmapped_mem = sum;
+			sum += av->sbrked_mem;
+			if (sum > (unsigned long)(av->max_total_mem))
+				av->max_total_mem = sum;
+
+			retval = chunk2mem(newp);
+			goto DONE;
+		}
+
+		/* Note the extra (sizeof(size_t)) overhead. */
+		if ((unsigned long)(oldsize) >= (unsigned long)(nb + (sizeof(size_t))))
+			newmem = oldmem; /* do nothing */
+		else {
+			/* Must alloc, copy, free. */
+			newmem = malloc(nb - MALLOC_ALIGN_MASK);
+			if (newmem != 0) {
+				memcpy(newmem, oldmem, oldsize - 2*(sizeof(size_t)));
+				free(oldmem);
+			}
+		}
+		retval = newmem;
     }
+
+ DONE:
+	__MALLOC_UNLOCK;
+	return retval;
 }
 
diff --git a/libc/stdlib/random.c b/libc/stdlib/random.c
index b0a00e1..1bd63bc 100644
--- a/libc/stdlib/random.c
+++ b/libc/stdlib/random.c
@@ -27,16 +27,14 @@
 #include <limits.h>
 #include <stddef.h>
 #include <stdlib.h>
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
+
 /* POSIX.1c requires that there is mutual exclusion for the `rand' and
    `srand' functions to prevent concurrent calls from modifying common
    data.  */
-static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-#else
-#define __pthread_mutex_lock(x)
-#define __pthread_mutex_unlock(x)
-#endif
+
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 
 /* An improved random number generation package.  In addition to the standard
    rand()/srand() like interface, this package also has a special state info
@@ -184,9 +182,9 @@ static struct random_data unsafe_state =
    for default usage relies on values produced by this routine.  */
 void srandom (unsigned int x)
 {
-    __pthread_mutex_lock(&lock);
+    __UCLIBC_MUTEX_LOCK(mylock);
     srandom_r (x, &unsafe_state);
-    __pthread_mutex_unlock(&lock);
+    __UCLIBC_MUTEX_UNLOCK(mylock);
 }
 weak_alias (srandom, srand)
 
@@ -205,10 +203,10 @@ char * initstate (unsigned int seed, cha
 {
     int32_t *ostate;
 
-    __pthread_mutex_lock(&lock);
+    __UCLIBC_MUTEX_LOCK(mylock);
     ostate = &unsafe_state.state[-1];
     initstate_r (seed, arg_state, n, &unsafe_state);
-    __pthread_mutex_unlock(&lock);
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return (char *) ostate;
 }
 
@@ -224,11 +222,11 @@ char * setstate (char *arg_state)
 {
     int32_t *ostate;
 
-    __pthread_mutex_lock(&lock);
+    __UCLIBC_MUTEX_LOCK(mylock);
     ostate = &unsafe_state.state[-1];
     if (setstate_r (arg_state, &unsafe_state) < 0)
 	ostate = NULL;
-    __pthread_mutex_unlock(&lock);
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return (char *) ostate;
 }
 
@@ -247,9 +245,9 @@ long int random ()
 {
   int32_t retval;
 
-  __pthread_mutex_lock(&lock);
+  __UCLIBC_MUTEX_LOCK(mylock);
   random_r (&unsafe_state, &retval);
-  __pthread_mutex_unlock(&lock);
+  __UCLIBC_MUTEX_UNLOCK(mylock);
   return retval;
 }
 
diff --git a/libc/stdlib/setenv.c b/libc/stdlib/setenv.c
index d0cfe52..2d899cc 100644
--- a/libc/stdlib/setenv.c
+++ b/libc/stdlib/setenv.c
@@ -17,7 +17,7 @@
    02111-1307 USA.  
    
    modified for uClibc by Erik Andersen <andersen@codepoet.org>
-   */
+*/
 
 #define _GNU_SOURCE
 #include <features.h>
@@ -26,16 +26,9 @@
 #include <string.h>
 #include <unistd.h>
 
-#ifdef __UCLIBC_HAS_THREADS__
-#include <pthread.h>
-static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
-# define LOCK	__pthread_mutex_lock(&mylock)
-# define UNLOCK	__pthread_mutex_unlock(&mylock);
-#else
-# define LOCK
-# define UNLOCK
-#endif
+#include <bits/uClibc_mutex.h>
 
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
 
 /* If this variable is not a null pointer we allocated the current
    environment.  */
@@ -49,14 +42,15 @@ static char **last_environ;
    to reuse values once generated for a `setenv' call since we can never
    free the strings.  */
 int __add_to_environ (const char *name, const char *value, 
-	const char *combined, int replace)
+					  const char *combined, int replace)
 {
     register char **ep;
     register size_t size;
     const size_t namelen = strlen (name);
     const size_t vallen = value != NULL ? strlen (value) + 1 : 0;
+    int rv = -1;
 
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
 
     /* We have to get the pointer now that we have the lock and not earlier
        since another thread might have created a new environment.  */
@@ -64,72 +58,72 @@ int __add_to_environ (const char *name, 
 
     size = 0;
     if (ep != NULL) {
-	for (; *ep != NULL; ++ep) {
-	    if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
-		break;
-	    else
-		++size;
-	}
+		for (; *ep != NULL; ++ep) {
+			if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
+				break;
+			else
+				++size;
+		}
     }
 
     if (ep == NULL || *ep == NULL) {
-	char **new_environ;
+		char **new_environ;
 
-	/* We allocated this space; we can extend it.  */
-	new_environ = (char **) realloc (last_environ,
-		(size + 2) * sizeof (char *));
-	if (new_environ == NULL) {
-	    UNLOCK;
-	    return -1;
-	}
-
-	/* If the whole entry is given add it.  */
-	if (combined != NULL) {
-	    /* We must not add the string to the search tree since it belongs
-	       to the user.  */
-	    new_environ[size] = (char *) combined;
-	} else {
-	    /* See whether the value is already known.  */
-	    new_environ[size] = (char *) malloc (namelen + 1 + vallen);
-	    if (new_environ[size] == NULL) {
-		__set_errno (ENOMEM);
-		UNLOCK;
-		return -1;
-	    }
-
-	    memcpy (new_environ[size], name, namelen);
-	    new_environ[size][namelen] = '=';
-	    memcpy (&new_environ[size][namelen + 1], value, vallen);
-	}
-
-	if (__environ != last_environ) {
-	    memcpy ((char *) new_environ, (char *) __environ,
-		    size * sizeof (char *));
-	}
+		/* We allocated this space; we can extend it.  */
+		new_environ = (char **) realloc (last_environ,
+										 (size + 2) * sizeof (char *));
+		if (new_environ == NULL) {
+			goto DONE;
+		}
+
+		/* If the whole entry is given add it.  */
+		if (combined != NULL) {
+			/* We must not add the string to the search tree since it belongs
+			   to the user.  */
+			new_environ[size] = (char *) combined;
+		} else {
+			/* See whether the value is already known.  */
+			new_environ[size] = (char *) malloc (namelen + 1 + vallen);
+			if (new_environ[size] == NULL) {
+				__set_errno (ENOMEM);
+				goto DONE;
+			}
+
+			memcpy (new_environ[size], name, namelen);
+			new_environ[size][namelen] = '=';
+			memcpy (&new_environ[size][namelen + 1], value, vallen);
+		}
+
+		if (__environ != last_environ) {
+			memcpy ((char *) new_environ, (char *) __environ,
+					size * sizeof (char *));
+		}
 
-	new_environ[size + 1] = NULL;
-	last_environ = __environ = new_environ;
+		new_environ[size + 1] = NULL;
+		last_environ = __environ = new_environ;
     } else if (replace) {
-	char *np;
+		char *np;
 
-	/* Use the user string if given.  */
-	if (combined != NULL) {
-	    np = (char *) combined;
-	} else {
-	    np = malloc (namelen + 1 + vallen);
-	    if (np == NULL) {
-		UNLOCK;
-		return -1;
-	    }
-	    memcpy (np, name, namelen);
-	    np[namelen] = '=';
-	    memcpy (&np[namelen + 1], value, vallen);
-	}
-	*ep = np;
-    }
-
-    UNLOCK;
-    return 0;
+		/* Use the user string if given.  */
+		if (combined != NULL) {
+			np = (char *) combined;
+		} else {
+			np = malloc (namelen + 1 + vallen);
+			if (np == NULL) {
+				goto DONE;
+			}
+			memcpy (np, name, namelen);
+			np[namelen] = '=';
+			memcpy (&np[namelen + 1], value, vallen);
+		}
+		*ep = np;
+    }
+
+    rv = 0;
+
+ DONE:
+    __UCLIBC_MUTEX_UNLOCK(mylock);
+    return rv;
 }
 
 int setenv (const char *name, const char *value, int replace)
@@ -143,26 +137,26 @@ int unsetenv (const char *name)
     char **ep;
 
     if (name == NULL || *name == '\0' || strchr (name, '=') != NULL) {
-	__set_errno (EINVAL);
-	return -1;
+		__set_errno (EINVAL);
+		return -1;
     }
 
     len = strlen (name);
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     ep = __environ;
     while (*ep != NULL) {
-	if (!strncmp (*ep, name, len) && (*ep)[len] == '=') {
-	    /* Found it.  Remove this pointer by moving later ones back.  */
-	    char **dp = ep;
-	    do {
-		dp[0] = dp[1];
-	    } while (*dp++);
-	    /* Continue the loop in case NAME appears again.  */
-	} else {
-	    ++ep;
-	}
+		if (!strncmp (*ep, name, len) && (*ep)[len] == '=') {
+			/* Found it.  Remove this pointer by moving later ones back.  */
+			char **dp = ep;
+			do {
+				dp[0] = dp[1];
+			} while (*dp++);
+			/* Continue the loop in case NAME appears again.  */
+		} else {
+			++ep;
+		}
     }
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return 0;
 }
 
@@ -171,15 +165,15 @@ int unsetenv (const char *name)
    for Fortran 77) requires this function.  */
 int clearenv (void)
 {
-    LOCK;
+    __UCLIBC_MUTEX_LOCK(mylock);
     if (__environ == last_environ && __environ != NULL) {
-	/* We allocated this environment so we can free it.  */
-	free (__environ);
-	last_environ = NULL;
+		/* We allocated this environment so we can free it.  */
+		free (__environ);
+		last_environ = NULL;
     }
     /* Clear the environment pointer removes the whole environment.  */
     __environ = NULL;
-    UNLOCK;
+    __UCLIBC_MUTEX_UNLOCK(mylock);
     return 0;
 }
 
@@ -190,10 +184,10 @@ int putenv (char *string)
     const char *const name_end = strchr (string, '=');
 
     if (name_end != NULL) {
-	char *name = strndup(string, name_end - string);
-	result = __add_to_environ (name, NULL, string, 1);
-	free(name);
-	return(result);
+		char *name = strndup(string, name_end - string);
+		result = __add_to_environ (name, NULL, string, 1);
+		free(name);
+		return(result);
     }
     unsetenv (string);
     return 0;
diff --git a/libc/sysdeps/linux/common/bits/uClibc_stdio.h b/libc/sysdeps/linux/common/bits/uClibc_stdio.h
index 40cd5fe..3c6911e 100644
--- a/libc/sysdeps/linux/common/bits/uClibc_stdio.h
+++ b/libc/sysdeps/linux/common/bits/uClibc_stdio.h
@@ -116,9 +116,7 @@
 #endif
 
 /**********************************************************************/
-#ifdef __UCLIBC_HAS_THREADS__
-/* Need this for pthread_mutex_t. */
-#include <bits/pthreadtypes.h>
+#include <bits/uClibc_mutex.h>
 
 /* user_locking
  * 0 : do auto locking/unlocking
@@ -132,43 +130,37 @@
  * This way, we avoid calling the weak lock/unlock functions.
  */
 
-#define __STDIO_AUTO_THREADLOCK_VAR			int __infunc_user_locking
-
-#define __STDIO_AUTO_THREADLOCK(__stream)								\
-	if ((__infunc_user_locking = (__stream)->__user_locking) == 0) {	\
-		__pthread_mutex_lock(&(__stream)->__lock);						\
-	}
-
-#define __STDIO_AUTO_THREADUNLOCK(__stream)				\
-	if (__infunc_user_locking == 0) {					\
-		__pthread_mutex_unlock(&(__stream)->__lock);		\
-	}
+#define __STDIO_AUTO_THREADLOCK_VAR											\
+        __UCLIBC_MUTEX_AUTO_LOCK_VAR(__infunc_user_locking)
 
-#define __STDIO_SET_USER_LOCKING(__stream)	((__stream)->__user_locking = 1)
+#define __STDIO_AUTO_THREADLOCK(__stream)									\
+        __UCLIBC_MUTEX_AUTO_LOCK((__stream)->__lock, __infunc_user_locking,	\
+								 (__stream)->__user_locking)
 
-#define __STDIO_ALWAYS_THREADLOCK(__stream)	\
-		__pthread_mutex_lock(&(__stream)->__lock)
+#define __STDIO_AUTO_THREADUNLOCK(__stream)									\
+        __UCLIBC_MUTEX_AUTO_UNLOCK((__stream)->__lock, __infunc_user_locking)
 
-#define __STDIO_ALWAYS_THREADTRYLOCK(__stream)	\
-		__pthread_mutex_trylock(&(__stream)->__lock)
+#define __STDIO_ALWAYS_THREADLOCK(__stream)									\
+        __UCLIBC_MUTEX_LOCK((__stream)->__lock)
 
-#define __STDIO_ALWAYS_THREADUNLOCK(__stream) \
-		__pthread_mutex_unlock(&(__stream)->__lock)
+#define __STDIO_ALWAYS_THREADUNLOCK(__stream)								\
+        __UCLIBC_MUTEX_UNLOCK((__stream)->__lock)
 
-#else  /* __UCLIBC_HAS_THREADS__ */
+#define __STDIO_ALWAYS_THREADLOCK_CANCEL_UNSAFE(__stream)					\
+        __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE((__stream)->__lock)
 
-#define __STDIO_AUTO_THREADLOCK_VAR				((void)0)
+#define __STDIO_ALWAYS_THREADTRYLOCK_CANCEL_UNSAFE(__stream)				\
+        __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE((__stream)->__lock)
 
-#define __STDIO_AUTO_THREADLOCK(__stream)		((void)0)
-#define __STDIO_AUTO_THREADUNLOCK(__stream)		((void)0)
+#define __STDIO_ALWAYS_THREADUNLOCK_CANCEL_UNSAFE(__stream) 				\
+        __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE((__stream)->__lock)
 
+#ifdef __UCLIBC_HAS_THREADS__
+#define __STDIO_SET_USER_LOCKING(__stream)	((__stream)->__user_locking = 1)
+#else
 #define __STDIO_SET_USER_LOCKING(__stream)		((void)0)
+#endif
 
-#define __STDIO_ALWAYS_THREADLOCK(__stream)		((void)0)
-#define __STDIO_ALWAYS_THREADTRYLOCK(__stream)	(0)	/* Always succeed. */
-#define __STDIO_ALWAYS_THREADUNLOCK(__stream)	((void)0)
-
-#endif /* __UCLIBC_HAS_THREADS__ */
 /**********************************************************************/
 
 #define __STDIO_IOFBF 0		/* Fully buffered.  */
@@ -283,7 +275,7 @@ struct __STDIO_FILE_STRUCT {
 #endif
 #ifdef __UCLIBC_HAS_THREADS__
 	int __user_locking;
-	pthread_mutex_t __lock;
+	__UCLIBC_MUTEX(__lock);
 #endif
 /* Everything after this is unimplemented... and may be trashed. */
 #if __STDIO_BUILTIN_BUF_SIZE > 0
@@ -358,10 +350,14 @@ extern void _stdio_term(void);
 extern struct __STDIO_FILE_STRUCT *_stdio_openlist;
 
 #ifdef __UCLIBC_HAS_THREADS__
-extern pthread_mutex_t _stdio_openlist_lock;
-extern int _stdio_openlist_delflag;
+__UCLIBC_MUTEX_EXTERN(_stdio_openlist_add_lock);
+#ifdef __STDIO_BUFFERS
+__UCLIBC_MUTEX_EXTERN(_stdio_openlist_del_lock);
+extern volatile int _stdio_openlist_use_count; /* _stdio_openlist_del_lock */
+extern int _stdio_openlist_del_count; /* _stdio_openlist_del_lock */
+#endif
 extern int _stdio_user_locking;
-extern void __stdio_init_mutex(pthread_mutex_t *m);
+extern void __stdio_init_mutex(__UCLIBC_MUTEX_TYPE *m);
 #endif
 
 #endif
diff --git a/libc/sysdeps/linux/common/getdents.c b/libc/sysdeps/linux/common/getdents.c
index ab6a276..23463e5 100644
--- a/libc/sysdeps/linux/common/getdents.c
+++ b/libc/sysdeps/linux/common/getdents.c
@@ -30,8 +30,6 @@
 #include <sys/syscall.h>
 
 
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-
 struct kernel_dirent
 {
     long		d_ino;
diff --git a/libc/sysdeps/linux/common/sigprocmask.c b/libc/sysdeps/linux/common/sigprocmask.c
index 70ff366..565318d 100644
--- a/libc/sysdeps/linux/common/sigprocmask.c
+++ b/libc/sysdeps/linux/common/sigprocmask.c
@@ -23,6 +23,8 @@ int sigprocmask(int how, const sigset_t 
 	if (set &&
 #if (SIG_BLOCK == 0) && (SIG_UNBLOCK == 1) && (SIG_SETMASK == 2)
 		(((unsigned int) how) > 2)
+#elif (SIG_BLOCK == 1) && (SIG_UNBLOCK == 2) && (SIG_SETMASK == 3)
+		(((unsigned int)(how-1)) > 2)
 #else
 #warning "compile time assumption violated.. slow path..."
 		((how != SIG_BLOCK) && (how != SIG_UNBLOCK)
@@ -48,6 +50,8 @@ int sigprocmask(int how, const sigset_t 
 	if (set &&
 #if (SIG_BLOCK == 0) && (SIG_UNBLOCK == 1) && (SIG_SETMASK == 2)
 		(((unsigned int) how) > 2)
+#elif (SIG_BLOCK == 1) && (SIG_UNBLOCK == 2) && (SIG_SETMASK == 3)
+		(((unsigned int)(how-1)) > 2)
 #else
 #warning "compile time assumption violated.. slow path..."
 		((how != SIG_BLOCK) && (how != SIG_UNBLOCK)
diff --git a/libc/sysdeps/linux/mips/bits/kernel_sigaction.h b/libc/sysdeps/linux/mips/bits/kernel_sigaction.h
index b6f52cc..317e5b3 100644
--- a/libc/sysdeps/linux/mips/bits/kernel_sigaction.h
+++ b/libc/sysdeps/linux/mips/bits/kernel_sigaction.h
@@ -38,3 +38,6 @@ struct kernel_sigaction {
 	void		(*sa_restorer)(void);
 	int		s_resv[1]; /* reserved */
 };
+
+extern int __syscall_rt_sigaction (int, const struct kernel_sigaction *__unbounded,
+	struct kernel_sigaction *__unbounded, size_t);
diff --git a/libc/sysdeps/linux/mips/pipe.S b/libc/sysdeps/linux/mips/pipe.S
index c3afae5..cd88074 100644
--- a/libc/sysdeps/linux/mips/pipe.S
+++ b/libc/sysdeps/linux/mips/pipe.S
@@ -7,25 +7,36 @@
 #include <asm/unistd.h>
 #include <asm/regdef.h>
 
-        .globl  pipe
-        .ent    pipe, 0
+	.globl	pipe
+	.ent	pipe, 0
 pipe:
-        addiu   sp,sp,-24
-        sw      a0,16(sp)
-        li      v0,__NR_pipe
-        syscall
-        beqz    a3, 1f
-        la      t3, errno
-        sw      v0, (t3)
-        li      v0, -1
-        b       2f
+	.frame	sp, 24, sp
+#ifdef __PIC__
+	.set	noreorder
+	.cpload	$25
+	.set 	reorder
+	addiu	sp,sp,-24
+	.cprestore	16
+#else
+	addiu	sp,sp,-24
+#endif
+	sw	a0,16(sp)
+	li	v0,__NR_pipe
+	syscall
+	beqz	a3, 1f
+#ifdef __PIC__
+	la	t0, __syscall_error
+	jr	t9
+#else
+	j	__syscall_error
+#endif
 1:
-        lw      a0, 16(sp)
-        sw      v0, 0(a0)
-        sw      v1, 4(a0)
-        li      v0, 0
+	lw	a0, 16(sp)
+	sw	v0, 0(a0)
+	sw	v1, 4(a0)
+	li	v0, 0
 2:
-        addiu   sp,sp,24
-        j       ra
-        .end    pipe
-        .size   pipe,.-pipe
+	addiu	sp,sp,24
+	j	ra
+	.end	pipe
+	.size	pipe,.-pipe
diff --git a/libcrypt/des.c b/libcrypt/des.c
index 3b49a7a..f7a6be1 100644
--- a/libcrypt/des.c
+++ b/libcrypt/des.c
@@ -504,7 +504,7 @@ do_des(	u_int32_t l_in, u_int32_t r_in, 
 		kl = kl1;
 		kr = kr1;
 		round = 16;
-		while (round--) {
+		do {
 			/*
 			 * Expand R to 48 bits (simulate the E-box).
 			 */
@@ -540,7 +540,7 @@ do_des(	u_int32_t l_in, u_int32_t r_in, 
 			f ^= l;
 			l = r;
 			r = f;
-		}
+		} while (--round);
 		r = l;
 		l = f;
 	}
diff --git a/libpthread/linuxthreads/ptfork.c b/libpthread/linuxthreads/ptfork.c
index eb544f3..cfec2b7 100644
--- a/libpthread/linuxthreads/ptfork.c
+++ b/libpthread/linuxthreads/ptfork.c
@@ -26,6 +26,15 @@
 #include "pthread.h"
 #include "internals.h"
 
+#warning hack alert... should be sufficent for system(), but what about other libc mutexes?
+#include <bits/uClibc_mutex.h>
+
+__UCLIBC_MUTEX_EXTERN(__malloc_lock);
+
+#define __MALLOC_LOCK		__UCLIBC_MUTEX_LOCK(__malloc_lock)
+#define __MALLOC_UNLOCK		__UCLIBC_MUTEX_UNLOCK(__malloc_lock)
+#warning hack alert block end
+
 struct handler_list {
   void (*handler)(void);
   struct handler_list * next;
@@ -91,9 +100,18 @@ pid_t __fork(void)
   parent = pthread_atfork_parent;
   pthread_mutex_unlock(&pthread_atfork_lock);
   pthread_call_handlers(prepare);
+
+#warning hack alert
+  __MALLOC_LOCK;
+
   pid = __libc_fork();
+
+#warning hack alert
+  __MALLOC_UNLOCK;
+
   if (pid == 0) {
     __pthread_reset_main_thread();
+#warning need to reconsider __fresetlockfiles!
     __fresetlockfiles();
     pthread_call_handlers(child);
   } else {
diff -urN -x .git uClibc-0.9.28/libc/sysdeps/linux/common/bits/uClibc_mutex.h uClibc-mjn3/libc/sysdeps/linux/common/bits/uClibc_mutex.h
--- uClibc-0.9.28/libc/sysdeps/linux/common/bits/uClibc_mutex.h	1969-12-31 17:00:00.000000000 -0700
+++ uClibc-mjn3/libc/sysdeps/linux/common/bits/uClibc_mutex.h	2006-03-08 11:21:58.000000000 -0700
@@ -0,0 +1,87 @@
+/* Copyright (C) 2006   Manuel Novoa III    <mjn3@codepoet.org>
+ *
+ * GNU Library General Public License (LGPL) version 2 or later.
+ *
+ * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
+ */
+
+#ifndef _UCLIBC_MUTEX_H
+#define _UCLIBC_MUTEX_H
+
+#include <features.h>
+
+#ifdef __UCLIBC_HAS_THREADS__
+
+#include <pthread.h>
+
+#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_LOCK_CANCEL_UNSAFE(M)								\
+		__pthread_mutex_lock(&(M))
+
+#define __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)								\
+		__pthread_mutex_unlock(&(M))
+
+#define __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)								\
+		__pthread_mutex_trylock(&(M))
+
+#define __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,C)								\
+	do {																	\
+		struct _pthread_cleanup_buffer __infunc_pthread_cleanup_buffer;		\
+		if (C) {															\
+			_pthread_cleanup_push_defer(&__infunc_pthread_cleanup_buffer,	\
+										__pthread_mutex_unlock,				\
+										&(M));								\
+			__pthread_mutex_lock(&(M));										\
+		}																	\
+		((void)0)
+
+#define __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,C)								\
+		if (C) {															\
+			_pthread_cleanup_pop_restore(&__infunc_pthread_cleanup_buffer,1);\
+		}																	\
+	} while (0)
+
+#define __UCLIBC_MUTEX_AUTO_LOCK_VAR(A)		int A
+
+#define __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)										\
+        __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,((A=(V)) == 0))
+
+#define __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)										\
+        __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,(A == 0))
+
+#define __UCLIBC_MUTEX_LOCK(M)												\
+        __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
+
+#define __UCLIBC_MUTEX_UNLOCK(M)											\
+        __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
+
+#else
+
+#define __UCLIBC_MUTEX(M)			void *__UCLIBC_MUTEX_DUMMY_ ## M
+#define __UCLIBC_MUTEX_INIT(M,I)	extern void *__UCLIBC_MUTEX_DUMMY_ ## M
+#define __UCLIBC_MUTEX_STATIC(M)	extern void *__UCLIBC_MUTEX_DUMMY_ ## M
+#define __UCLIBC_MUTEX_EXTERN(M)	extern void *__UCLIBC_MUTEX_DUMMY_ ## M
+
+#define __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)		((void)0)
+#define __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)		((void)0)
+#define __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)		(0)	/* Always succeed? */
+
+#define __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,C)		((void)0)
+#define __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,C)		((void)0)
+
+#define __UCLIBC_MUTEX_AUTO_LOCK_VAR(A)				((void)0)
+#define __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)				((void)0)
+#define __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)				((void)0)
+
+#define __UCLIBC_MUTEX_LOCK(M)						((void)0)
+#define __UCLIBC_MUTEX_UNLOCK(M)					((void)0)
+
+#endif
+
+#endif /* _UCLIBC_MUTEX_H */
diff -urN -x .git uClibc-0.9.28/libc/sysdeps/linux/mips/pipe.c uClibc-mjn3/libc/sysdeps/linux/mips/pipe.c
--- uClibc-0.9.28/libc/sysdeps/linux/mips/pipe.c	2005-08-17 16:49:44.000000000 -0600
+++ uClibc-mjn3/libc/sysdeps/linux/mips/pipe.c	1969-12-31 17:00:00.000000000 -0700
@@ -1,23 +0,0 @@
-/* pipe system call for Linux/MIPS */
-
-/*see uClibc's sh/pipe.c and glibc-2.2.4's mips/pipe.S */
-
-#include <errno.h>
-#include <unistd.h>
-#include <syscall.h>
-
-int pipe(int *fd)
-{
-    register long int res __asm__ ("$2"); // v0
-    register long int res2 __asm__ ("$3"); // v1
-
-    asm ("move\t$4,%2\n\t"		// $4 = a0
-	 "syscall"		/* Perform the system call.  */
-	 : "=r" (res)
-	 : "0" (__NR_pipe), "r" (fd)
-	 : "$4", "$7");
-
-	fd[0] = res;
-	fd[1] = res2;
-	return(0);
-}