Index: uspace/lib/posix/Makefile
===================================================================
--- uspace/lib/posix/Makefile	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/Makefile	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,16 +37,13 @@
 LIBC_FILE = $(LIBC_PREFIX)/libc.a
 
-FIXED_POSIX_LIBRARY = libposixaslibc.a
 FIXED_C_LIBRARY = libc4posix.a
 MERGED_C_LIBRARY = libc.a
 MERGE_LIBRARIES = \
 	$(FIXED_C_LIBRARY) \
-	$(FIXED_POSIX_LIBRARY) \
+	$(LIBRARY).a \
 	$(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a \
 	$(LIBSOFTINT_PREFIX)/libsoftint.a
 
 REDEFS_HIDE_LIBC = redefs-hide-libc-symbols.list
-REDEFS_SHOW_LIBPOSIX = redefs-show-posix-symbols.list
-COLLISIONS_LIST = collisions.list
 
 PRE_DEPEND = $(INCLUDE_LIBC)
@@ -54,6 +51,4 @@
 	$(INCLUDE_LIBC) \
 	$(REDEFS_HIDE_LIBC) \
-	$(REDEFS_SHOW_LIBPOSIX) \
-	$(COLLISIONS_LIST) \
 	libc.o
 
@@ -65,5 +60,4 @@
 	src/fcntl.c \
 	src/fnmatch.c \
-	src/getopt.c \
 	src/locale.c \
 	src/pthread/condvar.c \
@@ -94,11 +88,6 @@
 	ln -s -f -n ../$^ $@
 
-$(FIXED_C_LIBRARY): $(LIBC_FILE) $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
+$(FIXED_C_LIBRARY): $(LIBC_FILE) $(REDEFS_HIDE_LIBC)
 	$(OBJCOPY) --redefine-syms=$(REDEFS_HIDE_LIBC) $(LIBC_FILE) $@
-	$(OBJCOPY) --redefine-syms=$(REDEFS_SHOW_LIBPOSIX) $@ $@
-
-$(FIXED_POSIX_LIBRARY): $(LIBRARY).a $(REDEFS_HIDE_LIBC) $(REDEFS_SHOW_LIBPOSIX)
-	$(OBJCOPY) --redefine-syms=$(REDEFS_HIDE_LIBC) $(LIBRARY).a $@
-	$(OBJCOPY) --redefine-syms=$(REDEFS_SHOW_LIBPOSIX) $@ $@
 
 $(MERGED_C_LIBRARY): $(MERGE_LIBRARIES)
@@ -106,13 +95,5 @@
 	$(AR) rc $@ libc.o
 
-$(REDEFS_HIDE_LIBC): $(COLLISIONS_LIST)
-	sed 's/.*/& __helenos_libc_&/' <$(COLLISIONS_LIST) >$@
+$(REDEFS_HIDE_LIBC): $(SOURCES)
+	sed -n -e 's/_HIDE_LIBC_SYMBOL(\(.*\))/\1 __helenos_libc_\1/p' $(SOURCES) >$@
 
-$(REDEFS_SHOW_LIBPOSIX): $(COLLISIONS_LIST)
-	sed 's/.*/posix_& &/' <$(COLLISIONS_LIST) >$@
-
-$(COLLISIONS_LIST): include/posix/*.h include/posix/*/*.h
-	find ./include/posix -name '*.h' -exec \
-		sed -n -e '/^#/d' -e 's/__POSIX_DEF__/\n&/gp' {} \; | \
-		sed -n -e 's/__POSIX_DEF__(\([^)]*\)).*/\1/p' | \
-		sort -u >$@
Index: uspace/lib/posix/include/posix/ctype.h
===================================================================
--- uspace/lib/posix/include/posix/ctype.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/ctype.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,8 +37,4 @@
 #define POSIX_CTYPE_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "libc/ctype.h"
 
Index: uspace/lib/posix/include/posix/dirent.h
===================================================================
--- uspace/lib/posix/include/posix/dirent.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/dirent.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_DIRENT_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include <libc/dirent.h>
 
Index: uspace/lib/posix/include/posix/dlfcn.h
===================================================================
--- uspace/lib/posix/include/posix/dlfcn.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/dlfcn.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,5 @@
 #define POSIX_DLFCN_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
+#include "libc/dlfcn.h"
 
 #define RTLD_LAZY 1
@@ -43,10 +41,8 @@
 #define RTLD_LOCAL 0
 
-
-extern void *__POSIX_DEF__(dlopen)(const char *, int);
-extern void *__POSIX_DEF__(dlsym)(void *, const char *);
-extern int __POSIX_DEF__(dlclose)(void *);
-extern char *__POSIX_DEF__(dlerror)(void);
-
+extern void *dlopen(const char *, int);
+extern void *dlsym(void *, const char *);
+extern int dlclose(void *);
+extern char *dlerror(void);
 
 #endif
Index: uspace/lib/posix/include/posix/fcntl.h
===================================================================
--- uspace/lib/posix/include/posix/fcntl.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/fcntl.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -35,8 +35,4 @@
 #ifndef POSIX_FCNTL_H_
 #define POSIX_FCNTL_H_
-
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
 
 #include "sys/types.h"
@@ -93,7 +89,6 @@
 #define FD_CLOEXEC         1 /* Close on exec. */
 
-extern int __POSIX_DEF__(open)(const char *pathname, int flags, ...);
-extern int __POSIX_DEF__(fcntl)(int fd, int cmd, ...);
-
+extern int open(const char *pathname, int flags, ...);
+extern int fcntl(int fd, int cmd, ...);
 
 #endif /* POSIX_FCNTL_H_ */
Index: uspace/lib/posix/include/posix/fenv.h
===================================================================
--- uspace/lib/posix/include/posix/fenv.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/fenv.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,5 +37,4 @@
 #define POSIX_FENV_H_
 
-
 #define FE_DIVBYZERO 1
 #define FE_INEXACT 2
Index: uspace/lib/posix/include/posix/fnmatch.h
===================================================================
--- uspace/lib/posix/include/posix/fnmatch.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/fnmatch.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_FNMATCH_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 /* Error Values */
 #undef FNM_NOMATCH
@@ -60,5 +56,5 @@
 #define FNM_CASEFOLD 16
 
-extern int __POSIX_DEF__(fnmatch)(const char *pattern, const char *string, int flags);
+extern int fnmatch(const char *pattern, const char *string, int flags);
 
 
Index: uspace/lib/posix/include/posix/getopt.h
===================================================================
--- uspace/lib/posix/include/posix/getopt.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/getopt.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -35,8 +35,4 @@
 #define POSIX_GETOPT_H
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "unistd.h"
 
@@ -55,5 +51,5 @@
 #endif
 
-extern int __POSIX_DEF__(getopt_long)(int, char * const [], const char *, const struct option *, int *);
+extern int getopt_long(int, char * const [], const char *, const struct option *, int *);
 
 
Index: uspace/lib/posix/include/posix/inttypes.h
===================================================================
--- uspace/lib/posix/include/posix/inttypes.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/inttypes.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_INTTYPES_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "stdint.h"
 #include "libc/inttypes.h"
Index: uspace/lib/posix/include/posix/locale.h
===================================================================
--- uspace/lib/posix/include/posix/locale.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/locale.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,15 +36,11 @@
 #define POSIX_LOCALE_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include <_bits/NULL.h>
 
 #ifndef __locale_t_defined
 	#define __locale_t_defined
-	typedef struct __posix_locale *__POSIX_DEF__(locale_t);
+	typedef struct __posix_locale *locale_t;
 	#ifndef LIBPOSIX_INTERNAL
-		#define locale_t __POSIX_DEF__(locale_t)
+		#define locale_t locale_t
 	#endif
 #endif
@@ -84,5 +80,5 @@
 #define LC_GLOBAL_LOCALE NULL
 
-struct __POSIX_DEF__(lconv) {
+struct lconv {
 	char *currency_symbol;
 	char *decimal_point;
@@ -111,13 +107,13 @@
 };
 
-extern char *__POSIX_DEF__(setlocale)(int category, const char *locale);
-extern struct __POSIX_DEF__(lconv) *__POSIX_DEF__(localeconv)(void);
+extern char *setlocale(int category, const char *locale);
+extern struct lconv *localeconv(void);
 
 /* POSIX Extensions */
-extern __POSIX_DEF__(locale_t) __POSIX_DEF__(duplocale)(__POSIX_DEF__(locale_t) locobj);
-extern void __POSIX_DEF__(freelocale)(__POSIX_DEF__(locale_t) locobj);
-extern __POSIX_DEF__(locale_t) __POSIX_DEF__(newlocale)(int category_mask, const char *locale,
-    __POSIX_DEF__(locale_t) base);
-extern __POSIX_DEF__(locale_t) __POSIX_DEF__(uselocale)(__POSIX_DEF__(locale_t) newloc);
+extern locale_t duplocale(locale_t locobj);
+extern void freelocale(locale_t locobj);
+extern locale_t newlocale(int category_mask, const char *locale,
+    locale_t base);
+extern locale_t uselocale(locale_t newloc);
 
 
Index: uspace/lib/posix/include/posix/pthread.h
===================================================================
--- uspace/lib/posix/include/posix/pthread.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/pthread.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -32,8 +32,4 @@
 #ifndef POSIX_PTHREAD_H_
 #define POSIX_PTHREAD_H_
-
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
 
 #include "libc/thread.h"
@@ -99,5 +95,5 @@
 extern int pthread_cond_signal(pthread_cond_t *);
 extern int pthread_cond_timedwait(pthread_cond_t *__restrict__,
-    pthread_mutex_t *__restrict__, const struct __POSIX_DEF__(timespec) *__restrict__);
+    pthread_mutex_t *__restrict__, const struct timespec *__restrict__);
 extern int pthread_cond_wait(pthread_cond_t *__restrict__,
     pthread_mutex_t *__restrict__);
Index: uspace/lib/posix/include/posix/pwd.h
===================================================================
--- uspace/lib/posix/include/posix/pwd.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/pwd.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,29 +36,25 @@
 #define POSIX_PWD_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
-struct __POSIX_DEF__(passwd) {
+struct passwd {
 	char *pw_name;
-	__POSIX_DEF__(uid_t) pw_uid;
-	__POSIX_DEF__(gid_t) pw_gid;
+	uid_t pw_uid;
+	gid_t pw_gid;
 	char *pw_dir;
 	char *pw_shell;
 };
 
-extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwent)(void);
-extern void __POSIX_DEF__(setpwent)(void);
-extern void __POSIX_DEF__(endpwent)(void);
+extern struct passwd *getpwent(void);
+extern void setpwent(void);
+extern void endpwent(void);
 
-extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwnam)(const char *name);
-extern int __POSIX_DEF__(getpwnam_r)(const char *name, struct __POSIX_DEF__(passwd) *pwd,
-    char *buffer, size_t bufsize, struct __POSIX_DEF__(passwd) **result);
+extern struct passwd *getpwnam(const char *name);
+extern int getpwnam_r(const char *name, struct passwd *pwd,
+    char *buffer, size_t bufsize, struct passwd **result);
 
-extern struct __POSIX_DEF__(passwd) *__POSIX_DEF__(getpwuid)(__POSIX_DEF__(uid_t) uid);
-extern int __POSIX_DEF__(getpwuid_r)(__POSIX_DEF__(uid_t) uid, struct __POSIX_DEF__(passwd) *pwd,
-    char *buffer, size_t bufsize, struct __POSIX_DEF__(passwd) **result);
+extern struct passwd *getpwuid(uid_t uid);
+extern int getpwuid_r(uid_t uid, struct passwd *pwd,
+    char *buffer, size_t bufsize, struct passwd **result);
 
 
Index: uspace/lib/posix/include/posix/signal.h
===================================================================
--- uspace/lib/posix/include/posix/signal.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/signal.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_SIGNAL_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 #include <posix/ucontext.h>
@@ -63,6 +59,6 @@
 	int si_errno;
 
-	__POSIX_DEF__(pid_t) si_pid;
-	__POSIX_DEF__(uid_t) si_uid;
+	pid_t si_pid;
+	uid_t si_uid;
 	void *si_addr;
 	int si_status;
@@ -70,16 +66,16 @@
 	long si_band;
 
-	union __POSIX_DEF__(sigval) si_value;
-} __POSIX_DEF__(siginfo_t);
-
-struct __POSIX_DEF__(sigaction) {
+	union sigval si_value;
+} siginfo_t;
+
+struct sigaction {
 	void (*sa_handler)(int);
-	__POSIX_DEF__(sigset_t) sa_mask;
+	sigset_t sa_mask;
 	int sa_flags;
-	void (*sa_sigaction)(int, __POSIX_DEF__(siginfo_t) *, void *);
+	void (*sa_sigaction)(int, siginfo_t *, void *);
 };
 
 
-/* Values of __POSIX_DEF__(sigevent)::sigev_notify */
+/* Values of sigevent::sigev_notify */
 #undef SIGEV_NONE
 #undef SIGEV_SIGNAL
@@ -229,25 +225,25 @@
 };
 
-extern int __POSIX_DEF__(sigaction)(int sig, const struct __POSIX_DEF__(sigaction) *__restrict__ act,
-    struct __POSIX_DEF__(sigaction) *__restrict__ oact);
-
-extern void (*__POSIX_DEF__(signal)(int sig, void (*func)(int)))(int);
-extern int __POSIX_DEF__(raise)(int sig);
-extern int __POSIX_DEF__(kill)(__POSIX_DEF__(pid_t) pid, int sig);
-extern int __POSIX_DEF__(killpg)(__POSIX_DEF__(pid_t) pid, int sig);
-
-extern void __POSIX_DEF__(psiginfo)(const __POSIX_DEF__(siginfo_t) *pinfo, const char *message);
-extern void __POSIX_DEF__(psignal)(int signum, const char *message);
-
-extern int __POSIX_DEF__(sigemptyset)(__POSIX_DEF__(sigset_t) *set);
-extern int __POSIX_DEF__(sigfillset)(__POSIX_DEF__(sigset_t) *set);
-extern int __POSIX_DEF__(sigaddset)(__POSIX_DEF__(sigset_t) *set, int signo);
-extern int __POSIX_DEF__(sigdelset)(__POSIX_DEF__(sigset_t) *set, int signo);
-extern int __POSIX_DEF__(sigismember)(const __POSIX_DEF__(sigset_t) *set, int signo);
-
-extern int __POSIX_DEF__(thread_sigmask)(int how, const __POSIX_DEF__(sigset_t) *__restrict__ set,
-    __POSIX_DEF__(sigset_t) *__restrict__ oset);
-extern int __POSIX_DEF__(sigprocmask)(int how, const __POSIX_DEF__(sigset_t) *__restrict__ set,
-    __POSIX_DEF__(sigset_t) *__restrict__ oset);
+extern int sigaction(int sig, const struct sigaction *__restrict__ act,
+    struct sigaction *__restrict__ oact);
+
+extern void (*signal(int sig, void (*func)(int)))(int);
+extern int raise(int sig);
+extern int kill(pid_t pid, int sig);
+extern int killpg(pid_t pid, int sig);
+
+extern void psiginfo(const siginfo_t *pinfo, const char *message);
+extern void psignal(int signum, const char *message);
+
+extern int sigemptyset(sigset_t *set);
+extern int sigfillset(sigset_t *set);
+extern int sigaddset(sigset_t *set, int signo);
+extern int sigdelset(sigset_t *set, int signo);
+extern int sigismember(const sigset_t *set, int signo);
+
+extern int thread_sigmask(int how, const sigset_t *__restrict__ set,
+    sigset_t *__restrict__ oset);
+extern int sigprocmask(int how, const sigset_t *__restrict__ set,
+    sigset_t *__restrict__ oset);
 
 
Index: uspace/lib/posix/include/posix/stddef.h
===================================================================
--- uspace/lib/posix/include/posix/stddef.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/stddef.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_STDDEF_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
Index: uspace/lib/posix/include/posix/stdint.h
===================================================================
--- uspace/lib/posix/include/posix/stdint.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/stdint.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_STDINT_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "libc/stdint.h"
 
Index: uspace/lib/posix/include/posix/stdio.h
===================================================================
--- uspace/lib/posix/include/posix/stdio.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/stdio.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,7 +37,5 @@
 #define POSIX_STDIO_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
+#include "libc/stdio.h"
 
 #include "stddef.h"
@@ -67,15 +65,4 @@
 typedef struct _IO_FILE FILE;
 
-#ifndef LIBPOSIX_INTERNAL
-	enum _buffer_type {
-		/** No buffering */
-		_IONBF,
-		/** Line buffering */
-		_IOLBF,
-		/** Full buffering */
-		_IOFBF
-	};
-#endif
-
 extern FILE *stdin;
 extern FILE *stdout;
@@ -130,84 +117,84 @@
 #undef L_ctermid
 #define L_ctermid PATH_MAX
-extern char *__POSIX_DEF__(ctermid)(char *s);
+extern char *ctermid(char *s);
 
 /* Error Recovery */
-extern void __POSIX_DEF__(clearerr)(FILE *stream);
+extern void clearerr(FILE *stream);
 
 /* Input/Output */
 #undef putc
 #define putc fputc
-extern int __POSIX_DEF__(fputs)(const char *__restrict__ s, FILE *__restrict__ stream);
+extern int fputs(const char *__restrict__ s, FILE *__restrict__ stream);
 #undef getc
 #define getc fgetc
-extern int __POSIX_DEF__(ungetc)(int c, FILE *stream);
-extern ssize_t __POSIX_DEF__(getdelim)(char **__restrict__ lineptr, size_t *__restrict__ n,
+extern int ungetc(int c, FILE *stream);
+extern ssize_t getdelim(char **__restrict__ lineptr, size_t *__restrict__ n,
     int delimiter, FILE *__restrict__ stream);
-extern ssize_t __POSIX_DEF__(getline)(char **__restrict__ lineptr, size_t *__restrict__ n,
+extern ssize_t getline(char **__restrict__ lineptr, size_t *__restrict__ n,
     FILE *__restrict__ stream);
 
 /* Opening Streams */
-extern FILE *__POSIX_DEF__(freopen)(const char *__restrict__ filename,
+extern FILE *freopen(const char *__restrict__ filename,
     const char *__restrict__ mode, FILE *__restrict__ stream);
 
 /* Error Messages */
-extern void __POSIX_DEF__(perror)(const char *s);
+extern void perror(const char *s);
 
 /* File Positioning */
 typedef struct {
 	off64_t offset;
-} __POSIX_DEF__(fpos_t);
-
-extern int __POSIX_DEF__(fsetpos)(FILE *stream, const __POSIX_DEF__(fpos_t) *pos);
-extern int __POSIX_DEF__(fgetpos)(FILE *__restrict__ stream, __POSIX_DEF__(fpos_t) *__restrict__ pos);
-extern int __POSIX_DEF__(fseek)(FILE *stream, long offset, int whence);
-extern int __POSIX_DEF__(fseeko)(FILE *stream, __POSIX_DEF__(off_t) offset, int whence);
-extern long __POSIX_DEF__(ftell)(FILE *stream);
-extern __POSIX_DEF__(off_t) __POSIX_DEF__(ftello)(FILE *stream);
+} fpos_t;
+
+extern int fsetpos(FILE *stream, const fpos_t *pos);
+extern int fgetpos(FILE *__restrict__ stream, fpos_t *__restrict__ pos);
+extern int fseek(FILE *stream, long offset, int whence);
+extern int fseeko(FILE *stream, off_t offset, int whence);
+extern long ftell(FILE *stream);
+extern off_t ftello(FILE *stream);
 
 /* Flushing Buffers */
-extern int __POSIX_DEF__(fflush)(FILE *stream);
+extern int fflush(FILE *stream);
 
 /* Formatted Output */
-extern int __POSIX_DEF__(dprintf)(int fildes, const char *__restrict__ format, ...)
+extern int dprintf(int fildes, const char *__restrict__ format, ...)
     _HELENOS_PRINTF_ATTRIBUTE(2, 3);
-extern int __POSIX_DEF__(vdprintf)(int fildes, const char *__restrict__ format, va_list ap);
-extern int __POSIX_DEF__(sprintf)(char *__restrict__ s, const char *__restrict__ format, ...)
+extern int vdprintf(int fildes, const char *__restrict__ format, va_list ap);
+extern int sprintf(char *__restrict__ s, const char *__restrict__ format, ...)
     _HELENOS_PRINTF_ATTRIBUTE(2, 3);
-extern int __POSIX_DEF__(vsprintf)(char *__restrict__ s, const char *__restrict__ format, va_list ap);
+extern int vsprintf(char *__restrict__ s, const char *__restrict__ format, va_list ap);
 
 /* Formatted Input */
-extern int __POSIX_DEF__(fscanf)(
+extern int fscanf(
     FILE *__restrict__ stream, const char *__restrict__ format, ...);
-extern int __POSIX_DEF__(vfscanf)(
+extern int vfscanf(
     FILE *__restrict__ stream, const char *__restrict__ format, va_list arg);
-extern int __POSIX_DEF__(scanf)(const char *__restrict__ format, ...);
-extern int __POSIX_DEF__(vscanf)(const char *__restrict__ format, va_list arg);
-extern int __POSIX_DEF__(sscanf)(
+extern int scanf(const char *__restrict__ format, ...);
+extern int vscanf(const char *__restrict__ format, va_list arg);
+extern int sscanf(
     const char *__restrict__ s, const char *__restrict__ format, ...);
-extern int __POSIX_DEF__(vsscanf)(
+extern int vsscanf(
     const char *__restrict__ s, const char *__restrict__ format, va_list arg);
 
 /* File Locking */
-extern void __POSIX_DEF__(flockfile)(FILE *file);
-extern int __POSIX_DEF__(ftrylockfile)(FILE *file);
-extern void __POSIX_DEF__(funlockfile)(FILE *file);
-extern int __POSIX_DEF__(getc_unlocked)(FILE *stream);
-extern int __POSIX_DEF__(getchar_unlocked)(void);
-extern int __POSIX_DEF__(putc_unlocked)(int c, FILE *stream);
-extern int __POSIX_DEF__(putchar_unlocked)(int c);
+extern void flockfile(FILE *file);
+extern int ftrylockfile(FILE *file);
+extern void funlockfile(FILE *file);
+extern int getc_unlocked(FILE *stream);
+extern int getchar_unlocked(void);
+extern int putc_unlocked(int c, FILE *stream);
+extern int putchar_unlocked(int c);
 
 /* Deleting Files */
-extern int __POSIX_DEF__(remove)(const char *path);
+extern int remove(const char *path);
 
 /* Renaming Files */
-extern int __POSIX_DEF__(rename)(const char *oldname, const char *newname);
+extern int rename(const char *oldname, const char *newname);
 
 /* Temporary Files */
 #undef L_tmpnam
 #define L_tmpnam PATH_MAX
-extern char *__POSIX_DEF__(tmpnam)(char *s);
-extern char *__POSIX_DEF__(tempnam)(const char *dir, const char *pfx);
-extern FILE *__POSIX_DEF__(tmpfile)(void);
+extern char *tmpnam(char *s);
+extern char *tempnam(const char *dir, const char *pfx);
+extern FILE *tmpfile(void);
 
 
Index: uspace/lib/posix/include/posix/stdlib.h
===================================================================
--- uspace/lib/posix/include/posix/stdlib.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/stdlib.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,8 +37,4 @@
 #define POSIX_STDLIB_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
@@ -53,12 +49,12 @@
 #define EXIT_SUCCESS 0
 #define _Exit exit
-extern int __POSIX_DEF__(atexit)(void (*func)(void));
+extern int atexit(void (*func)(void));
 extern void exit(int status) __attribute__((noreturn));
 extern void abort(void) __attribute__((noreturn));
 
 /* Absolute Value */
-extern int __POSIX_DEF__(abs)(int i);
-extern long __POSIX_DEF__(labs)(long i);
-extern long long __POSIX_DEF__(llabs)(long long i);
+extern int abs(int i);
+extern long labs(long i);
+extern long long llabs(long long i);
 
 /* Integer Division */
@@ -66,37 +62,37 @@
 typedef struct {
 	int quot, rem;
-} __POSIX_DEF__(div_t);
+} div_t;
 
 typedef struct {
 	long quot, rem;
-} __POSIX_DEF__(ldiv_t);
+} ldiv_t;
 
 typedef struct {
 	long long quot, rem;
-} __POSIX_DEF__(lldiv_t);
+} lldiv_t;
 
-extern __POSIX_DEF__(div_t) __POSIX_DEF__(div)(int numer, int denom);
-extern __POSIX_DEF__(ldiv_t) __POSIX_DEF__(ldiv)(long numer, long denom);
-extern __POSIX_DEF__(lldiv_t) __POSIX_DEF__(lldiv)(long long numer, long long denom);
+extern div_t div(int numer, int denom);
+extern ldiv_t ldiv(long numer, long denom);
+extern lldiv_t lldiv(long long numer, long long denom);
 
 /* Array Functions */
-extern void __POSIX_DEF__(qsort)(void *array, size_t count, size_t size,
+extern void qsort(void *array, size_t count, size_t size,
     int (*compare)(const void *, const void *));
-extern void *__POSIX_DEF__(bsearch)(const void *key, const void *base,
+extern void *bsearch(const void *key, const void *base,
     size_t nmemb, size_t size, int (*compar)(const void *, const void *));
 
 /* Environment Access */
-extern char *__POSIX_DEF__(getenv)(const char *name);
-extern int __POSIX_DEF__(putenv)(char *string);
-extern int __POSIX_DEF__(system)(const char *string);
+extern char *getenv(const char *name);
+extern int putenv(char *string);
+extern int system(const char *string);
 
 /* Symbolic Links */
-extern char *__POSIX_DEF__(realpath)(const char *__restrict__ name, char *__restrict__ resolved);
+extern char *realpath(const char *__restrict__ name, char *__restrict__ resolved);
 
 /* Floating Point Conversion */
-extern double __POSIX_DEF__(atof)(const char *nptr);
-extern float __POSIX_DEF__(strtof)(const char *__restrict__ nptr, char **__restrict__ endptr);
-extern double __POSIX_DEF__(strtod)(const char *__restrict__ nptr, char **__restrict__ endptr);
-extern long double __POSIX_DEF__(strtold)(const char *__restrict__ nptr, char **__restrict__ endptr);
+extern double atof(const char *nptr);
+extern float strtof(const char *__restrict__ nptr, char **__restrict__ endptr);
+extern double strtod(const char *__restrict__ nptr, char **__restrict__ endptr);
+extern long double strtold(const char *__restrict__ nptr, char **__restrict__ endptr);
 
 /* Integer Conversion */
@@ -114,21 +110,21 @@
 
 /* Memory Allocation */
-extern void *__POSIX_DEF__(malloc)(size_t size)
+extern void *malloc(size_t size)
     __attribute__((malloc));
-extern void *__POSIX_DEF__(calloc)(size_t nelem, size_t elsize)
+extern void *calloc(size_t nelem, size_t elsize)
     __attribute__((malloc));
-extern void *__POSIX_DEF__(realloc)(void *ptr, size_t size)
+extern void *realloc(void *ptr, size_t size)
     __attribute__((warn_unused_result));
-extern void __POSIX_DEF__(free)(void *ptr);
+extern void free(void *ptr);
 
 /* Temporary Files */
-extern int __POSIX_DEF__(mkstemp)(char *tmpl);
+extern int mkstemp(char *tmpl);
 
 /* Pseudo-random number generator */
-extern int __POSIX_DEF__(rand)(void);
-extern void __POSIX_DEF__(srand)(unsigned int seed);
+extern int rand(void);
+extern void srand(unsigned int seed);
 
 /* Legacy Declarations */
-extern char *__POSIX_DEF__(mktemp)(char *tmpl);
+extern char *mktemp(char *tmpl);
 extern int bsd_getloadavg(double loadavg[], int nelem);
 
Index: uspace/lib/posix/include/posix/string.h
===================================================================
--- uspace/lib/posix/include/posix/string.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/string.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,8 +37,4 @@
 #define POSIX_STRING_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
@@ -74,54 +70,54 @@
 
 /* Copying and Concatenation */
-extern char *__POSIX_DEF__(strcpy)(char *__restrict__ dest, const char *__restrict__ src);
-extern char *__POSIX_DEF__(strncpy)(char *__restrict__ dest, const char *__restrict__ src, size_t n);
-extern char *__POSIX_DEF__(stpcpy)(char *__restrict__ dest, const char *__restrict__ src);
-extern char *__POSIX_DEF__(stpncpy)(char *__restrict__ dest, const char *__restrict__ src, size_t n);
-extern char *__POSIX_DEF__(strcat)(char *__restrict__ dest, const char *__restrict__ src);
-extern char *__POSIX_DEF__(strncat)(char *__restrict__ dest, const char *__restrict__ src, size_t n);
-extern void *__POSIX_DEF__(memccpy)(void *__restrict__ dest, const void *__restrict__ src, int c, size_t n);
-extern char *__POSIX_DEF__(strdup)(const char *s);
-extern char *__POSIX_DEF__(strndup)(const char *s, size_t n);
+extern char *strcpy(char *__restrict__ dest, const char *__restrict__ src);
+extern char *strncpy(char *__restrict__ dest, const char *__restrict__ src, size_t n);
+extern char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
+extern char *stpncpy(char *__restrict__ dest, const char *__restrict__ src, size_t n);
+extern char *strcat(char *__restrict__ dest, const char *__restrict__ src);
+extern char *strncat(char *__restrict__ dest, const char *__restrict__ src, size_t n);
+extern void *memccpy(void *__restrict__ dest, const void *__restrict__ src, int c, size_t n);
+extern char *strdup(const char *s);
+extern char *strndup(const char *s, size_t n);
 
 /* String/Array Comparison */
-extern int __POSIX_DEF__(memcmp)(const void *mem1, const void *mem2, size_t n);
-extern int __POSIX_DEF__(strcmp)(const char *s1, const char *s2);
-extern int __POSIX_DEF__(strncmp)(const char *s1, const char *s2, size_t n);
+extern int memcmp(const void *mem1, const void *mem2, size_t n);
+extern int strcmp(const char *s1, const char *s2);
+extern int strncmp(const char *s1, const char *s2, size_t n);
 
 /* Search Functions */
-extern void *__POSIX_DEF__(memchr)(const void *mem, int c, size_t n);
-extern char *__POSIX_DEF__(strchr)(const char *s, int c);
-extern char *__POSIX_DEF__(strrchr)(const char *s, int c);
+extern void *memchr(const void *mem, int c, size_t n);
+extern char *strchr(const char *s, int c);
+extern char *strrchr(const char *s, int c);
 extern char *gnu_strchrnul(const char *s, int c);
-extern char *__POSIX_DEF__(strpbrk)(const char *s1, const char *s2);
-extern size_t __POSIX_DEF__(strcspn)(const char *s1, const char *s2);
-extern size_t __POSIX_DEF__(strspn)(const char *s1, const char *s2);
-extern char *__POSIX_DEF__(strstr)(const char *haystack, const char *needle);
+extern char *strpbrk(const char *s1, const char *s2);
+extern size_t strcspn(const char *s1, const char *s2);
+extern size_t strspn(const char *s1, const char *s2);
+extern char *strstr(const char *haystack, const char *needle);
 
 /* Tokenization functions. */
-extern char *__POSIX_DEF__(strtok_r)(char *, const char *, char **);
-extern char *__POSIX_DEF__(strtok)(char *, const char *);
+extern char *strtok_r(char *, const char *, char **);
+extern char *strtok(char *, const char *);
 
 
 /* Collation Functions */
-extern int __POSIX_DEF__(strcoll)(const char *s1, const char *s2);
-extern size_t __POSIX_DEF__(strxfrm)(char *__restrict__ s1, const char *__restrict__ s2, size_t n);
+extern int strcoll(const char *s1, const char *s2);
+extern size_t strxfrm(char *__restrict__ s1, const char *__restrict__ s2, size_t n);
 
 /* Error Messages */
-extern char *__POSIX_DEF__(strerror)(int errnum);
-extern int __POSIX_DEF__(strerror_r)(int errnum, char *buf, size_t bufsz);
+extern char *strerror(int errnum);
+extern int strerror_r(int errnum, char *buf, size_t bufsz);
 
 /* String Length */
-extern size_t __POSIX_DEF__(strlen)(const char *s);
-extern size_t __POSIX_DEF__(strnlen)(const char *s, size_t n);
+extern size_t strlen(const char *s);
+extern size_t strnlen(const char *s, size_t n);
 
 /* Signal Messages */
-extern char *__POSIX_DEF__(strsignal)(int signum);
+extern char *strsignal(int signum);
 
 /* Legacy Declarations */
 #ifndef POSIX_STRINGS_H_
-extern int __POSIX_DEF__(ffs)(int i);
-extern int __POSIX_DEF__(strcasecmp)(const char *s1, const char *s2);
-extern int __POSIX_DEF__(strncasecmp)(const char *s1, const char *s2, size_t n);
+extern int ffs(int i);
+extern int strcasecmp(const char *s1, const char *s2);
+extern int strncasecmp(const char *s1, const char *s2, size_t n);
 #endif
 
Index: uspace/lib/posix/include/posix/strings.h
===================================================================
--- uspace/lib/posix/include/posix/strings.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/strings.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,20 +37,15 @@
 #define POSIX_STRINGS_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
-
 #include "libc/types/common.h"
 
 /* Search Functions */
 #ifndef POSIX_STRING_H_
-extern int __POSIX_DEF__(ffs)(int i);
+extern int ffs(int i);
 #endif
 
 /* String/Array Comparison */
 #ifndef POSIX_STRING_H_
-extern int __POSIX_DEF__(strcasecmp)(const char *s1, const char *s2);
-extern int __POSIX_DEF__(strncasecmp)(const char *s1, const char *s2, size_t n);
+extern int strcasecmp(const char *s1, const char *s2);
+extern int strncasecmp(const char *s1, const char *s2, size_t n);
 #endif
 
@@ -62,9 +57,9 @@
 
 /* Legacy Functions */
-extern int __POSIX_DEF__(bcmp)(const void *mem1, const void *mem2, size_t n);
-extern void __POSIX_DEF__(bcopy)(const void *src, void *dest, size_t n);
-extern void __POSIX_DEF__(bzero)(void *mem, size_t n);
-extern char *__POSIX_DEF__(index)(const char *s, int c);
-extern char *__POSIX_DEF__(rindex)(const char *s, int c);
+extern int bcmp(const void *mem1, const void *mem2, size_t n);
+extern void bcopy(const void *src, void *dest, size_t n);
+extern void bzero(void *mem, size_t n);
+extern char *index(const char *s, int c);
+extern char *rindex(const char *s, int c);
 
 
Index: uspace/lib/posix/include/posix/sys/mman.h
===================================================================
--- uspace/lib/posix/include/posix/sys/mman.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/sys/mman.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_SYS_MMAN_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "types.h"
 #include <abi/mm/as.h>
@@ -61,7 +57,7 @@
 
 extern void *
-__POSIX_DEF__(mmap)(void *start, size_t length, int prot, int flags, int fd,
-    __POSIX_DEF__(off_t) offset);
-extern int __POSIX_DEF__(munmap)(void *start, size_t length);
+mmap(void *start, size_t length, int prot, int flags, int fd,
+    off_t offset);
+extern int munmap(void *start, size_t length);
 
 
Index: uspace/lib/posix/include/posix/sys/stat.h
===================================================================
--- uspace/lib/posix/include/posix/sys/stat.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/sys/stat.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -39,8 +39,4 @@
 #include "types.h"
 #include "../time.h"
-
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
 
 /* values are the same as on Linux */
@@ -112,15 +108,15 @@
 #define S_ISSOCK(m) ((m & S_IFSOCK) != 0) /* socket? (Not in POSIX.1-1996.) */
 
-struct __POSIX_DEF__(stat) {
-	__POSIX_DEF__(dev_t)     st_dev;     /* ID of device containing file */
-	__POSIX_DEF__(ino_t)     st_ino;     /* inode number */
-	__POSIX_DEF__(mode_t)    st_mode;    /* protection */
-	__POSIX_DEF__(nlink_t)   st_nlink;   /* number of hard links */
-	__POSIX_DEF__(uid_t)     st_uid;     /* user ID of owner */
-	__POSIX_DEF__(gid_t)     st_gid;     /* group ID of owner */
-	__POSIX_DEF__(dev_t)     st_rdev;    /* device ID (if special file) */
-	__POSIX_DEF__(off_t)     st_size;    /* total size, in bytes */
-	__POSIX_DEF__(blksize_t) st_blksize; /* blocksize for file system I/O */
-	__POSIX_DEF__(blkcnt_t)  st_blocks;  /* number of 512B blocks allocated */
+struct stat {
+	dev_t     st_dev;     /* ID of device containing file */
+	ino_t     st_ino;     /* inode number */
+	mode_t    st_mode;    /* protection */
+	nlink_t   st_nlink;   /* number of hard links */
+	uid_t     st_uid;     /* user ID of owner */
+	gid_t     st_gid;     /* group ID of owner */
+	dev_t     st_rdev;    /* device ID (if special file) */
+	off_t     st_size;    /* total size, in bytes */
+	blksize_t st_blksize; /* blocksize for file system I/O */
+	blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
 	time_t          st_atime;   /* time of last access */
 	time_t          st_mtime;   /* time of last modification */
@@ -128,10 +124,10 @@
 };
 
-extern int __POSIX_DEF__(fstat)(int fd, struct __POSIX_DEF__(stat) *st);
-extern int __POSIX_DEF__(lstat)(const char *__restrict__ path, struct __POSIX_DEF__(stat) *__restrict__ st);
-extern int __POSIX_DEF__(stat)(const char *__restrict__ path, struct __POSIX_DEF__(stat) *__restrict__ st);
-extern int __POSIX_DEF__(chmod)(const char *path, __POSIX_DEF__(mode_t) mode);
-extern __POSIX_DEF__(mode_t) __POSIX_DEF__(umask)(__POSIX_DEF__(mode_t) mask);
-extern int __POSIX_DEF__(mkdir)(const char *path, __POSIX_DEF__(mode_t) mode);
+extern int fstat(int fd, struct stat *st);
+extern int lstat(const char *__restrict__ path, struct stat *__restrict__ st);
+extern int stat(const char *__restrict__ path, struct stat *__restrict__ st);
+extern int chmod(const char *path, mode_t mode);
+extern mode_t umask(mode_t mask);
+extern int mkdir(const char *path, mode_t mode);
 
 
Index: uspace/lib/posix/include/posix/sys/time.h
===================================================================
--- uspace/lib/posix/include/posix/sys/time.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/sys/time.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,8 +34,4 @@
 #define POSIX_SYS_TIME_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "libc/sys/time.h"
 
Index: uspace/lib/posix/include/posix/sys/types.h
===================================================================
--- uspace/lib/posix/include/posix/sys/types.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/sys/types.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,29 +37,25 @@
 #define POSIX_SYS_TYPES_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "libc/offset.h"
 #include "libc/sys/time.h"
 #include "libc/types/common.h"
 
-typedef unsigned int __POSIX_DEF__(ino_t);
-typedef unsigned int __POSIX_DEF__(nlink_t);
-typedef unsigned int __POSIX_DEF__(uid_t);
-typedef unsigned int __POSIX_DEF__(gid_t);
-typedef off64_t __POSIX_DEF__(off_t);
-typedef long __POSIX_DEF__(blksize_t);
-typedef long __POSIX_DEF__(blkcnt_t);
-typedef int64_t __POSIX_DEF__(pid_t);
-typedef sysarg_t __POSIX_DEF__(dev_t);
-typedef unsigned int __POSIX_DEF__(mode_t);
+typedef unsigned int ino_t;
+typedef unsigned int nlink_t;
+typedef unsigned int uid_t;
+typedef unsigned int gid_t;
+typedef off64_t off_t;
+typedef long blksize_t;
+typedef long blkcnt_t;
+typedef int64_t pid_t;
+typedef sysarg_t dev_t;
+typedef unsigned int mode_t;
 
 /* PThread Types */
-typedef struct __POSIX_DEF__(thread_attr) __POSIX_DEF__(thread_attr_t);
+typedef struct thread_attr thread_attr_t;
 
 /* Clock Types */
-typedef long __POSIX_DEF__(clock_t);
-typedef int __POSIX_DEF__(clockid_t);
+typedef long clock_t;
+typedef int clockid_t;
 
 
Index: uspace/lib/posix/include/posix/sys/wait.h
===================================================================
--- uspace/lib/posix/include/posix/sys/wait.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/sys/wait.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,8 +36,4 @@
 #define POSIX_SYS_WAIT_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "types.h"
 
@@ -56,6 +52,6 @@
 extern int __posix_wtermsig(int status);
 
-extern __POSIX_DEF__(pid_t) __POSIX_DEF__(wait)(int *stat_ptr);
-extern __POSIX_DEF__(pid_t) __POSIX_DEF__(waitpid)(__POSIX_DEF__(pid_t) pid, int *stat_ptr, int options);
+extern pid_t wait(int *stat_ptr);
+extern pid_t waitpid(pid_t pid, int *stat_ptr, int options);
 
 
Index: uspace/lib/posix/include/posix/time.h
===================================================================
--- uspace/lib/posix/include/posix/time.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/time.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,8 +37,4 @@
 #define POSIX_TIME_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
@@ -51,69 +47,69 @@
 #ifndef __locale_t_defined
 	#define __locale_t_defined
-	typedef struct __posix_locale *__POSIX_DEF__(locale_t);
+	typedef struct __posix_locale *locale_t;
 	#ifndef LIBPOSIX_INTERNAL
-		#define locale_t __POSIX_DEF__(locale_t)
+		#define locale_t locale_t
 	#endif
 #endif
 
 #ifndef POSIX_SIGNAL_H_
-	struct __POSIX_DEF__(sigevent);
+	struct sigevent;
 	#ifndef LIBPOSIX_INTERNAL
-		#define sigevent __POSIX_DEF__(sigevent)
+		#define sigevent sigevent
 	#endif
 #endif
 
 #undef CLOCK_REALTIME
-#define CLOCK_REALTIME ((__POSIX_DEF__(clockid_t)) 0)
+#define CLOCK_REALTIME ((clockid_t) 0)
 
-struct __POSIX_DEF__(timespec) {
+struct timespec {
 	time_t tv_sec; /* Seconds. */
 	long tv_nsec; /* Nanoseconds. */
 };
 
-struct __POSIX_DEF__(itimerspec) {
-	struct __POSIX_DEF__(timespec) it_interval; /* Timer period. */
-	struct __POSIX_DEF__(timespec) it_value; /* Timer expiration. */
+struct itimerspec {
+	struct timespec it_interval; /* Timer period. */
+	struct timespec it_value; /* Timer expiration. */
 };
 
-typedef struct __posix_timer *__POSIX_DEF__(timer_t);
+typedef struct __posix_timer *timer_t;
 
 /* Timezones */
-extern int __POSIX_DEF__(daylight);
-extern long __POSIX_DEF__(timezone);
-extern char *__POSIX_DEF__(tzname)[2];
-extern void __POSIX_DEF__(tzset)(void);
+extern int daylight;
+extern long timezone;
+extern char *tzname[2];
+extern void tzset(void);
 
 /* Time */
-extern time_t __POSIX_DEF__(time)(time_t *t);
+extern time_t time(time_t *t);
 
 /* Broken-down Time */
-extern struct tm *__POSIX_DEF__(gmtime_r)(const time_t *__restrict__ timer,
+extern struct tm *gmtime_r(const time_t *__restrict__ timer,
     struct tm *__restrict__ result);
-extern struct tm *__POSIX_DEF__(gmtime)(const time_t *__restrict__ timep);
-extern struct tm *__POSIX_DEF__(localtime_r)(const time_t *__restrict__ timer,
+extern struct tm *gmtime(const time_t *__restrict__ timep);
+extern struct tm *localtime_r(const time_t *__restrict__ timer,
     struct tm *__restrict__ result);
-extern struct tm *__POSIX_DEF__(localtime)(const time_t *__restrict__ timep);
+extern struct tm *localtime(const time_t *__restrict__ timep);
 
 /* Formatting Calendar Time */
-extern char *__POSIX_DEF__(asctime_r)(const struct tm *__restrict__ timeptr,
+extern char *asctime_r(const struct tm *__restrict__ timeptr,
     char *__restrict__ buf);
-extern char *__POSIX_DEF__(asctime)(const struct tm *__restrict__ timeptr);
-extern char *__POSIX_DEF__(ctime_r)(const time_t *timer, char *buf);
-extern char *__POSIX_DEF__(ctime)(const time_t *timer);
+extern char *asctime(const struct tm *__restrict__ timeptr);
+extern char *ctime_r(const time_t *timer, char *buf);
+extern char *ctime(const time_t *timer);
 extern time_t time(time_t *t);
 
 /* Clocks */
-extern int __POSIX_DEF__(clock_getres)(__POSIX_DEF__(clockid_t) clock_id,
-    struct __POSIX_DEF__(timespec) *res);
-extern int __POSIX_DEF__(clock_gettime)(__POSIX_DEF__(clockid_t) clock_id,
-    struct __POSIX_DEF__(timespec) *tp);
-extern int __POSIX_DEF__(clock_settime)(__POSIX_DEF__(clockid_t) clock_id,
-    const struct __POSIX_DEF__(timespec) *tp); 
-extern int __POSIX_DEF__(clock_nanosleep)(__POSIX_DEF__(clockid_t) clock_id, int flags,
-    const struct __POSIX_DEF__(timespec) *rqtp, struct __POSIX_DEF__(timespec) *rmtp);
+extern int clock_getres(clockid_t clock_id,
+    struct timespec *res);
+extern int clock_gettime(clockid_t clock_id,
+    struct timespec *tp);
+extern int clock_settime(clockid_t clock_id,
+    const struct timespec *tp);
+extern int clock_nanosleep(clockid_t clock_id, int flags,
+    const struct timespec *rqtp, struct timespec *rmtp);
 
 /* CPU Time */
-extern __POSIX_DEF__(clock_t) __POSIX_DEF__(clock)(void);
+extern clock_t clock(void);
 
 
Index: uspace/lib/posix/include/posix/ucontext.h
===================================================================
--- uspace/lib/posix/include/posix/ucontext.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/ucontext.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -36,28 +36,24 @@
 #define POSIX_UCONTEXT_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 
-typedef int __POSIX_DEF__(sig_atomic_t);
-typedef uint32_t __POSIX_DEF__(sigset_t);
-typedef struct __POSIX_DEF__(mcontext) {
+typedef int sig_atomic_t;
+typedef uint32_t sigset_t;
+typedef struct mcontext {
 	/* must not be empty to avoid compiler warnings (-pedantic) */
 	int dummy;
-} __POSIX_DEF__(mcontext_t);
+} mcontext_t;
 
-union __POSIX_DEF__(sigval) {
+union sigval {
 	int sival_int;
 	void *sival_ptr;
 };
 
-struct __POSIX_DEF__(sigevent) {
+struct sigevent {
 	int sigev_notify; /* Notification type. */
 	int sigev_signo; /* Signal number. */
-	union __POSIX_DEF__(sigval) sigev_value; /* Signal value. */
-	void (*sigev_notify_function)(union __POSIX_DEF__(sigval)); /* Notification function. */
-	__POSIX_DEF__(thread_attr_t) *sigev_notify_attributes; /* Notification attributes. */
+	union sigval sigev_value; /* Signal value. */
+	void (*sigev_notify_function)(union sigval); /* Notification function. */
+	thread_attr_t *sigev_notify_attributes; /* Notification attributes. */
 };
 
@@ -66,12 +62,12 @@
 	size_t ss_size;
 	int ss_flags;
-} __POSIX_DEF__(stack_t);
+} stack_t;
 
-typedef struct __POSIX_DEF__(ucontext) {
-	struct __POSIX_DEF__(ucontext) *uc_link;
-	__POSIX_DEF__(sigset_t) uc_sigmask;
-	__POSIX_DEF__(stack_t) uc_stack;
-	__POSIX_DEF__(mcontext_t) uc_mcontext;
-} __POSIX_DEF__(ucontext_t);
+typedef struct ucontext {
+	struct ucontext *uc_link;
+	sigset_t uc_sigmask;
+	stack_t uc_stack;
+	mcontext_t uc_mcontext;
+} ucontext_t;
 
 
Index: uspace/lib/posix/include/posix/unistd.h
===================================================================
--- uspace/lib/posix/include/posix/unistd.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/include/posix/unistd.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -37,8 +37,4 @@
 #define POSIX_UNISTD_H_
 
-#ifndef __POSIX_DEF__
-#define __POSIX_DEF__(x) x
-#endif
-
 #include "sys/types.h"
 #include "stddef.h"
@@ -51,45 +47,45 @@
 #define _exit exit
 
-extern char *__POSIX_DEF__(optarg);
+extern char *optarg;
 extern int optind, opterr, optopt;
-extern int __POSIX_DEF__(getopt)(int, char * const [], const char *);
+extern int getopt(int, char * const [], const char *);
 
 /* Environment */
-extern char **__POSIX_DEF__(environ);
+extern char **environ;
 
 /* Sleeping */
-extern unsigned int __POSIX_DEF__(sleep)(unsigned int);
+extern unsigned int sleep(unsigned int);
 
 /* Login Information */
-extern char *__POSIX_DEF__(getlogin)(void);
-extern int __POSIX_DEF__(getlogin_r)(char *name, size_t namesize);
+extern char *getlogin(void);
+extern int getlogin_r(char *name, size_t namesize);
 
 /* Identifying Terminals */
-extern int __POSIX_DEF__(isatty)(int fd);
+extern int isatty(int fd);
 
 /* Working Directory */
-extern char *__POSIX_DEF__(getcwd)(char *buf, size_t size);
-extern int __POSIX_DEF__(chdir)(const char *path);
+extern char *getcwd(char *buf, size_t size);
+extern int chdir(const char *path);
 
 /* Query Memory Parameters */
-extern int __POSIX_DEF__(getpagesize)(void);
+extern int getpagesize(void);
 
 /* Process Identification */
-extern __POSIX_DEF__(pid_t) __POSIX_DEF__(getpid)(void);
-extern __POSIX_DEF__(uid_t) __POSIX_DEF__(getuid)(void);
-extern __POSIX_DEF__(gid_t) __POSIX_DEF__(getgid)(void);
+extern pid_t getpid(void);
+extern uid_t getuid(void);
+extern gid_t getgid(void);
 
 /* File Manipulation */
-extern int __POSIX_DEF__(close)(int fildes);
-extern ssize_t __POSIX_DEF__(read)(int fildes, void *buf, size_t nbyte);
-extern ssize_t __POSIX_DEF__(write)(int fildes, const void *buf, size_t nbyte);
-extern __POSIX_DEF__(off_t) __POSIX_DEF__(lseek)(int fildes,
-    __POSIX_DEF__(off_t) offset, int whence);
-extern int __POSIX_DEF__(fsync)(int fildes);
-extern int __POSIX_DEF__(ftruncate)(int fildes, __POSIX_DEF__(off_t) length);
-extern int __POSIX_DEF__(rmdir)(const char *path);
-extern int __POSIX_DEF__(unlink)(const char *path);
-extern int __POSIX_DEF__(dup)(int fildes);
-extern int __POSIX_DEF__(dup2)(int fildes, int fildes2);
+extern int close(int fildes);
+extern ssize_t read(int fildes, void *buf, size_t nbyte);
+extern ssize_t write(int fildes, const void *buf, size_t nbyte);
+extern off_t lseek(int fildes,
+    off_t offset, int whence);
+extern int fsync(int fildes);
+extern int ftruncate(int fildes, off_t length);
+extern int rmdir(const char *path);
+extern int unlink(const char *path);
+extern int dup(int fildes);
+extern int dup2(int fildes, int fildes2);
 
 /* Standard Streams */
@@ -110,5 +106,5 @@
 #define	W_OK 2 /* Test for write permission. */
 #define	R_OK 4 /* Test for read permission. */
-extern int __POSIX_DEF__(access)(const char *path, int amode);
+extern int access(const char *path, int amode);
 
 /* System Parameters */
@@ -119,5 +115,5 @@
 	_SC_CLK_TCK
 };
-extern long __POSIX_DEF__(sysconf)(int name);
+extern long sysconf(int name);
 
 /* Path Configuration Parameters */
@@ -143,18 +139,18 @@
 	_PC_VDISABLE
 };
-extern long __POSIX_DEF__(pathconf)(const char *path, int name);
+extern long pathconf(const char *path, int name);
 
 /* Creating a Process */
-extern __POSIX_DEF__(pid_t) __POSIX_DEF__(fork)(void);
+extern pid_t fork(void);
 
 /* Executing a File */
-extern int __POSIX_DEF__(execv)(const char *path, char *const argv[]);
-extern int __POSIX_DEF__(execvp)(const char *file, char *const argv[]);
+extern int execv(const char *path, char *const argv[]);
+extern int execvp(const char *file, char *const argv[]);
 
 /* Creating a Pipe */
-extern int __POSIX_DEF__(pipe)(int fildes[2]);
+extern int pipe(int fildes[2]);
 
 /* Issue alarm signal. */
-extern unsigned int __POSIX_DEF__(alarm)(unsigned int);
+extern unsigned int alarm(unsigned int);
 
 #endif /* POSIX_UNISTD_H_ */
Index: uspace/lib/posix/src/dlfcn.c
===================================================================
--- uspace/lib/posix/src/dlfcn.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/dlfcn.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -31,13 +31,11 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/dlfcn.h"
 
-#include "libc/dlfcn.h"
+_HIDE_LIBC_SYMBOL(dlopen)
+extern void *__helenos_libc_dlopen(const char *filename, int flags);
 
-void *posix_dlopen(const char *filename, int flags)
+void *dlopen(const char *filename, int flags)
 {
 	if (flags != 0) {
@@ -45,13 +43,8 @@
 	}
 	
-	return dlopen(filename, 0);
+	return __helenos_libc_dlopen(filename, 0);
 }
 
-void *posix_dlsym(void *handle, const char *symbol)
-{
-	return dlsym(handle, symbol);
-}
-
-int posix_dlclose(void *handle)
+int dlclose(void *handle)
 {
 	not_implemented();
@@ -59,5 +52,5 @@
 }
 
-char *posix_dlerror(void)
+char *dlerror(void)
 {
 	not_implemented();
Index: uspace/lib/posix/src/fcntl.c
===================================================================
--- uspace/lib/posix/src/fcntl.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/fcntl.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/fcntl.h"
@@ -51,5 +48,5 @@
  *     to the requested operation.
  */
-int posix_fcntl(int fd, int cmd, ...)
+int fcntl(int fd, int cmd, ...)
 {
 	int flags;
@@ -102,11 +99,11 @@
  * @param posix_flags Access mode flags.
  */
-int posix_open(const char *pathname, int posix_flags, ...)
+int open(const char *pathname, int posix_flags, ...)
 {
-	posix_mode_t posix_mode = 0;
+	mode_t posix_mode = 0;
 	if (posix_flags & O_CREAT) {
 		va_list args;
 		va_start(args, posix_flags);
-		posix_mode = va_arg(args, posix_mode_t);
+		posix_mode = va_arg(args, mode_t);
 		va_end(args);
 		(void) posix_mode;
Index: uspace/lib/posix/src/fnmatch.c
===================================================================
--- uspace/lib/posix/src/fnmatch.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/fnmatch.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -41,7 +41,4 @@
  * will be fairly straightforward.
  */
-
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
 
 #include "libc/stdbool.h"
@@ -205,5 +202,5 @@
 {
 	const struct _char_class *class = elem;
-	return posix_strcmp((const char *) key, class->name);
+	return strcmp((const char *) key, class->name);
 }
 
@@ -218,5 +215,5 @@
 {
 	/* Search for class in the array of supported character classes. */
-	const struct _char_class *class = posix_bsearch(cname, _char_classes,
+	const struct _char_class *class = bsearch(cname, _char_classes,
 	    sizeof(_char_classes) / sizeof(struct _char_class),
 	    sizeof(struct _char_class), _class_compare);
@@ -582,5 +579,5 @@
 {
 	assert(s != NULL);
-	char *result = posix_strdup(s);
+	char *result = strdup(s);
 	for (char *i = result; *i != '\0'; ++i) {
 		*i = tolower(*i);
@@ -598,5 +595,5 @@
  * @return Zero if the string matches the pattern, FNM_NOMATCH otherwise.
  */
-int posix_fnmatch(const char *pattern, const char *string, int flags)
+int fnmatch(const char *pattern, const char *string, int flags)
 {
 	assert(pattern != NULL);
@@ -637,6 +634,6 @@
 	#undef assert
 	#define assert(x) { if (x) printf("SUCCESS: "#x"\n"); else { printf("FAILED: "#x"\n"); fail++; } }
-	#define match(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == 0)
-	#define nomatch(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == FNM_NOMATCH)
+	#define match(s1, s2, flags) assert(fnmatch(s1, s2, flags) == 0)
+	#define nomatch(s1, s2, flags) assert(fnmatch(s1, s2, flags) == FNM_NOMATCH)
 
 	static_assert(FNM_PATHNAME == FNM_FILE_NAME);
Index: pace/lib/posix/src/getopt.c
===================================================================
--- uspace/lib/posix/src/getopt.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ 	(revision )
@@ -1,55 +1,0 @@
-/*
- * Copyright (c) 2012 Vojtech Horky
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * - Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * - Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- * - The name of the author may not be used to endorse or promote products
- *   derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** @addtogroup libposix
- * @{
- */
-/** @file Command line argument parsing.
- */
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
-#include "internal/common.h"
-#include "libc/getopt.h"
-#include "posix/getopt.h"
-
-
-int posix_getopt_long(int argc, char * const argv[],
-    const char *opt_string, const struct option *long_opts, int *long_index)
-{
-	int rc = getopt_long(argc, argv, opt_string, long_opts, long_index);
-	posix_optarg = (char *) optarg;
-	return rc;
-}
-
-int posix_getopt(int argc, char * const argv[], const char *opt_string)
-{
-	int rc = getopt(argc, argv, opt_string);
-	posix_optarg = (char *) optarg;
-	return rc;
-}
Index: uspace/lib/posix/src/internal/common.h
===================================================================
--- uspace/lib/posix/src/internal/common.h	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/internal/common.h	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -50,4 +50,7 @@
 	} while (0)
 
+// Just a marker for external tools.
+#define _HIDE_LIBC_SYMBOL(symbol)
+
 /* Checks if the value is a failing error code.
  * If so, writes the error code to errno and returns true.
Index: uspace/lib/posix/src/locale.c
===================================================================
--- uspace/lib/posix/src/locale.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/locale.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/locale.h"
@@ -54,5 +51,5 @@
 };
 
-const struct posix_lconv C_LOCALE = {
+const struct lconv C_LOCALE = {
 	.currency_symbol = (char *) "",
 	.decimal_point = (char *) ".",
@@ -88,9 +85,9 @@
  * @return Original locale name on success, NULL on failure.
  */
-char *posix_setlocale(int category, const char *locale)
+char *setlocale(int category, const char *locale)
 {
 	// TODO
 	if (locale == NULL || *locale == '\0' ||
-	    posix_strcmp(locale, "C") == 0) {
+	    strcmp(locale, "C") == 0) {
 		return (char *) "C";
 	}
@@ -103,8 +100,8 @@
  * @return Information about the current locale.
  */
-struct posix_lconv *posix_localeconv(void)
+struct lconv *localeconv(void)
 {
 	// TODO
-	return (struct posix_lconv *) &C_LOCALE;
+	return (struct lconv *) &C_LOCALE;
 }
 
@@ -115,5 +112,5 @@
  * @return Duplicated object.
  */
-posix_locale_t posix_duplocale(posix_locale_t locobj)
+locale_t duplocale(locale_t locobj)
 {
 	if (locobj == NULL) {
@@ -121,5 +118,5 @@
 		return NULL;
 	}
-	posix_locale_t copy = malloc(sizeof(struct __posix_locale));
+	locale_t copy = malloc(sizeof(struct __posix_locale));
 	if (copy == NULL) {
 		errno = ENOMEM;
@@ -135,5 +132,5 @@
  * @param locobj Object to free.
  */
-void posix_freelocale(posix_locale_t locobj)
+void freelocale(locale_t locobj)
 {
 	if (locobj) {
@@ -150,6 +147,6 @@
  * @return The new/modified locale object.
  */
-posix_locale_t posix_newlocale(int category_mask, const char *locale,
-    posix_locale_t base)
+locale_t newlocale(int category_mask, const char *locale,
+    locale_t base)
 {
 	if (locale == NULL ||
@@ -159,5 +156,5 @@
 	}
 	// TODO
-	posix_locale_t new = malloc(sizeof(struct __posix_locale));
+	locale_t new = malloc(sizeof(struct __posix_locale));
 	if (new == NULL) {
 		errno = ENOMEM;
@@ -165,5 +162,5 @@
 	}
 	if (base != NULL) {
-		posix_freelocale(base);
+		freelocale(base);
 	}
 	return new;
@@ -176,5 +173,5 @@
  * @return The previously set locale or LC_GLOBAL_LOCALE
  */
-posix_locale_t posix_uselocale(posix_locale_t newloc)
+locale_t uselocale(locale_t newloc)
 {
 	// TODO
Index: uspace/lib/posix/src/pthread/condvar.c
===================================================================
--- uspace/lib/posix/src/pthread/condvar.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/pthread/condvar.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "posix/pthread.h"
 #include "errno.h"
@@ -66,5 +63,5 @@
 
 int pthread_cond_timedwait(pthread_cond_t *restrict condvar,
-    pthread_mutex_t *restrict mutex, const struct __POSIX_DEF__(timespec) *restrict timeout)
+    pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout)
 {
 	not_implemented();
Index: uspace/lib/posix/src/pthread/keys.c
===================================================================
--- uspace/lib/posix/src/pthread/keys.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/pthread/keys.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "posix/stdlib.h"
 #include "posix/pthread.h"
Index: uspace/lib/posix/src/pthread/mutex.c
===================================================================
--- uspace/lib/posix/src/pthread/mutex.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/pthread/mutex.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -32,7 +32,4 @@
 /** @file Pthread: mutexes.
  */
-
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
 
 #include "posix/pthread.h"
Index: uspace/lib/posix/src/pthread/threads.c
===================================================================
--- uspace/lib/posix/src/pthread/threads.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/pthread/threads.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -32,7 +32,4 @@
 /** @file Pthread: thread management.
  */
-
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
 
 #include "posix/pthread.h"
Index: uspace/lib/posix/src/pwd.c
===================================================================
--- uspace/lib/posix/src/pwd.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/pwd.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "libc/stdbool.h"
 #include "posix/pwd.h"
@@ -45,5 +42,5 @@
 
 /* dummy user account */
-static const struct posix_passwd dummy_pwd = {
+static const struct passwd dummy_pwd = {
 	.pw_name = (char *) "user",
 	.pw_uid = 0,
@@ -62,5 +59,5 @@
  *     doesn't have user accounts, this always returns the same made-up entry.
  */
-struct posix_passwd *posix_getpwent(void)
+struct passwd *getpwent(void)
 {
 	if (entry_read) {
@@ -69,5 +66,5 @@
 
 	entry_read = true;
-	return (struct posix_passwd *) &dummy_pwd;
+	return (struct passwd *) &dummy_pwd;
 }
 
@@ -75,5 +72,5 @@
  * Rewind the user list.
  */
-void posix_setpwent(void)
+void setpwent(void)
 {
 	entry_read = false;
@@ -83,5 +80,5 @@
  * Ends enumerating and releases all resources. (Noop)
  */
-void posix_endpwent(void)
+void endpwent(void)
 {
 	/* noop */
@@ -94,13 +91,13 @@
  * @return Either found entry or NULL if no such entry exists.
  */
-struct posix_passwd *posix_getpwnam(const char *name)
+struct passwd *getpwnam(const char *name)
 {
 	assert(name != NULL);
 
-	if (posix_strcmp(name, "user") != 0) {
+	if (strcmp(name, "user") != 0) {
 		return NULL;
 	}
 
-	return (struct posix_passwd *) &dummy_pwd;
+	return (struct passwd *) &dummy_pwd;
 }
 
@@ -116,6 +113,6 @@
  *     non-zero error number if error occured.
  */
-int posix_getpwnam_r(const char *name, struct posix_passwd *pwd,
-    char *buffer, size_t bufsize, struct posix_passwd **result)
+int getpwnam_r(const char *name, struct passwd *pwd,
+    char *buffer, size_t bufsize, struct passwd **result)
 {
 	assert(name != NULL);
@@ -124,10 +121,10 @@
 	assert(result != NULL);
 	
-	if (posix_strcmp(name, "user") != 0) {
+	if (strcmp(name, "user") != 0) {
 		*result = NULL;
 		return 0;
 	}
 	
-	return posix_getpwuid_r(0, pwd, buffer, bufsize, result);
+	return getpwuid_r(0, pwd, buffer, bufsize, result);
 }
 
@@ -138,5 +135,5 @@
  * @return Either found entry or NULL if no such entry exists.
  */
-struct posix_passwd *posix_getpwuid(posix_uid_t uid)
+struct passwd *getpwuid(uid_t uid)
 {
 	if (uid != 0) {
@@ -144,5 +141,5 @@
 	}
 
-	return (struct posix_passwd *) &dummy_pwd;
+	return (struct passwd *) &dummy_pwd;
 }
 
@@ -158,6 +155,6 @@
  *     non-zero error number if error occured.
  */
-int posix_getpwuid_r(posix_uid_t uid, struct posix_passwd *pwd,
-    char *buffer, size_t bufsize, struct posix_passwd **result)
+int getpwuid_r(uid_t uid, struct passwd *pwd,
+    char *buffer, size_t bufsize, struct passwd **result)
 {
 	assert(pwd != NULL);
@@ -184,5 +181,5 @@
 	pwd->pw_dir = (char *) bf + 5;
 	pwd->pw_shell = (char *) bf + 7;
-	*result = (struct posix_passwd *) pwd;
+	*result = (struct passwd *) pwd;
 
 	return 0;
Index: uspace/lib/posix/src/signal.c
===================================================================
--- uspace/lib/posix/src/signal.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/signal.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "posix/signal.h"
 #include "internal/common.h"
@@ -61,5 +58,5 @@
 static LIST_INITIALIZE(_signal_queue);
 
-static posix_sigset_t _signal_mask = 0;
+static sigset_t _signal_mask = 0;
 
 #define DEFAULT_HANDLER { .sa_handler = SIG_DFL, \
@@ -67,5 +64,5 @@
 
 /* Actions associated with each signal number. */
-static struct posix_sigaction _signal_actions[_TOP_SIGNAL + 1] = {
+static struct sigaction _signal_actions[_TOP_SIGNAL + 1] = {
 	DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, 
 	DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, 
@@ -111,5 +108,5 @@
 	case SIGILL:
 	case SIGSEGV:
-		posix_psignal(signo, "Hardware exception raised by user code");
+		psignal(signo, "Hardware exception raised by user code");
 		abort();
 	case SIGSYS:
@@ -124,5 +121,5 @@
 	case SIGTTIN:
 	case SIGTTOU:
-		posix_psignal(signo, "Unsupported signal caught");
+		psignal(signo, "Unsupported signal caught");
 		abort();
 	case SIGCHLD:
@@ -164,5 +161,5 @@
  * @return Always returns zero.
  */
-int posix_sigemptyset(posix_sigset_t *set)
+int sigemptyset(sigset_t *set)
 {
 	assert(set != NULL);
@@ -178,5 +175,5 @@
  * @return Always returns zero.
  */
-int posix_sigfillset(posix_sigset_t *set)
+int sigfillset(sigset_t *set)
 {
 	assert(set != NULL);
@@ -193,5 +190,5 @@
  * @return Always returns zero.
  */
-int posix_sigaddset(posix_sigset_t *set, int signo)
+int sigaddset(sigset_t *set, int signo)
 {
 	assert(set != NULL);
@@ -208,5 +205,5 @@
  * @return Always returns zero.
  */
-int posix_sigdelset(posix_sigset_t *set, int signo)
+int sigdelset(sigset_t *set, int signo)
 {
 	assert(set != NULL);
@@ -223,5 +220,5 @@
  * @return 1 if the signal is in the set, 0 otherwise.
  */
-int posix_sigismember(const posix_sigset_t *set, int signo)
+int sigismember(const sigset_t *set, int signo)
 {
 	assert(set != NULL);
@@ -239,15 +236,15 @@
  * @param oact
  */
-static void _sigaction_unsafe(int sig, const struct posix_sigaction *restrict act,
-    struct posix_sigaction *restrict oact)
+static void _sigaction_unsafe(int sig, const struct sigaction *restrict act,
+    struct sigaction *restrict oact)
 {
 	if (oact != NULL) {
 		memcpy(oact, &_signal_actions[sig],
-		    sizeof(struct posix_sigaction));
+		    sizeof(struct sigaction));
 	}
 
 	if (act != NULL) {
 		memcpy(&_signal_actions[sig], act,
-		    sizeof(struct posix_sigaction));
+		    sizeof(struct sigaction));
 	}
 }
@@ -263,6 +260,6 @@
  * @return -1 with errno set on failure, 0 on success.
  */
-int posix_sigaction(int sig, const struct posix_sigaction *restrict act,
-    struct posix_sigaction *restrict oact)
+int sigaction(int sig, const struct sigaction *restrict act,
+    struct sigaction *restrict oact)
 {
 	if (sig > _TOP_SIGNAL || (act != NULL &&
@@ -273,5 +270,5 @@
 
 	if (sig > _TOP_CATCHABLE_SIGNAL) {
-		posix_psignal(sig,
+		psignal(sig,
 		    "WARNING: registering handler for a partially"
 		    " or fully unsupported signal. This handler may only be"
@@ -294,7 +291,7 @@
  * @return SIG_ERR on failure, original handler on success.
  */
-void (*posix_signal(int sig, void (*func)(int)))(int)
-{
-	struct posix_sigaction new = {
+void (*signal(int sig, void (*func)(int)))(int)
+{
+	struct sigaction new = {
 		.sa_handler = func,
 		.sa_mask = 0,
@@ -302,6 +299,6 @@
 		.sa_sigaction = NULL
 	};
-	struct posix_sigaction old;
-	if (posix_sigaction(sig, func == NULL ? NULL : &new, &old) == 0) {
+	struct sigaction old;
+	if (sigaction(sig, func == NULL ? NULL : &new, &old) == 0) {
 		return old.sa_handler;
 	} else {
@@ -313,5 +310,5 @@
 	link_t link;
 	int signo;
-	posix_siginfo_t siginfo;
+	siginfo_t siginfo;
 } signal_queue_item;
 
@@ -322,5 +319,5 @@
  * @param siginfo Additional information about the signal.
  */
-static void _queue_signal(int signo, posix_siginfo_t *siginfo)
+static void _queue_signal(int signo, siginfo_t *siginfo)
 {
 	assert(signo >= 0 && signo <= _TOP_SIGNAL);
@@ -330,5 +327,5 @@
 	link_initialize(&(item->link));
 	item->signo = signo;
-	memcpy(&item->siginfo, siginfo, sizeof(posix_siginfo_t));
+	memcpy(&item->siginfo, siginfo, sizeof(siginfo_t));
 	list_append(&(item->link), &_signal_queue);
 }
@@ -343,5 +340,5 @@
  *     blocked.
  */
-static int _raise_sigaction(int signo, posix_siginfo_t *siginfo)
+static int _raise_sigaction(int signo, siginfo_t *siginfo)
 {
 	assert(signo >= 0 && signo <= _TOP_SIGNAL);
@@ -350,7 +347,7 @@
 	fibril_mutex_lock(&_signal_mutex);
 
-	struct posix_sigaction action = _signal_actions[signo];
-
-	if (posix_sigismember(&_signal_mask, signo) ||
+	struct sigaction action = _signal_actions[signo];
+
+	if (sigismember(&_signal_mask, signo) ||
 	    action.sa_handler == SIG_HOLD) {
 		_queue_signal(signo, siginfo);
@@ -364,5 +361,5 @@
 
 	if ((action.sa_flags & SA_RESETHAND) && signo != SIGILL && signo != SIGTRAP) {
-		_signal_actions[signo] = (struct posix_sigaction) DEFAULT_HANDLER;
+		_signal_actions[signo] = (struct sigaction) DEFAULT_HANDLER;
 	}
 
@@ -394,5 +391,5 @@
 		    list_get_instance(iterator, signal_queue_item, link);
 		
-		if (!posix_sigismember(&_signal_mask, item->signo) &&
+		if (!sigismember(&_signal_mask, item->signo) &&
 		    _signal_actions[item->signo].sa_handler != SIG_HOLD) {
 			list_remove(&(item->link));
@@ -411,8 +408,8 @@
  * @return -1 with errno set on failure, 0 on success.
  */
-int posix_raise(int sig)
+int raise(int sig)
 {
 	if (sig >= 0 && sig <= _TOP_SIGNAL) {
-		posix_siginfo_t siginfo = {
+		siginfo_t siginfo = {
 			.si_signo = sig,
 			.si_code = SI_USER
@@ -433,5 +430,5 @@
  *     action, invalid signal number, lack of permissions, etc.), 0 on success.
  */
-int posix_kill(posix_pid_t pid, int signo)
+int kill(pid_t pid, int signo)
 {
 	if (pid < 1) {
@@ -446,6 +443,6 @@
 	}
 
-	if (pid == (posix_pid_t) task_get_id()) {
-		return posix_raise(signo);
+	if (pid == (pid_t) task_get_id()) {
+		return raise(signo);
 	}
 
@@ -471,8 +468,8 @@
  * @return -1 on failure, 0 on success (see kill()).
  */
-int posix_killpg(posix_pid_t pid, int sig)
+int killpg(pid_t pid, int sig)
 {
 	assert(pid > 1);
-	return posix_kill(-pid, sig);
+	return kill(-pid, sig);
 }
 
@@ -483,8 +480,8 @@
  * @param message String to output alongside human-readable signal description.
  */
-void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message)
+void psiginfo(const siginfo_t *pinfo, const char *message)
 {
 	assert(pinfo != NULL);
-	posix_psignal(pinfo->si_signo, message);
+	psignal(pinfo->si_signo, message);
 	// TODO: print si_code
 }
@@ -496,7 +493,7 @@
  * @param message String to output alongside human-readable signal description.
  */
-void posix_psignal(int signum, const char *message)
-{
-	char *sigmsg = posix_strsignal(signum);
+void psignal(int signum, const char *message)
+{
+	char *sigmsg = strsignal(signum);
 	if (message == NULL || *message == '\0') {
 		fprintf(stderr, "%s\n", sigmsg);
@@ -514,6 +511,6 @@
  * @return 0 success, errorcode on failure.
  */
-int posix_thread_sigmask(int how, const posix_sigset_t *restrict set,
-    posix_sigset_t *restrict oset)
+int thread_sigmask(int how, const sigset_t *restrict set,
+    sigset_t *restrict oset)
 {
 	fibril_mutex_lock(&_signal_mutex);
@@ -554,8 +551,8 @@
  * @return 0 on success, -1 with errno set on failure.
  */
-int posix_sigprocmask(int how, const posix_sigset_t *restrict set,
-    posix_sigset_t *restrict oset)
-{
-	int result = posix_thread_sigmask(how, set, oset);
+int sigprocmask(int how, const sigset_t *restrict set,
+    sigset_t *restrict oset)
+{
+	int result = thread_sigmask(how, set, oset);
 	if (result != 0) {
 		errno = result;
Index: uspace/lib/posix/src/stdio.c
===================================================================
--- uspace/lib/posix/src/stdio.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/stdio.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/stdio.h"
@@ -55,13 +52,4 @@
 #include "libc/adt/list.h"
 
-/** Clears the stream's error and end-of-file indicators.
- *
- * @param stream Stream whose indicators shall be cleared.
- */
-void posix_clearerr(FILE *stream)
-{
-	clearerr(stream);
-}
-
 /**
  * Generate a pathname for the controlling terminal.
@@ -70,5 +58,5 @@
  * @return Either s or static location filled with the requested pathname.
  */
-char *posix_ctermid(char *s)
+char *ctermid(char *s)
 {
 	/* Currently always returns an error value (empty string). */
@@ -83,28 +71,4 @@
 	s[0] = '\0';
 	return s;
-}
-
-/**
- * Put a string on the stream.
- * 
- * @param s String to be written.
- * @param stream Output stream.
- * @return Non-negative on success, EOF on failure.
- */
-int posix_fputs(const char *restrict s, FILE *restrict stream)
-{
-	return fputs(s, stream);
-}
-
-/**
- * Push byte back into input stream.
- * 
- * @param c Byte to be pushed back.
- * @param stream Stream to where the byte shall be pushed.
- * @return Provided byte on success or EOF if not possible.
- */
-int posix_ungetc(int c, FILE *stream)
-{
-	return ungetc(c, stream);
 }
 
@@ -122,5 +86,5 @@
  *     or -1 on error (set in errno).
  */
-ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n,
+ssize_t getdelim(char **restrict lineptr, size_t *restrict n,
     int delimiter, FILE *restrict stream)
 {
@@ -194,25 +158,8 @@
  *     or -1 on error (set in errno).
  */
-ssize_t posix_getline(char **restrict lineptr, size_t *restrict n,
+ssize_t getline(char **restrict lineptr, size_t *restrict n,
     FILE *restrict stream)
 {
-	return posix_getdelim(lineptr, n, '\n', stream);
-}
-
-/**
- * Reopen a file stream.
- * 
- * @param filename Pathname of a file to be reopened or NULL for changing
- *     the mode of the stream.
- * @param mode Mode to be used for reopening the file or changing current
- *     mode of the stream.
- * @param stream Current stream associated with the opened file.
- * @return On success, either a stream of the reopened file or the provided
- *     stream with a changed mode. NULL otherwise.
- */
-FILE *posix_freopen(const char *restrict filename, 
-    const char *restrict mode, FILE *restrict stream)
-{
-	return freopen(filename, mode, stream);
+	return getdelim(lineptr, n, '\n', stream);
 }
 
@@ -222,10 +169,10 @@
  * @param s Error message.
  */
-void posix_perror(const char *s)
+void perror(const char *s)
 {
 	if (s == NULL || s[0] == '\0') {
-		fprintf(stderr, "%s\n", posix_strerror(errno));
+		fprintf(stderr, "%s\n", strerror(errno));
 	} else {
-		fprintf(stderr, "%s: %s\n", s, posix_strerror(errno));
+		fprintf(stderr, "%s: %s\n", s, strerror(errno));
 	}
 }
@@ -237,5 +184,5 @@
  * @return Zero on success, non-zero (with errno set) on failure
  */
-int posix_fsetpos(FILE *stream, const posix_fpos_t *pos)
+int fsetpos(FILE *stream, const fpos_t *pos)
 {
 	return fseek64(stream, pos->offset, SEEK_SET);
@@ -248,5 +195,5 @@
  * @return Zero on success, non-zero (with errno set) on failure
  */
-int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos)
+int fgetpos(FILE *restrict stream, fpos_t *restrict pos)
 {
 	off64_t ret = ftell64(stream);
@@ -267,18 +214,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_fseek(FILE *stream, long offset, int whence)
-{
-	return fseek(stream, offset, whence);
-}
-
-/**
- * Reposition a file-position indicator in a stream.
- * 
- * @param stream Stream to seek in.
- * @param offset Direction and amount of bytes to seek.
- * @param whence From where to seek.
- * @return Zero on success, -1 otherwise.
- */
-int posix_fseeko(FILE *stream, posix_off_t offset, int whence)
+int fseeko(FILE *stream, off_t offset, int whence)
 {
 	return fseek64(stream, offset, whence);
@@ -291,16 +225,5 @@
  * @return Current offset or -1 if not possible.
  */
-long posix_ftell(FILE *stream)
-{
-	return ftell(stream);
-}
-
-/**
- * Discover current file offset in a stream.
- * 
- * @param stream Stream for which the offset shall be retrieved.
- * @return Current offset or -1 if not possible.
- */
-posix_off_t posix_ftello(FILE *stream)
+off_t ftello(FILE *stream)
 {
 	return ftell64(stream);
@@ -308,15 +231,4 @@
 
 /**
- * Discard prefetched data or write unwritten data.
- * 
- * @param stream Stream that shall be flushed.
- * @return Zero on success, EOF on failure.
- */
-int posix_fflush(FILE *stream)
-{
-	return fflush(stream);
-}
-
-/**
  * Print formatted output to the opened file.
  *
@@ -325,9 +237,9 @@
  * @return Either the number of printed characters or negative value on error.
  */
-int posix_dprintf(int fildes, const char *restrict format, ...)
+int dprintf(int fildes, const char *restrict format, ...)
 {
 	va_list list;
 	va_start(list, format);
-	int result = posix_vdprintf(fildes, format, list);
+	int result = vdprintf(fildes, format, list);
 	va_end(list);
 	return result;
@@ -392,5 +304,5 @@
  * @return Either the number of printed characters or negative value on error.
  */
-int posix_vdprintf(int fildes, const char *restrict format, va_list ap)
+int vdprintf(int fildes, const char *restrict format, va_list ap)
 {
 	printf_spec_t spec = {
@@ -411,9 +323,9 @@
  *     negative value on error.
  */
-int posix_sprintf(char *s, const char *restrict format, ...)
+int sprintf(char *s, const char *restrict format, ...)
 {
 	va_list list;
 	va_start(list, format);
-	int result = posix_vsprintf(s, format, list);
+	int result = vsprintf(s, format, list);
 	va_end(list);
 	return result;
@@ -429,5 +341,5 @@
  *     negative value on error.
  */
-int posix_vsprintf(char *s, const char *restrict format, va_list ap)
+int vsprintf(char *s, const char *restrict format, va_list ap)
 {
 	return vsnprintf(s, STR_NO_LIMIT, format, ap);
@@ -441,9 +353,9 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_fscanf(FILE *restrict stream, const char *restrict format, ...)
+int fscanf(FILE *restrict stream, const char *restrict format, ...)
 {
 	va_list list;
 	va_start(list, format);
-	int result = posix_vfscanf(stream, format, list);
+	int result = vfscanf(stream, format, list);
 	va_end(list);
 	return result;
@@ -456,9 +368,9 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_scanf(const char *restrict format, ...)
+int scanf(const char *restrict format, ...)
 {
 	va_list list;
 	va_start(list, format);
-	int result = posix_vscanf(format, list);
+	int result = vscanf(format, list);
 	va_end(list);
 	return result;
@@ -472,7 +384,7 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_vscanf(const char *restrict format, va_list arg)
-{
-	return posix_vfscanf(stdin, format, arg);
+int vscanf(const char *restrict format, va_list arg)
+{
+	return vfscanf(stdin, format, arg);
 }
 
@@ -484,9 +396,9 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_sscanf(const char *restrict s, const char *restrict format, ...)
+int sscanf(const char *restrict s, const char *restrict format, ...)
 {
 	va_list list;
 	va_start(list, format);
-	int result = posix_vsscanf(s, format, list);
+	int result = vsscanf(s, format, list);
 	va_end(list);
 	return result;
@@ -498,5 +410,5 @@
  * @param file File stream to lock.
  */
-void posix_flockfile(FILE *file)
+void flockfile(FILE *file)
 {
 	/* dummy */
@@ -509,5 +421,5 @@
  * @return Zero for success and non-zero if the lock cannot be acquired.
  */
-int posix_ftrylockfile(FILE *file)
+int ftrylockfile(FILE *file)
 {
 	/* dummy */
@@ -520,5 +432,5 @@
  * @param file File stream to unlock.
  */
-void posix_funlockfile(FILE *file)
+void funlockfile(FILE *file)
 {
 	/* dummy */
@@ -531,5 +443,5 @@
  * @return Either read byte or EOF.
  */
-int posix_getc_unlocked(FILE *stream)
+int getc_unlocked(FILE *stream)
 {
 	return getc(stream);
@@ -541,5 +453,5 @@
  * @return Either read byte or EOF.
  */
-int posix_getchar_unlocked(void)
+int getchar_unlocked(void)
 {
 	return getchar();
@@ -553,5 +465,5 @@
  * @return Either written byte or EOF.
  */
-int posix_putc_unlocked(int c, FILE *stream)
+int putc_unlocked(int c, FILE *stream)
 {
 	return putc(c, stream);
@@ -564,36 +476,7 @@
  * @return Either written byte or EOF.
  */
-int posix_putchar_unlocked(int c)
+int putchar_unlocked(int c)
 {
 	return putchar(c);
-}
-
-/**
- * Remove a file or directory.
- *
- * @param path Pathname of the file that shall be removed.
- * @return Zero on success, -1 (with errno set) otherwise.
- */
-int posix_remove(const char *path)
-{
-	if (failed(vfs_unlink_path(path)))
-		return -1;
-	else
-		return 0;
-}
-
-/**
- * Rename a file or directory.
- *
- * @param old Old pathname.
- * @param new New pathname.
- * @return Zero on success, -1 (with errno set) otherwise.
- */
-int posix_rename(const char *old, const char *new)
-{
-	if (failed(vfs_rename_path(old, new)))
-		return -1;
-	else
-		return 0;
 }
 
@@ -604,7 +487,7 @@
  * @return The value of s on success, NULL on failure.
  */
-char *posix_tmpnam(char *s)
-{
-	assert(L_tmpnam >= posix_strlen("/tmp/tnXXXXXX"));
+char *tmpnam(char *s)
+{
+	assert(L_tmpnam >= strlen("/tmp/tnXXXXXX"));
 	
 	static char buffer[L_tmpnam + 1];
@@ -613,6 +496,6 @@
 	}
 	
-	posix_strcpy(s, "/tmp/tnXXXXXX");
-	posix_mktemp(s);
+	strcpy(s, "/tmp/tnXXXXXX");
+	mktemp(s);
 	
 	if (*s == '\0') {
@@ -631,15 +514,15 @@
  * @return Newly allocated unique path for temporary file. NULL on failure.
  */
-char *posix_tempnam(const char *dir, const char *pfx)
+char *tempnam(const char *dir, const char *pfx)
 {
 	/* Sequence number of the filename. */
 	static int seq = 0;
 	
-	size_t dir_len = posix_strlen(dir);
+	size_t dir_len = strlen(dir);
 	if (dir[dir_len - 1] == '/') {
 		dir_len--;
 	}
 	
-	size_t pfx_len = posix_strlen(pfx);
+	size_t pfx_len = strlen(pfx);
 	if (pfx_len > 5) {
 		pfx_len = 5;
@@ -655,7 +538,7 @@
 	
 	char *res_ptr = result;
-	posix_strncpy(res_ptr, dir, dir_len);
+	strncpy(res_ptr, dir, dir_len);
 	res_ptr += dir_len;
-	posix_strncpy(res_ptr, pfx, pfx_len);
+	strncpy(res_ptr, pfx, pfx_len);
 	res_ptr += pfx_len;
 	
@@ -666,5 +549,5 @@
 		errno = EOK;
 		/* Check if the file exists. */
-		if (posix_access(result, F_OK) == -1) {
+		if (access(result, F_OK) == -1) {
 			if (errno == ENOENT) {
 				errno = orig_errno;
@@ -694,8 +577,8 @@
  * @return Newly allocated unique path for temporary file. NULL on failure.
  */
-FILE *posix_tmpfile(void)
+FILE *tmpfile(void)
 {
 	char filename[] = "/tmp/tfXXXXXX";
-	int fd = posix_mkstemp(filename);
+	int fd = mkstemp(filename);
 	if (fd == -1) {
 		/* errno set by mkstemp(). */
@@ -704,5 +587,5 @@
 	
 	/* Unlink the created file, so that it's removed on close(). */
-	posix_unlink(filename);
+	unlink(filename);
 	return fdopen(fd, "w+");
 }
Index: uspace/lib/posix/src/stdio/scanf.c
===================================================================
--- uspace/lib/posix/src/stdio/scanf.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/stdio/scanf.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include <assert.h>
 
@@ -119,5 +116,5 @@
 	/* Initialize internal structures. */
 	self->consumed = 0;
-	ssize_t fetched = posix_getline(
+	ssize_t fetched = getline(
 	    &self->window, &self->window_size, self->source.stream);
 	if (fetched != -1) {
@@ -140,5 +137,5 @@
 	/* Initialize internal structures. */
 	self->consumed = 0;
-	self->fetched = posix_strlen(self->source.string);
+	self->fetched = strlen(self->source.string);
 	self->window = (char *) self->source.string;
 	self->window_size = self->fetched + 1;
@@ -158,5 +155,5 @@
 		/* Do we need to fetch a new line from the source? */
 		if (*self->cursor == '\0') {
-			ssize_t fetched = posix_getline(&self->window,
+			ssize_t fetched = getline(&self->window,
 			    &self->window_size, self->source.stream);
 			if (fetched != -1) {
@@ -208,11 +205,10 @@
 		 * containing newline, while at the same time newline is the character
 		 * that breaks the matching process. */
-		int rc = posix_fseek(
-		    self->source.stream, -1, SEEK_CUR);
+		int rc = fseek(self->source.stream, -1, SEEK_CUR);
 		if (rc == -1) {
 			/* Seek failed.  */
 			return 0;
 		}
-		ssize_t fetched = posix_getline(&self->window,
+		ssize_t fetched = getline(&self->window,
 		    &self->window_size, self->source.stream);
 		if (fetched != -1) {
@@ -266,5 +262,5 @@
 	if (*self->cursor == '\0') {
 		/* Window was completely consumed, fetch new data. */
-		ssize_t fetched = posix_getline(&self->window,
+		ssize_t fetched = getline(&self->window,
 		    &self->window_size, self->source.stream);
 		if (fetched != -1) {
@@ -298,5 +294,5 @@
 	/* Try to correct the difference between the stream position and what was
 	 * actually consumed. If it is not possible, continue anyway. */
-	posix_fseek(self->source.stream, self->consumed - self->fetched, SEEK_CUR);
+	fseek(self->source.stream, self->consumed - self->fetched, SEEK_CUR);
 
 	/* Destruct internal structures. */
@@ -638,5 +634,5 @@
 				 * than allowed by width. */
 				if (width != -1) {
-					cur_duplicated = posix_strndup(cur_borrowed, width);
+					cur_duplicated = strndup(cur_borrowed, width);
 					cur_limited = cur_duplicated;
 				} else {
@@ -812,5 +808,5 @@
 				 * than allowed by width. */
 				if (width != -1) {
-					cur_duplicated = posix_strndup(cur_borrowed, width);
+					cur_duplicated = strndup(cur_borrowed, width);
 					cur_limited = cur_duplicated;
 				} else {
@@ -826,11 +822,11 @@
 				switch (length_mod) {
 				case LMOD_NONE:
-					fres = posix_strtof(cur_limited, (char **) &cur_updated);
+					fres = strtof(cur_limited, (char **) &cur_updated);
 					break;
 				case LMOD_l:
-					dres = posix_strtod(cur_limited, (char **) &cur_updated);
+					dres = strtod(cur_limited, (char **) &cur_updated);
 					break;
 				case LMOD_L:
-					ldres = posix_strtold(cur_limited, (char **) &cur_updated);
+					ldres = strtold(cur_limited, (char **) &cur_updated);
 					break;
 				default:
@@ -1194,5 +1190,5 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_vfscanf(
+int vfscanf(
     FILE *restrict stream, const char *restrict format, va_list arg)
 {
@@ -1214,5 +1210,5 @@
  * @return The number of converted output items or EOF on failure.
  */
-int posix_vsscanf(
+int vsscanf(
     const char *restrict s, const char *restrict format, va_list arg)
 {
Index: uspace/lib/posix/src/stdlib.c
===================================================================
--- uspace/lib/posix/src/stdlib.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/stdlib.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/stdlib.h"
@@ -60,5 +57,5 @@
  * @param compare
  */
-int posix_atexit(void (*func)(void))
+int atexit(void (*func)(void))
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -73,5 +70,5 @@
  * @return Absolute value of the parameter.
  */
-int posix_abs(int i)
+int abs(int i)
 {
 	return i < 0 ? -i : i;
@@ -84,5 +81,5 @@
  * @return Absolute value of the parameter.
  */
-long posix_labs(long i)
+long labs(long i)
 {
 	return i < 0 ? -i : i;
@@ -95,5 +92,5 @@
  * @return Absolute value of the parameter.
  */
-long long posix_llabs(long long i)
+long long llabs(long long i)
 {
 	return i < 0 ? -i : i;
@@ -107,7 +104,7 @@
  * @return Quotient and remainder packed into structure.
  */
-posix_div_t posix_div(int numer, int denom)
-{
-	return (posix_div_t) { .quot = numer / denom, .rem = numer % denom };
+div_t div(int numer, int denom)
+{
+	return (div_t) { .quot = numer / denom, .rem = numer % denom };
 }
 
@@ -119,7 +116,7 @@
  * @return Quotient and remainder packed into structure.
  */
-posix_ldiv_t posix_ldiv(long numer, long denom)
-{
-	return (posix_ldiv_t) { .quot = numer / denom, .rem = numer % denom };
+ldiv_t ldiv(long numer, long denom)
+{
+	return (ldiv_t) { .quot = numer / denom, .rem = numer % denom };
 }
 
@@ -131,21 +128,7 @@
  * @return Quotient and remainder packed into structure.
  */
-posix_lldiv_t posix_lldiv(long long numer, long long denom)
-{
-	return (posix_lldiv_t) { .quot = numer / denom, .rem = numer % denom };
-}
-
-/**
- * Array sorting utilizing the quicksort algorithm.
- *
- * @param array Array of elements to sort.
- * @param count Number of elements in the array.
- * @param size Width of each element.
- * @param compare Decides relative ordering of two elements.
- */
-void posix_qsort(void *array, size_t count, size_t size,
-    int (*compare)(const void *, const void *))
-{
-	qsort(array, count, size, compare);
+lldiv_t lldiv(long long numer, long long denom)
+{
+	return (lldiv_t) { .quot = numer / denom, .rem = numer % denom };
 }
 
@@ -160,5 +143,5 @@
  * @return Pointer to a matching element, or NULL if none can be found.
  */
-void *posix_bsearch(const void *key, const void *base,
+void *bsearch(const void *key, const void *base,
     size_t nmemb, size_t size, int (*compar)(const void *, const void *))
 {
@@ -195,5 +178,5 @@
  * @return Value of the variable or NULL if such variable does not exist.
  */
-char *posix_getenv(const char *name)
+char *getenv(const char *name)
 {
 	return NULL;
@@ -206,5 +189,5 @@
  * @return
  */
-int posix_putenv(char *string)
+int putenv(char *string)
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -221,5 +204,5 @@
  *     or not (zero).
  */
-int posix_system(const char *string) {
+int system(const char *string) {
 	// TODO: does nothing at the moment
 	not_implemented();
@@ -237,5 +220,5 @@
  *
  */
-char *posix_realpath(const char *restrict name, char *restrict resolved)
+char *realpath(const char *restrict name, char *restrict resolved)
 {
 	#ifndef PATH_MAX
@@ -279,17 +262,17 @@
 /**
  * Converts a string representation of a floating-point number to
- * its native representation. See posix_strtold().
+ * its native representation. See strtold().
  *
  * @param nptr String representation of a floating-point number.
  * @return Double-precision number resulting from the string conversion.
  */
-double posix_atof(const char *nptr)
-{
-	return posix_strtod(nptr, NULL);
+double atof(const char *nptr)
+{
+	return strtod(nptr, NULL);
 }
 
 /**
  * Converts a string representation of a floating-point number to
- * its native representation. See posix_strtold().
+ * its native representation. See strtold().
  *
  * @param nptr String representation of a floating-point number.
@@ -298,12 +281,12 @@
  * @return Single-precision number resulting from the string conversion.
  */
-float posix_strtof(const char *restrict nptr, char **restrict endptr)
-{
-	return (float) posix_strtold(nptr, endptr);
+float strtof(const char *restrict nptr, char **restrict endptr)
+{
+	return (float) strtold(nptr, endptr);
 }
 
 /**
  * Converts a string representation of a floating-point number to
- * its native representation. See posix_strtold().
+ * its native representation. See strtold().
  *
  * @param nptr String representation of a floating-point number.
@@ -312,80 +295,7 @@
  * @return Double-precision number resulting from the string conversion.
  */
-double posix_strtod(const char *restrict nptr, char **restrict endptr)
-{
-	return (double) posix_strtold(nptr, endptr);
-}
-
-/**
- * Allocate memory chunk.
- *
- * @param size Size of the chunk to allocate.
- * @return Either pointer to the allocated chunk or NULL if not possible.
- */
-void *posix_malloc(size_t size)
-{
-	return malloc(size);
-}
-
-/**
- * Allocate memory for an array of elements.
- *
- * @param nelem Number of elements in the array.
- * @param elsize Size of each element.
- * @return Either pointer to the allocated array or NULL if not possible.
- */
-void *posix_calloc(size_t nelem, size_t elsize)
-{
-	return calloc(nelem, elsize);
-}
-
-/**
- * Reallocate memory chunk to a new size.
- *
- * @param ptr Memory chunk to reallocate. Might be NULL.
- * @param size Size of the reallocated chunk. Might be zero.
- * @return Either NULL or the pointer to the newly reallocated chunk.
- */
-void *posix_realloc(void *ptr, size_t size)
-{
-	if (ptr != NULL && size == 0) {
-		/* Native realloc does not handle this special case. */
-		free(ptr);
-		return NULL;
-	} else {
-		return realloc(ptr, size);
-	}
-}
-
-/**
- * Free allocated memory chunk.
- *
- * @param ptr Memory chunk to be freed.
- */
-void posix_free(void *ptr)
-{
-	if (ptr) {
-		free(ptr);
-	}
-}
-
-/**
- * Generate a pseudo random integer in the range 0 to RAND_MAX inclusive.
- *
- * @return The pseudo random integer.
- */
-int posix_rand(void)
-{
-	return (int) rand();
-}
-
-/**
- * Initialize a new sequence of pseudo-random integers.
- *
- * @param seed The seed of the new sequence.
- */
-void posix_srand(unsigned int seed)
-{
-	srand(seed);
+double strtod(const char *restrict nptr, char **restrict endptr)
+{
+	return (double) strtold(nptr, endptr);
 }
 
@@ -396,17 +306,17 @@
  * @return The opened file descriptor or -1 on error.
  */
-int posix_mkstemp(char *tmpl)
+int mkstemp(char *tmpl)
 {
 	int fd = -1;
 	
-	char *tptr = tmpl + posix_strlen(tmpl) - 6;
+	char *tptr = tmpl + strlen(tmpl) - 6;
 	
 	while (fd < 0) {
-		if (*posix_mktemp(tmpl) == '\0') {
+		if (*mktemp(tmpl) == '\0') {
 			/* Errno set by mktemp(). */
 			return -1;
 		}
 		
-		fd = posix_open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+		fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 		
 		if (fd == -1) {
@@ -427,7 +337,7 @@
  *    reduced to an empty string.
  */
-char *posix_mktemp(char *tmpl)
-{
-	int tmpl_len = posix_strlen(tmpl);
+char *mktemp(char *tmpl)
+{
+	int tmpl_len = strlen(tmpl);
 	if (tmpl_len < 6) {
 		errno = EINVAL;
@@ -437,5 +347,5 @@
 	
 	char *tptr = tmpl + tmpl_len - 6;
-	if (posix_strcmp(tptr, "XXXXXX") != 0) {
+	if (strcmp(tptr, "XXXXXX") != 0) {
 		errno = EINVAL;
 		*tmpl = '\0';
@@ -451,5 +361,5 @@
 		errno = 0;
 		/* Check if the file exists. */
-		if (posix_access(tmpl, F_OK) == -1) {
+		if (access(tmpl, F_OK) == -1) {
 			if (errno == ENOENT) {
 				errno = orig_errno;
Index: uspace/lib/posix/src/stdlib/strtold.c
===================================================================
--- uspace/lib/posix/src/stdlib/strtold.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/stdlib/strtold.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -32,7 +32,4 @@
 /** @file Backend for floating point conversions.
  */
-
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
 
 #include "../internal/common.h"
@@ -407,5 +404,5 @@
  * @return An approximate representation of the input floating-point number.
  */
-long double posix_strtold(const char *restrict nptr, char **restrict endptr)
+long double strtold(const char *restrict nptr, char **restrict endptr)
 {
 	assert(nptr != NULL);
@@ -433,5 +430,5 @@
 	
 	/* check for NaN */
-	if (posix_strncasecmp(&nptr[i], "nan", 3) == 0) {
+	if (strncasecmp(&nptr[i], "nan", 3) == 0) {
 		// FIXME: return NaN
 		// TODO: handle the parenthesised case
@@ -445,7 +442,7 @@
 	
 	/* check for Infinity */
-	if (posix_strncasecmp(&nptr[i], "inf", 3) == 0) {
+	if (strncasecmp(&nptr[i], "inf", 3) == 0) {
 		i += 3;
-		if (posix_strncasecmp(&nptr[i], "inity", 5) == 0) {
+		if (strncasecmp(&nptr[i], "inity", 5) == 0) {
 			i += 5;
 		}
Index: uspace/lib/posix/src/string.c
===================================================================
--- uspace/lib/posix/src/string.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/string.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/string.h"
@@ -62,5 +59,5 @@
 static char *strpbrk_null(const char *s1, const char *s2)
 {
-	while (!posix_strchr(s2, *s1)) {
+	while (!strchr(s2, *s1)) {
 		++s1;
 	}
@@ -76,7 +73,7 @@
  * @return Pointer to the destination buffer.
  */
-char *posix_strcpy(char *restrict dest, const char *restrict src)
-{
-	posix_stpcpy(dest, src);
+char *strcpy(char *restrict dest, const char *restrict src)
+{
+	stpcpy(dest, src);
 	return dest;
 }
@@ -90,7 +87,7 @@
  * @return Pointer to the destination buffer.
  */
-char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n)
-{
-	posix_stpncpy(dest, src, n);
+char *strncpy(char *restrict dest, const char *restrict src, size_t n)
+{
+	stpncpy(dest, src, n);
 	return dest;
 }
@@ -103,5 +100,5 @@
  * @return Pointer to the nul character in the destination string.
  */
-char *posix_stpcpy(char *restrict dest, const char *restrict src)
+char *stpcpy(char *restrict dest, const char *restrict src)
 {
 	assert(dest != NULL);
@@ -129,5 +126,5 @@
  * @return Pointer to the first written nul character or &dest[n].
  */
-char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n)
+char *stpncpy(char *restrict dest, const char *restrict src, size_t n)
 {
 	assert(dest != NULL);
@@ -159,10 +156,10 @@
  * @return Pointer to destination buffer.
  */
-char *posix_strcat(char *restrict dest, const char *restrict src)
+char *strcat(char *restrict dest, const char *restrict src)
 {
 	assert(dest != NULL);
 	assert(src != NULL);
 
-	posix_strcpy(posix_strchr(dest, '\0'), src);
+	strcpy(strchr(dest, '\0'), src);
 	return dest;
 }
@@ -176,10 +173,10 @@
  * @return Pointer to destination buffer.
  */
-char *posix_strncat(char *restrict dest, const char *restrict src, size_t n)
+char *strncat(char *restrict dest, const char *restrict src, size_t n)
 {
 	assert(dest != NULL);
 	assert(src != NULL);
 
-	char *zeroptr = posix_strncpy(posix_strchr(dest, '\0'), src, n);
+	char *zeroptr = strncpy(strchr(dest, '\0'), src, n);
 	/* strncpy doesn't append the nul terminator, so we do it here */
 	zeroptr[n] = '\0';
@@ -196,5 +193,5 @@
  * @return Pointer to the first byte after c in dest if found, NULL otherwise.
  */
-void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
+void *memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
 {
 	assert(dest != NULL);
@@ -222,7 +219,7 @@
  * @return Newly allocated copy of the string.
  */
-char *posix_strdup(const char *s)
-{
-	return posix_strndup(s, SIZE_MAX);
+char *strdup(const char *s)
+{
+	return strndup(s, SIZE_MAX);
 }
 
@@ -234,9 +231,9 @@
  * @return Newly allocated string copy of length at most n.
  */
-char *posix_strndup(const char *s, size_t n)
+char *strndup(const char *s, size_t n)
 {
 	assert(s != NULL);
 
-	size_t len = posix_strnlen(s, n);
+	size_t len = strnlen(s, n);
 	char *dup = malloc(len + 1);
 	if (dup == NULL) {
@@ -248,30 +245,4 @@
 
 	return dup;
-}
-
-/**
- * Compare bytes in memory.
- *
- * @param mem1 First area of memory to be compared.
- * @param mem2 Second area of memory to be compared.
- * @param n Maximum number of bytes to be compared.
- * @return Difference of the first pair of inequal bytes,
- *     or 0 if areas have the same content.
- */
-int posix_memcmp(const void *mem1, const void *mem2, size_t n)
-{
-	assert(mem1 != NULL);
-	assert(mem2 != NULL);
-
-	const unsigned char *s1 = mem1;
-	const unsigned char *s2 = mem2;
-	
-	for (size_t i = 0; i < n; ++i) {
-		if (s1[i] != s2[i]) {
-			return s1[i] - s2[i];
-		}
-	}
-	
-	return 0;
 }
 
@@ -284,10 +255,10 @@
  *     or 0 if strings have the same content.
  */
-int posix_strcmp(const char *s1, const char *s2)
+int strcmp(const char *s1, const char *s2)
 {
 	assert(s1 != NULL);
 	assert(s2 != NULL);
 
-	return posix_strncmp(s1, s2, STR_NO_LIMIT);
+	return strncmp(s1, s2, STR_NO_LIMIT);
 }
 
@@ -301,5 +272,5 @@
  *     or 0 if strings have the same content.
  */
-int posix_strncmp(const char *s1, const char *s2, size_t n)
+int strncmp(const char *s1, const char *s2, size_t n)
 {
 	assert(s1 != NULL);
@@ -327,5 +298,5 @@
  *     NULL pointer otherwise.
  */
-void *posix_memchr(const void *mem, int c, size_t n)
+void *memchr(const void *mem, int c, size_t n)
 {
 	assert(mem != NULL);
@@ -349,5 +320,5 @@
  *     NULL pointer otherwise.
  */
-char *posix_strchr(const char *s, int c)
+char *strchr(const char *s, int c)
 {
 	assert(s != NULL);
@@ -365,9 +336,9 @@
  *     NULL pointer otherwise.
  */
-char *posix_strrchr(const char *s, int c)
+char *strrchr(const char *s, int c)
 {
 	assert(s != NULL);
 	
-	const char *ptr = posix_strchr(s, '\0');
+	const char *ptr = strchr(s, '\0');
 	
 	/* the same as in strchr, except it loops in reverse direction */
@@ -410,5 +381,5 @@
  *     NULL pointer otherwise.
  */
-char *posix_strpbrk(const char *s1, const char *s2)
+char *strpbrk(const char *s1, const char *s2)
 {
 	assert(s1 != NULL);
@@ -426,5 +397,5 @@
  * @return Length of the prefix.
  */
-size_t posix_strcspn(const char *s1, const char *s2)
+size_t strcspn(const char *s1, const char *s2)
 {
 	assert(s1 != NULL);
@@ -442,5 +413,5 @@
  * @return Length of the prefix.
  */
-size_t posix_strspn(const char *s1, const char *s2)
+size_t strspn(const char *s1, const char *s2)
 {
 	assert(s1 != NULL);
@@ -449,5 +420,5 @@
 	const char *ptr;
 	for (ptr = s1; *ptr != '\0'; ++ptr) {
-		if (!posix_strchr(s2, *ptr)) {
+		if (!strchr(s2, *ptr)) {
 			break;
 		}
@@ -464,5 +435,5 @@
  *     not found.
  */
-char *posix_strstr(const char *haystack, const char *needle)
+char *strstr(const char *haystack, const char *needle)
 {
 	assert(haystack != NULL);
@@ -475,5 +446,5 @@
 	
 	/* Preprocess needle. */
-	size_t nlen = posix_strlen(needle);
+	size_t nlen = strlen(needle);
 	size_t prefix_table[nlen + 1];
 	
@@ -521,9 +492,9 @@
  *                      exists.
  */
-char *posix_strtok(char *s, const char *delim)
+char *strtok(char *s, const char *delim)
 {
 	static char *next;
 
-	return posix_strtok_r(s, delim, &next);
+	return strtok_r(s, delim, &next);
 }
 
@@ -541,5 +512,5 @@
  *                      exists.
  */
-char *posix_strtok_r(char *s, const char *delim, char **next)
+char *strtok_r(char *s, const char *delim, char **next)
 {
 	char *start, *end;
@@ -549,9 +520,9 @@
 
 	/* Skip over leading delimiters. */
-	while (*s && (posix_strchr(delim, *s) != NULL)) ++s;
+	while (*s && (strchr(delim, *s) != NULL)) ++s;
 	start = s;
 
 	/* Skip over token characters. */
-	while (*s && (posix_strchr(delim, *s) == NULL)) ++s;
+	while (*s && (strchr(delim, *s) == NULL)) ++s;
 	end = s;
 	*next = (*s ? s + 1 : s);
@@ -576,10 +547,10 @@
  *     or 0 if strings have the same content.
  */
-int posix_strcoll(const char *s1, const char *s2)
+int strcoll(const char *s1, const char *s2)
 {
 	assert(s1 != NULL);
 	assert(s2 != NULL);
 
-	return posix_strcmp(s1, s2);
+	return strcmp(s1, s2);
 }
 
@@ -596,13 +567,13 @@
  * @return Length of the transformed string.
  */
-size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n)
+size_t strxfrm(char *restrict s1, const char *restrict s2, size_t n)
 {
 	assert(s1 != NULL || n == 0);
 	assert(s2 != NULL);
 
-	size_t len = posix_strlen(s2);
+	size_t len = strlen(s2);
 
 	if (n > len) {
-		posix_strcpy(s1, s2);
+		strcpy(s1, s2);
 	}
 
@@ -616,5 +587,5 @@
  * @return Error message.
  */
-char *posix_strerror(int errnum)
+char *strerror(int errnum)
 {
 	// FIXME: move strerror() and strerror_r() to libc.
@@ -630,14 +601,14 @@
  * @return Zero on success, errno otherwise.
  */
-int posix_strerror_r(int errnum, char *buf, size_t bufsz)
+int strerror_r(int errnum, char *buf, size_t bufsz)
 {
 	assert(buf != NULL);
 	
-	char *errstr = posix_strerror(errnum);
-	
-	if (posix_strlen(errstr) + 1 > bufsz) {
+	char *errstr = strerror(errnum);
+	
+	if (strlen(errstr) + 1 > bufsz) {
 		return ERANGE;
 	} else {
-		posix_strcpy(buf, errstr);
+		strcpy(buf, errstr);
 	}
 
@@ -651,9 +622,9 @@
  * @return Length of the string.
  */
-size_t posix_strlen(const char *s)
+size_t strlen(const char *s)
 {
 	assert(s != NULL);
 	
-	return (size_t) (posix_strchr(s, '\0') - s);
+	return (size_t) (strchr(s, '\0') - s);
 }
 
@@ -665,5 +636,5 @@
  * @return The lower of either string length or n limit.
  */
-size_t posix_strnlen(const char *s, size_t n)
+size_t strnlen(const char *s, size_t n)
 {
 	assert(s != NULL);
@@ -685,5 +656,5 @@
  * @return Human readable signal description.
  */
-char *posix_strsignal(int signum)
+char *strsignal(int signum)
 {
 	static const char *const sigstrings[] = {
Index: uspace/lib/posix/src/strings.c
===================================================================
--- uspace/lib/posix/src/strings.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/strings.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/strings.h"
@@ -52,5 +49,5 @@
  * @return Index of first set bit. Bits are numbered starting at one.
  */
-int posix_ffs(int i)
+int ffs(int i)
 {
 	if (i == 0) {
@@ -92,7 +89,7 @@
  *     or 0 if strings have the same content.
  */
-int posix_strcasecmp(const char *s1, const char *s2)
+int strcasecmp(const char *s1, const char *s2)
 {
-	return posix_strncasecmp(s1, s2, STR_NO_LIMIT);
+	return strncasecmp(s1, s2, STR_NO_LIMIT);
 }
 
@@ -106,5 +103,5 @@
  *     or 0 if strings have the same content.
  */
-int posix_strncasecmp(const char *s1, const char *s2, size_t n)
+int strncasecmp(const char *s1, const char *s2, size_t n)
 {
 	for (size_t i = 0; i < n; ++i) {
@@ -131,5 +128,5 @@
  *     zero. Otherwise return non-zero.
  */
-int posix_bcmp(const void *mem1, const void *mem2, size_t n)
+int bcmp(const void *mem1, const void *mem2, size_t n)
 {
 	return memcmp(mem1, mem2, n);
@@ -143,5 +140,5 @@
  * @param n Number of bytes to copy.
  */
-void posix_bcopy(const void *src, void *dest, size_t n)
+void bcopy(const void *src, void *dest, size_t n)
 {
 	/* Note that memmove has different order of arguments. */
@@ -155,5 +152,5 @@
  * @param n Number of bytes to reset.
  */
-void posix_bzero(void *mem, size_t n)
+void bzero(void *mem, size_t n)
 {
 	memset(mem, 0, n);
@@ -168,7 +165,7 @@
  *     NULL pointer otherwise.
  */
-char *posix_index(const char *s, int c)
+char *index(const char *s, int c)
 {
-	return posix_strchr(s, c);
+	return strchr(s, c);
 }
 
@@ -181,7 +178,7 @@
  *     NULL pointer otherwise.
  */
-char *posix_rindex(const char *s, int c)
+char *rindex(const char *s, int c)
 {
-	return posix_strrchr(s, c);
+	return strrchr(s, c);
 }
 
Index: uspace/lib/posix/src/sys/mman.c
===================================================================
--- uspace/lib/posix/src/sys/mman.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/sys/mman.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "../internal/common.h"
 #include <posix/sys/mman.h>
@@ -42,6 +39,6 @@
 #include <posix/unistd.h>
 
-void *posix_mmap(void *start, size_t length, int prot, int flags, int fd,
-    __POSIX_DEF__(off_t) offset)
+void *mmap(void *start, size_t length, int prot, int flags, int fd,
+    off_t offset)
 {
 	if (!start)
@@ -57,5 +54,5 @@
 }
 
-int posix_munmap(void *start, size_t length)
+int munmap(void *start, size_t length)
 {
 	int rc = as_area_destroy(start);
Index: uspace/lib/posix/src/sys/stat.c
===================================================================
--- uspace/lib/posix/src/sys/stat.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/sys/stat.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "../internal/common.h"
 #include "posix/sys/stat.h"
@@ -52,7 +49,7 @@
  * @return 0 on success, -1 on error.
  */
-static int stat_to_posix(struct posix_stat *dest, vfs_stat_t *src)
+static int stat_to_posix(struct stat *dest, vfs_stat_t *src)
 {
-	memset(dest, 0, sizeof(struct posix_stat));
+	memset(dest, 0, sizeof(struct stat));
 	
 	dest->st_dev = src->service;
@@ -86,5 +83,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_fstat(int fd, struct posix_stat *st)
+int fstat(int fd, struct stat *st)
 {
 	vfs_stat_t hst;
@@ -101,8 +98,8 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_lstat(const char *restrict path, struct posix_stat *restrict st)
+int lstat(const char *restrict path, struct stat *restrict st)
 {
 	/* There are currently no symbolic links in HelenOS. */
-	return posix_stat(path, st);
+	return stat(path, st);
 }
 
@@ -114,5 +111,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_stat(const char *restrict path, struct posix_stat *restrict st)
+int stat(const char *restrict path, struct stat *restrict st)
 {
 	vfs_stat_t hst;
@@ -129,5 +126,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_chmod(const char *path, posix_mode_t mode)
+int chmod(const char *path, mode_t mode)
 {
 	/* HelenOS doesn't support permissions, return success. */
@@ -142,5 +139,5 @@
  * @return Previous file mode creation mask.
  */
-posix_mode_t posix_umask(posix_mode_t mask)
+mode_t umask(mode_t mask)
 {
 	/* HelenOS doesn't support permissions, return empty mask. */
@@ -155,5 +152,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_mkdir(const char *path, posix_mode_t mode)
+int mkdir(const char *path, mode_t mode)
 {
 	if (failed(vfs_link_path(path, KIND_DIRECTORY, NULL)))
Index: uspace/lib/posix/src/sys/wait.c
===================================================================
--- uspace/lib/posix/src/sys/wait.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/sys/wait.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -33,7 +33,4 @@
 /** @file Support for waiting.
  */
-
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
 
 #include "../internal/common.h"
@@ -76,9 +73,9 @@
  *     -1 on signal interrupt, (pid_t)-1 otherwise.
  */
-posix_pid_t posix_wait(int *stat_ptr)
+pid_t wait(int *stat_ptr)
 {
 	/* HelenOS does not support this. */
 	errno = ENOSYS;
-	return (posix_pid_t) -1;
+	return (pid_t) -1;
 }
 
@@ -94,5 +91,5 @@
  *     no child process whose status can be reported, (pid_t)-1 otherwise.
  */
-posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options)
+pid_t waitpid(pid_t pid, int *stat_ptr, int options)
 {
 	assert(stat_ptr != NULL);
@@ -104,5 +101,5 @@
 	if (failed(task_wait_task_id((task_id_t) pid, &texit, &retval))) {
 		/* Unable to retrieve status. */
-		return (posix_pid_t) -1;
+		return (pid_t) -1;
 	}
 	
Index: uspace/lib/posix/src/time.c
===================================================================
--- uspace/lib/posix/src/time.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/time.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/time.h"
@@ -70,5 +67,5 @@
  * Set timezone conversion information.
  */
-void posix_tzset(void)
+void tzset(void)
 {
 	// TODO: read environment
@@ -80,17 +77,4 @@
 
 /**
- * Get the time in seconds
- *
- * @param t If t is non-NULL, the return value is also stored in the memory
- *          pointed to by t.
- * @return  On success, the value of time in seconds since the Epoch
- *          is returned. On error, (time_t)-1 is returned.
- */
-time_t posix_time(time_t *t)
-{
-	return time(t);
-}
-
-/**
  * Converts a time value to a broken-down UTC time.
  * 
@@ -99,5 +83,5 @@
  * @return Value of result on success, NULL on overflow.
  */
-struct tm *posix_gmtime_r(const time_t *restrict timer,
+struct tm *gmtime_r(const time_t *restrict timer,
     struct tm *restrict result)
 {
@@ -117,9 +101,9 @@
  *               the result, NULL in case of error.
  */
-struct tm *posix_gmtime(const time_t *restrict timep)
+struct tm *gmtime(const time_t *restrict timep)
 {
 	static struct tm result;
 
-	return posix_gmtime_r(timep, &result);
+	return gmtime_r(timep, &result);
 }
 
@@ -131,10 +115,10 @@
  * @return Value of result on success, NULL on overflow.
  */
-struct tm *posix_localtime_r(const time_t *restrict timer,
+struct tm *localtime_r(const time_t *restrict timer,
     struct tm *restrict result)
 {
 	// TODO: deal with timezone
 	// currently assumes system and all times are in GMT
-	return posix_gmtime_r(timer, result);
+	return gmtime_r(timer, result);
 }
 
@@ -147,9 +131,9 @@
  *                 the result, NULL in case of error.
  */
-struct tm *posix_localtime(const time_t *restrict timep)
+struct tm *localtime(const time_t *restrict timep)
 {
 	static struct tm result;
 
-	return posix_localtime_r(timep, &result);
+	return localtime_r(timep, &result);
 }
 
@@ -163,5 +147,5 @@
  * @return Value of buf.
  */
-char *posix_asctime_r(const struct tm *restrict timeptr,
+char *asctime_r(const struct tm *restrict timeptr,
     char *restrict buf)
 {
@@ -179,9 +163,9 @@
  *                   the result, NULL in case of error.
  */
-char *posix_asctime(const struct tm *restrict timeptr)
+char *asctime(const struct tm *restrict timeptr)
 {
 	static char buf[ASCTIME_BUF_LEN];
 
-	return posix_asctime_r(timeptr, buf);
+	return asctime_r(timeptr, buf);
 }
 
@@ -195,5 +179,5 @@
  * @return Pointer to buf on success, NULL on failure.
  */
-char *posix_ctime_r(const time_t *timer, char *buf)
+char *ctime_r(const time_t *timer, char *buf)
 {
 	if (failed(time_local2str(*timer, buf))) {
@@ -213,9 +197,9 @@
  *                 the result, NULL in case of error.
  */
-char *posix_ctime(const time_t *timep)
+char *ctime(const time_t *timep)
 {
 	static char buf[ASCTIME_BUF_LEN];
 
-	return posix_ctime_r(timep, buf);
+	return ctime_r(timep, buf);
 }
 
@@ -227,5 +211,5 @@
  * @return 0 on success, -1 with errno set on failure.
  */
-int posix_clock_getres(posix_clockid_t clock_id, struct posix_timespec *res)
+int clock_getres(clockid_t clock_id, struct timespec *res)
 {
 	assert(res != NULL);
@@ -249,5 +233,5 @@
  * @return 0 on success, -1 with errno on failure.
  */
-int posix_clock_gettime(posix_clockid_t clock_id, struct posix_timespec *tp)
+int clock_gettime(clockid_t clock_id, struct timespec *tp)
 {
 	assert(tp != NULL);
@@ -275,6 +259,6 @@
  * @return 0 on success, -1 with errno on failure.
  */
-int posix_clock_settime(posix_clockid_t clock_id,
-    const struct posix_timespec *tp)
+int clock_settime(clockid_t clock_id,
+    const struct timespec *tp)
 {
 	assert(tp != NULL);
@@ -302,6 +286,6 @@
  * @return 0 on success, -1 with errno set on failure.
  */
-int posix_clock_nanosleep(posix_clockid_t clock_id, int flags,
-    const struct posix_timespec *rqtp, struct posix_timespec *rmtp)
+int clock_nanosleep(clockid_t clock_id, int flags,
+    const struct timespec *rqtp, struct timespec *rmtp)
 {
 	assert(rqtp != NULL);
@@ -329,10 +313,10 @@
  * @return Consumed CPU cycles by this process or -1 if not available.
  */
-posix_clock_t posix_clock(void)
-{
-	posix_clock_t total_cycles = -1;
+clock_t clock(void)
+{
+	clock_t total_cycles = -1;
 	stats_task_t *task_stats = stats_get_task(task_get_id());
 	if (task_stats) {
-		total_cycles = (posix_clock_t) (task_stats->kcycles +
+		total_cycles = (clock_t) (task_stats->kcycles +
 		    task_stats->ucycles);
 		free(task_stats);
Index: uspace/lib/posix/src/unistd.c
===================================================================
--- uspace/lib/posix/src/unistd.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/src/unistd.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -34,7 +34,4 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
-
 #include "internal/common.h"
 #include "posix/unistd.h"
@@ -70,5 +67,5 @@
  * @return Always 0 on HelenOS.
  */
-unsigned int posix_sleep(unsigned int seconds)
+unsigned int sleep(unsigned int seconds)
 {
 	return thread_sleep(seconds);
@@ -80,5 +77,5 @@
  * @return User name (static) string or NULL if not found.
  */
-char *posix_getlogin(void)
+char *getlogin(void)
 {
 	/* There is currently no support for user accounts in HelenOS. */
@@ -93,9 +90,9 @@
  * @return Zero on success, error code otherwise.
  */
-int posix_getlogin_r(char *name, size_t namesize)
+int getlogin_r(char *name, size_t namesize)
 {
 	/* There is currently no support for user accounts in HelenOS. */
 	if (namesize >= 5) {
-		posix_strcpy(name, (char *) "user");
+		strcpy(name, (char *) "user");
 		return 0;
 	} else {
@@ -111,5 +108,5 @@
  * @return Boolean result of the test.
  */
-int posix_isatty(int fd)
+int isatty(int fd)
 {
 	// TODO
@@ -126,5 +123,5 @@
  * @return Buffer pointer on success, NULL on failure.
  */
-char *posix_getcwd(char *buf, size_t size)
+char *getcwd(char *buf, size_t size)
 {
 	if (failed(vfs_cwd_get(buf, size))) 
@@ -138,5 +135,5 @@
  * @param path New working directory.
  */
-int posix_chdir(const char *path)
+int chdir(const char *path)
 {
 	if (failed(vfs_cwd_set(path)))
@@ -150,5 +147,5 @@
  * @return Page size of the process.
  */
-int posix_getpagesize(void)
+int getpagesize(void)
 {
 	return PAGE_SIZE;
@@ -160,5 +157,5 @@
  * @return Process ID.
  */
-posix_pid_t posix_getpid(void)
+pid_t getpid(void)
 {
 	return task_get_id();
@@ -170,5 +167,5 @@
  * @return User ID.
  */
-posix_uid_t posix_getuid(void)
+uid_t getuid(void)
 {
 	/* There is currently no support for user accounts in HelenOS. */
@@ -181,5 +178,5 @@
  * @return Group ID.
  */
-posix_gid_t posix_getgid(void)
+gid_t getgid(void)
 {
 	/* There is currently no support for user accounts in HelenOS. */
@@ -193,5 +190,5 @@
  * @return 0 on success, -1 on error.
  */
-int posix_close(int fildes)
+int close(int fildes)
 {
 	posix_pos[fildes] = 0;
@@ -210,5 +207,5 @@
  * @return Number of read bytes on success, -1 otherwise.
  */
-ssize_t posix_read(int fildes, void *buf, size_t nbyte)
+ssize_t read(int fildes, void *buf, size_t nbyte)
 {
 	size_t nread;
@@ -226,5 +223,5 @@
  * @return Number of written bytes on success, -1 otherwise.
  */
-ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
+ssize_t write(int fildes, const void *buf, size_t nbyte)
 {
 	size_t nwr;
@@ -243,5 +240,5 @@
  *         as measured in bytes from the beginning of the file, -1 otherwise.
  */
-posix_off_t posix_lseek(int fildes, posix_off_t offset, int whence)
+off_t lseek(int fildes, off_t offset, int whence)
 {
 	vfs_stat_t st;
@@ -274,5 +271,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_fsync(int fildes)
+int fsync(int fildes)
 {
 	if (failed(vfs_sync(fildes)))
@@ -289,5 +286,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_ftruncate(int fildes, posix_off_t length)
+int ftruncate(int fildes, off_t length)
 {
 	if (failed(vfs_resize(fildes, (aoff64_t) length)))
@@ -303,5 +300,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_rmdir(const char *path)
+int rmdir(const char *path)
 {
 	if (failed(vfs_unlink_path(path)))
@@ -317,5 +314,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_unlink(const char *path)
+int unlink(const char *path)
 {
 	if (failed(vfs_unlink_path(path)))
@@ -331,7 +328,7 @@
  * @return On success, new file descriptor for the same file, otherwise -1.
  */
-int posix_dup(int fildes)
-{
-	return posix_fcntl(fildes, F_DUPFD, 0);
+int dup(int fildes)
+{
+	return fcntl(fildes, F_DUPFD, 0);
 }
 
@@ -344,5 +341,5 @@
  * @return fildes2 on success, -1 otherwise.
  */
-int posix_dup2(int fildes, int fildes2)
+int dup2(int fildes, int fildes2)
 {
 	int file;
@@ -360,5 +357,5 @@
  * @return Zero on success, -1 otherwise.
  */
-int posix_access(const char *path, int amode)
+int access(const char *path, int amode)
 {
 	if (amode == F_OK || (amode & (X_OK | W_OK | R_OK))) {
@@ -368,8 +365,8 @@
 		 * Check file existence by attempting to open it.
 		 */
-		int fd = posix_open(path, O_RDONLY);
+		int fd = open(path, O_RDONLY);
 		if (fd < 0)
 			return -1;
-		posix_close(fd);
+		close(fd);
 		return 0;
 	} else {
@@ -386,5 +383,5 @@
  * @return Variable value.
  */
-long posix_sysconf(int name)
+long sysconf(int name)
 {
 	long clk_tck = 0;
@@ -403,6 +400,6 @@
 	stats_physmem_t *mem_stats = stats_get_physmem();
 	if (mem_stats) {
-		phys_pages = (long) (mem_stats->total / posix_getpagesize());
-		avphys_pages = (long) (mem_stats->free / posix_getpagesize());
+		phys_pages = (long) (mem_stats->total / getpagesize());
+		avphys_pages = (long) (mem_stats->free / getpagesize());
 		free(mem_stats);
 		mem_stats = 0;
@@ -415,5 +412,5 @@
 		return avphys_pages;
 	case _SC_PAGESIZE:
-		return posix_getpagesize();
+		return getpagesize();
 	case _SC_CLK_TCK:
 		return clk_tck;
@@ -430,5 +427,5 @@
  * @return
  */
-long posix_pathconf(const char *path, int name)
+long pathconf(const char *path, int name)
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -441,5 +438,5 @@
  * @return
  */
-posix_pid_t posix_fork(void)
+pid_t fork(void)
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -454,5 +451,5 @@
  * @return
  */
-int posix_execv(const char *path, char *const argv[])
+int execv(const char *path, char *const argv[])
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -467,5 +464,5 @@
  * @return
  */
-int posix_execvp(const char *file, char *const argv[])
+int execvp(const char *file, char *const argv[])
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -479,5 +476,5 @@
  * @return
  */
-int posix_pipe(int fildes[2])
+int pipe(int fildes[2])
 {
 	// TODO: low priority, just a compile-time dependency of binutils
@@ -486,5 +483,5 @@
 }
 
-unsigned int posix_alarm(unsigned int seconds)
+unsigned int alarm(unsigned int seconds)
 {
 	not_implemented();
Index: uspace/lib/posix/test/scanf.c
===================================================================
--- uspace/lib/posix/test/scanf.c	(revision e0f47f53448ea5824cda6d06a7b34f8d2d74c41e)
+++ uspace/lib/posix/test/scanf.c	(revision 7f9df7b96a72566de47074ddcc443093aa8aa3e8)
@@ -27,6 +27,5 @@
  */
 
-#define LIBPOSIX_INTERNAL
-#define __POSIX_DEF__(x) posix_##x
+
 
 #include <errno.h>
@@ -52,5 +51,5 @@
 PCUT_TEST(int_decimal) {
 	int number;
-	int rc = posix_sscanf("4242", "%d", &number);
+	int rc = sscanf("4242", "%d", &number);
 	PCUT_ASSERT_INT_EQUALS(1, rc);
 	PCUT_ASSERT_INT_EQUALS(4242, number);
@@ -59,5 +58,5 @@
 PCUT_TEST(int_negative_decimal) {
 	int number;
-	int rc = posix_sscanf("-53", "%d", &number);
+	int rc = sscanf("-53", "%d", &number);
 	PCUT_ASSERT_INT_EQUALS(1, rc);
 	PCUT_ASSERT_INT_EQUALS(-53, number);
@@ -83,5 +82,5 @@
 	void *p;
 
-	int rc = posix_sscanf(
+	int rc = sscanf(
 		"\n j tt % \t -121314 98765 aqw 0765 0x77 0xABCDEF88 -99 884",
 		" j tt %%%3hhd%1hhu%3hd %3hu%u aqw%n %lo%llx %p %li %lld",
@@ -108,5 +107,5 @@
 	long double ld;
 
-	int rc = posix_sscanf(
+	int rc = sscanf(
 		"\n \t\t1.0 -0x555.AP10 1234.5678e12",
 		"%f %lf %Lf",
@@ -124,5 +123,5 @@
 	char *pstr;
 
-	int rc = posix_sscanf(
+	int rc = sscanf(
 		"\n\n\thello world    \n",
 		"%5s %ms",
@@ -141,5 +140,5 @@
 	char *pscanset;
 
-	int rc = posix_sscanf(
+	int rc = sscanf(
 		"\n\n\th-e-l-l-o world-]    \n",
 		" %9[-eh-o] %m[^]-]",
@@ -158,5 +157,5 @@
 	char *pseq;
 
-	int rc = posix_sscanf(
+	int rc = sscanf(
 		"\n\n\thello world    \n",
 		" %5c %mc",