Index: uspace/app/barber/barber.c
===================================================================
--- uspace/app/barber/barber.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/barber/barber.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -267,5 +267,5 @@
 			link_initialize(&dev->link);
 			dev->svc_id = svcs[i];
-			dev->sess = loc_service_connect(EXCHANGE_SERIALIZE, svcs[i], 0);
+			dev->sess = loc_service_connect(svcs[i], INTERFACE_DDF, 0);
 			
 			list_append(&dev->link, &led_devs);
Index: uspace/app/bdsh/cmds/builtins/cd/cd.c
===================================================================
--- uspace/app/bdsh/cmds/builtins/cd/cd.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/builtins/cd/cd.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -57,8 +57,6 @@
 	previous_directory_set = true;
 
-	int rc = chdir(new_dir);
-	if (rc != EOK) {
-		return rc;
-	}
+	if (chdir(new_dir) != 0)
+		return errno;
 
 	str_cpy(previous_directory, PATH_MAX, previous_directory_tmp);
Index: uspace/app/bdsh/cmds/modules/cat/cat.c
===================================================================
--- uspace/app/bdsh/cmds/modules/cat/cat.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/cat/cat.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -244,5 +244,4 @@
 		
 		bytes = read(fd, buff + copied_bytes, bytes_to_read);
-		bytes += copied_bytes;
 		copied_bytes = 0;
 
Index: uspace/app/bdsh/cmds/modules/cp/cp.c
===================================================================
--- uspace/app/bdsh/cmds/modules/cp/cp.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/cp/cp.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -27,4 +27,5 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -84,5 +85,5 @@
 	int r = stat(path, &s);
 
-	if (r)
+	if (r != 0)
 		return TYPE_NONE;
 	else if (s.is_directory)
@@ -234,5 +235,5 @@
 			 */
 			if (force && !interactive) {
-				if (unlink(dest_path)) {
+				if (unlink(dest_path) != 0) {
 					printf("Unable to remove %s\n",
 					    dest_path);
@@ -245,5 +246,5 @@
 				if (overwrite) {
 					printf("Overwriting file: %s\n", dest_path);
-					if (unlink(dest_path)) {
+					if (unlink(dest_path) != 0) {
 						printf("Unable to remove %s\n", dest_path);
 						goto exit;
@@ -294,5 +295,5 @@
 				merge_paths(dest_path, PATH_MAX, src_dirname);
 
-				if (mkdir(dest_path, 0) == -1) {
+				if (mkdir(dest_path, 0) != 0) {
 					printf("Unable to create "
 					    "dest directory %s\n", dest_path);
@@ -308,5 +309,5 @@
 			 * e.g. cp -r /src /data/new_dir_src
 			 */
-			if (mkdir(dest_path, 0)) {
+			if (mkdir(dest_path, 0) != 0) {
 				printf("Unable to create "
 				    "dest directory %s\n", dest_path);
@@ -405,6 +406,6 @@
 	}
 
-	while ((bytes = read_all(fd1, buff, blen)) > 0) {
-		if ((bytes = write_all(fd2, buff, bytes)) < 0)
+	while ((bytes = read(fd1, buff, blen)) > 0) {
+		if ((bytes = write(fd2, buff, bytes)) < 0)
 			break;
 		copied += bytes;
@@ -412,5 +413,5 @@
 
 	if (bytes < 0) {
-		printf("\nError copying %s, (%d)\n", src, bytes);
+		printf("\nError copying %s, (%d)\n", src, errno);
 		copied = bytes;
 	}
Index: uspace/app/bdsh/cmds/modules/ls/ls.c
===================================================================
--- uspace/app/bdsh/cmds/modules/ls/ls.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/ls/ls.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -31,4 +31,5 @@
  * As more stuff is completed and exposed in libc, this will improve */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -187,5 +188,5 @@
 		if (rc != 0) {
 			printf("ls: skipping bogus node %s\n", buff);
-			printf("rc=%d\n", rc);
+			printf("error=%d\n", errno);
 			goto out;
 		}
@@ -314,5 +315,5 @@
 static unsigned int ls_scope(const char *path, struct dir_elem_t *de)
 {
-	if (stat(path, &de->s)) {
+	if (stat(path, &de->s) != 0) {
 		cli_error(CL_ENOENT, "%s", path);
 		return LS_BOGUS;
@@ -376,18 +377,23 @@
 		}
 	}
-	
+
 	argc -= optind;
-	
+
 	de.name = (char *) malloc(PATH_MAX);
 	if (!de.name) {
-		cli_error(CL_ENOMEM, "%s: ", cmdname);
+		cli_error(CL_ENOMEM, "%s: Out of memory", cmdname);
 		return CMD_FAILURE;
 	}
 	memset(de.name, 0, PATH_MAX);
-	
-	if (argc == 0)
-		getcwd(de.name, PATH_MAX);
-	else
+
+	if (argc == 0) {
+		if (getcwd(de.name, PATH_MAX) == NULL) {
+			cli_error(CL_EFAIL, "%s: Failed determining working "
+			    "directory", cmdname);
+			return CMD_FAILURE;
+		}
+	} else {
 		str_cpy(de.name, PATH_MAX, argv[optind]);
+	}
 
 	scope = ls_scope(de.name, &de);
Index: uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mkdir/mkdir.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/mkdir/mkdir.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -89,5 +89,5 @@
 {
 	/* Ensure we would always work with absolute and canonified path. */
-	char *path = absolutize(user_path, NULL);
+	char *path = vfs_absolutize(user_path, NULL);
 	if (path == NULL) {
 		cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
@@ -95,12 +95,10 @@
 	}
 
-	int rc;
 	int ret = 0;
 
 	if (!create_parents) {
-		rc = mkdir(path, 0);
-		if (rc != EOK) {
+		if (mkdir(path, 0) != 0) {
 			cli_error(CL_EFAIL, "%s: could not create %s (%s)",
-			    cmdname, path, str_error(rc));
+			    cmdname, path, str_error(errno));
 			ret = 1;
 		}
@@ -137,12 +135,8 @@
 			char slash_char = path[prev_off];
 			path[prev_off] = 0;
-			rc = mkdir(path, 0);
-			if (rc == EEXIST) {
-				rc = EOK;
-			}
-
-			if (rc != EOK) {
+
+			if (mkdir(path, 0) != 0 && errno != EEXIST) {
 				cli_error(CL_EFAIL, "%s: could not create %s (%s)",
-				    cmdname, path, str_error(rc));
+				    cmdname, path, str_error(errno));
 				ret = 1;
 				goto leave;
@@ -152,8 +146,7 @@
 		}
 		/* Create the final directory. */
-		rc = mkdir(path, 0);
-		if (rc != EOK) {
+		if (mkdir(path, 0) != 0) {
 			cli_error(CL_EFAIL, "%s: could not create %s (%s)",
-			    cmdname, path, str_error(rc));
+			    cmdname, path, str_error(errno));
 			ret = 1;
 		}
@@ -214,5 +207,6 @@
 
 	if (follow && (argv[optind] != NULL)) {
-		chdir(argv[optind]);
+		if (chdir(argv[optind]) != 0)
+			printf("%s: Error switching to directory.", cmdname);
 	}
 
Index: uspace/app/bdsh/cmds/modules/mkfile/mkfile.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mkfile/mkfile.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/mkfile/mkfile.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -27,4 +27,5 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -166,8 +167,10 @@
 
 		if ((rc2 = lseek(fd, file_size - 1, SEEK_SET)) < 0)
-			goto exit;
+			goto error;
 
 		rc2 = write(fd, &byte, sizeof(char));
-		goto exit;
+		if (rc2 < 0)
+			goto error;
+		return CMD_SUCCESS;
 	}
 
@@ -183,5 +186,5 @@
 		rc = write(fd, buffer, to_write);
 		if (rc <= 0) {
-			printf("%s: Error writing file (%zd).\n", cmdname, rc);
+			printf("%s: Error writing file (%d).\n", cmdname, errno);
 			close(fd);
 			return CMD_FAILURE;
@@ -191,12 +194,11 @@
 
 	free(buffer);
-exit:
-	rc = close(fd);
-
-	if (rc != 0 || rc2 < 0) {
-		printf("%s: Error writing file (%zd).\n", cmdname, rc);
-		return CMD_FAILURE;
-	}
+
+	if (close(fd) < 0)
+		goto error;
 
 	return CMD_SUCCESS;
+error:
+	printf("%s: Error writing file (%d).\n", cmdname, errno);
+	return CMD_FAILURE;
 }
Index: uspace/app/bdsh/cmds/modules/mount/mount.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mount/mount.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/mount/mount.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -72,5 +72,5 @@
 	int rc;
 
-	get_mtab_list(&mtab_list);
+	vfs_get_mtab_list(&mtab_list);
 
 	list_foreach(mtab_list, link, mtab_ent_t, mtab_ent) {
@@ -150,5 +150,5 @@
 		mopts = t_argv[4];
 
-	rc = mount(t_argv[1], t_argv[2], dev, mopts, 0, instance);
+	rc = vfs_mount(t_argv[1], t_argv[2], dev, mopts, 0, instance);
 	if (rc != EOK) {
 		printf("Unable to mount %s filesystem to %s on %s (rc=%d)\n",
Index: uspace/app/bdsh/cmds/modules/mv/mv.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mv/mv.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/mv/mv.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -60,7 +60,7 @@
 
 	rc = rename(argv[1], argv[2]);
-	if (rc != EOK) {
-		printf("Unable to rename %s to %s (rc=%d)\n",
-		    argv[1], argv[2], rc);
+	if (rc != 0) {
+		printf("Unable to rename %s to %s (error=%d)\n",
+		    argv[1], argv[2], errno);
 		return CMD_FAILURE;
 	}
Index: uspace/app/bdsh/cmds/modules/pwd/pwd.c
===================================================================
--- uspace/app/bdsh/cmds/modules/pwd/pwd.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/pwd/pwd.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -56,7 +56,6 @@
 
 	memset(buff, 0, PATH_MAX);
-	getcwd(buff, PATH_MAX);
 
-	if (! buff) {
+	if (getcwd(buff, PATH_MAX) == NULL) {
 		cli_error(CL_EFAIL,
 			"Unable to determine the current working directory");
Index: uspace/app/bdsh/cmds/modules/rm/rm.c
===================================================================
--- uspace/app/bdsh/cmds/modules/rm/rm.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/rm/rm.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -27,4 +27,5 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -131,5 +132,5 @@
 static unsigned int rm_single(const char *path)
 {
-	if (unlink(path)) {
+	if (unlink(path) != 0) {
 		cli_error(CL_EFAIL, "rm: could not remove file %s", path);
 		return 1;
@@ -150,5 +151,5 @@
 
 	fd = open(path, O_RDONLY);
-	if (fd > 0) {
+	if (fd >= 0) {
 		close(fd);
 		return RM_FILE;
@@ -210,5 +211,5 @@
 	rc = rmdir(path);
 	if (rc == 0)
-		return ret;
+		return errno;
 
 	cli_error(CL_ENOTSUP, "Can not remove %s", path);
Index: uspace/app/bdsh/cmds/modules/touch/touch.c
===================================================================
--- uspace/app/bdsh/cmds/modules/touch/touch.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/touch/touch.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -123,5 +123,5 @@
 		
 		/* Check whether file exists if -c (--no-create) option is given */
-		if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == EOK)))
+		if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == 0)))
 			fd = open(buff, O_RDWR | O_CREAT);
 		
Index: uspace/app/bdsh/cmds/modules/unmount/unmount.c
===================================================================
--- uspace/app/bdsh/cmds/modules/unmount/unmount.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/cmds/modules/unmount/unmount.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -66,5 +66,5 @@
 	}
 
-	rc = unmount(argv[1]);
+	rc = vfs_unmount(argv[1]);
 	if (rc != EOK) {
 		printf("Unable to unmount %s (rc=%d)\n", argv[1], rc);
Index: uspace/app/bdsh/compl.c
===================================================================
--- uspace/app/bdsh/compl.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/compl.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -360,5 +360,5 @@
 				asprintf(&ent_path, "%s/%s", *cs->path, dent->d_name);
 				struct stat ent_stat;
-				if (stat(ent_path, &ent_stat) != EOK) {
+				if (stat(ent_path, &ent_stat) != 0) {
 					/* Error */
 					free(ent_path);
Index: uspace/app/bdsh/config.h
===================================================================
--- uspace/app/bdsh/config.h	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/config.h	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -46,6 +46,6 @@
 /* How many words (arguments) are permitted, how big can a whole
  * sentence be? Similar to ARG_MAX */
-#define WORD_MAX 255
-#define INPUT_MAX 1024
+#define WORD_MAX 1023
+#define INPUT_MAX 4096
 
 /* Leftovers from Autoconf */
Index: uspace/app/bdsh/errors.h
===================================================================
--- uspace/app/bdsh/errors.h	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/errors.h	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -42,5 +42,5 @@
 #define CL_ENOTSUP 6
 #define CL_EEXEC   7
-#define CL_EEXISTS 8
+#define CL_EEXIST  8
 #define CL_ETOOBIG 9
 
Index: uspace/app/bdsh/exec.c
===================================================================
--- uspace/app/bdsh/exec.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/bdsh/exec.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -61,5 +61,5 @@
 
 	fd = open(f, O_RDONLY);
-	if (fd > -1) {
+	if (fd >= 0) {
 		close(fd);
 		return 0;
@@ -113,5 +113,5 @@
 	
 	for (i = 0; i < 3 && files[i] != NULL; i++) {
-		if (fhandle(files[i], &file_handles[i]) == EOK) {
+		if (vfs_fhandle(files[i], &file_handles[i]) == EOK) {
 			file_handles_p[i] = &file_handles[i];
 		}
Index: uspace/app/blkdump/blkdump.c
===================================================================
--- uspace/app/blkdump/blkdump.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/blkdump/blkdump.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -142,5 +142,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	rc = block_init(service_id, 2048);
 	if (rc != EOK)  {
 		printf(NAME ": Error initializing libblock.\n");
Index: uspace/app/date/date.c
===================================================================
--- uspace/app/date/date.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/date/date.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -136,6 +136,5 @@
 
 	/* Connect to the device */
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
-	    svc_id, 0);
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
 	if (!sess) {
 		printf(NAME ": Cannot connect to the device\n");
Index: uspace/app/df/df.c
===================================================================
--- uspace/app/df/df.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/df/df.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -119,10 +119,14 @@
 
 	LIST_INITIALIZE(mtab_list);
-	get_mtab_list(&mtab_list);
+	vfs_get_mtab_list(&mtab_list);
 
 	print_header();
 	list_foreach(mtab_list, link, mtab_ent_t, mtab_ent) {
-		statfs(mtab_ent->mp, &st);
-		print_statfs(&st, mtab_ent->fs_name, mtab_ent->mp);
+		if (statfs(mtab_ent->mp, &st) == 0) {
+			print_statfs(&st, mtab_ent->fs_name, mtab_ent->mp);
+		} else {
+			fprintf(stderr, "Cannot get information for '%s' (%d).\n",
+			    mtab_ent->mp, errno);
+		}
 	}
 
Index: uspace/app/hdisk/hdisk.c
===================================================================
--- uspace/app/hdisk/hdisk.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/hdisk/hdisk.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -82,5 +82,5 @@
 	label.device = dev_handle;
 	
-	rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
+	rc = block_init(dev_handle, 512);
 	if (rc != EOK) {
 		printf("Error during libblock init: %d - %s.\n", rc, str_error(rc));
Index: uspace/app/init/init.c
===================================================================
--- uspace/app/init/init.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/init/init.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -126,5 +126,5 @@
 		opts = "restore";
 	
-	int rc = mount(fstype, ROOT_MOUNT_POINT, ROOT_DEVICE, opts,
+	int rc = vfs_mount(fstype, ROOT_MOUNT_POINT, ROOT_DEVICE, opts,
 	    IPC_FLAG_BLOCKING, 0);
 	return mount_report("Root filesystem", ROOT_MOUNT_POINT, fstype,
@@ -143,5 +143,5 @@
 static bool mount_locfs(void)
 {
-	int rc = mount(LOCFS_FS_TYPE, LOCFS_MOUNT_POINT, "", "",
+	int rc = vfs_mount(LOCFS_FS_TYPE, LOCFS_MOUNT_POINT, "", "",
 	    IPC_FLAG_BLOCKING, 0);
 	return mount_report("Location service filesystem", LOCFS_MOUNT_POINT,
@@ -152,5 +152,5 @@
 {
 	struct stat s;
-	if (stat(path, &s) == ENOENT) {
+	if (stat(path, &s) != 0) {
 		printf("%s: Unable to stat %s\n", NAME, path);
 		return ENOENT;
@@ -299,5 +299,5 @@
 static bool mount_tmpfs(void)
 {
-	int rc = mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0, 0);
+	int rc = vfs_mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0, 0);
 	return mount_report("Temporary filesystem", TMPFS_MOUNT_POINT,
 	    TMPFS_FS_TYPE, NULL, rc);
Index: uspace/app/mixerctl/mixerctl.c
===================================================================
--- uspace/app/mixerctl/mixerctl.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/mixerctl/mixerctl.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -155,6 +155,5 @@
 	}
 
-	async_sess_t *session = loc_service_connect(
-	    EXCHANGE_ATOMIC, mixer_sid, 0);
+	async_sess_t *session = loc_service_connect(mixer_sid, INTERFACE_DDF, 0);
 	if (!session) {
 		printf("Failed connecting mixer service '%s'.\n", service);
Index: uspace/app/mkbd/main.c
===================================================================
--- uspace/app/mkbd/main.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/mkbd/main.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -231,6 +231,5 @@
 	}
 	
-	async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE,
-	    dev_handle, 0);
+	async_sess_t *sess = devman_device_connect(dev_handle, 0);
 	if (!sess) {
 		printf(NAME ": failed to connect to the device (handle %"
Index: uspace/app/mkexfat/mkexfat.c
===================================================================
--- uspace/app/mkexfat/mkexfat.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/mkexfat/mkexfat.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -803,5 +803,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	rc = block_init(service_id, 2048);
 	if (rc != EOK) {
 		printf(NAME ": Error initializing libblock.\n");
Index: uspace/app/mkfat/mkfat.c
===================================================================
--- uspace/app/mkfat/mkfat.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/mkfat/mkfat.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -162,5 +162,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	rc = block_init(service_id, 2048);
 	if (rc != EOK)  {
 		printf(NAME ": Error initializing libblock.\n");
Index: uspace/app/mkmfs/mkmfs.c
===================================================================
--- uspace/app/mkmfs/mkmfs.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/mkmfs/mkmfs.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -209,5 +209,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	rc = block_init(service_id, 2048);
 	if (rc != EOK)  {
 		printf(NAME ": Error initializing libblock.\n");
Index: uspace/app/nic/nic.c
===================================================================
--- uspace/app/nic/nic.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/nic/nic.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -99,5 +99,5 @@
 	printf("Using device: %s\n", svc_name);
 
-	sess = loc_service_connect(EXCHANGE_SERIALIZE, nics[i], 0);
+	sess = loc_service_connect(nics[i], INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");
@@ -117,10 +117,10 @@
 	int rc;
 
-	sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id, 0);
+	sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");
 		goto error;
 	}
-
+	
 	rc = nic_get_address(sess, &info->address);
 	if (rc != EOK) {
Index: uspace/app/sportdmp/sportdmp.c
===================================================================
--- uspace/app/sportdmp/sportdmp.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/sportdmp/sportdmp.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -111,5 +111,5 @@
 
 
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (!sess) {
Index: uspace/app/taskdump/elf_core.c
===================================================================
--- uspace/app/taskdump/elf_core.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/taskdump/elf_core.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -207,5 +207,5 @@
 	}
 
-	rc = write_all(fd, &elf_hdr, sizeof(elf_hdr));
+	rc = write(fd, &elf_hdr, sizeof(elf_hdr));
 	if (rc != sizeof(elf_hdr)) {
 		printf("Failed writing ELF header.\n");
@@ -215,5 +215,5 @@
 
 	for (i = 0; i < n_ph; ++i) {
-		rc = write_all(fd, &p_hdr[i], sizeof(p_hdr[i]));
+		rc = write(fd, &p_hdr[i], sizeof(p_hdr[i]));
 		if (rc != sizeof(p_hdr[i])) {
 			printf("Failed writing program header.\n");
@@ -236,5 +236,5 @@
 	note.type = NT_PRSTATUS;
 
-	rc = write_all(fd, &note, sizeof(elf_note_t));
+	rc = write(fd, &note, sizeof(elf_note_t));
 	if (rc != sizeof(elf_note_t)) {
 		printf("Failed writing note header.\n");
@@ -243,5 +243,5 @@
 	}
 
-	rc = write_all(fd, "CORE", note.namesz);
+	rc = write(fd, "CORE", note.namesz);
 	if (rc != (ssize_t) note.namesz) {
 		printf("Failed writing note header.\n");
@@ -257,5 +257,5 @@
 	}
 
-	rc = write_all(fd, &pr_status, sizeof(elf_prstatus_t));
+	rc = write(fd, &pr_status, sizeof(elf_prstatus_t));
 	if (rc != sizeof(elf_prstatus_t)) {
 		printf("Failed writing register data.\n");
@@ -321,5 +321,5 @@
 		}
 
-		rc = write_all(fd, buffer, to_copy);
+		rc = write(fd, buffer, to_copy);
 		if (rc != (ssize_t) to_copy) {
 			printf("Failed writing memory contents.\n");
Index: uspace/app/taskdump/symtab.c
===================================================================
--- uspace/app/taskdump/symtab.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/taskdump/symtab.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -88,5 +88,5 @@
 	}
 
-	rc = read_all(fd, &elf_hdr, sizeof(elf_header_t));
+	rc = read(fd, &elf_hdr, sizeof(elf_header_t));
 	if (rc != sizeof(elf_header_t)) {
 		printf("failed reading elf header\n");
@@ -310,5 +310,5 @@
 		return EIO;
 
-	rc = read_all(fd, sec_hdr, sizeof(elf_section_header_t));
+	rc = read(fd, sec_hdr, sizeof(elf_section_header_t));
 	if (rc != sizeof(elf_section_header_t))
 		return EIO;
@@ -346,5 +346,5 @@
 	}
 
-	rc = read_all(fd, *ptr, size);
+	rc = read(fd, *ptr, size);
 	if (rc != (ssize_t) size) {
 		printf("failed reading chunk\n");
Index: uspace/app/tester/float/float2.c
===================================================================
--- uspace/app/tester/float/float2.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/float/float2.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -1,4 +1,5 @@
 /*
  * Copyright (c) 2014 Martin Decky
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -27,4 +28,5 @@
  */
 
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -32,6 +34,7 @@
 #include "../tester.h"
 
-#define OPERANDS   10
-#define PRECISION  100000000
+#define OPERANDS         10
+#define PRECISIONF    10000
+#define PRECISION 100000000
 
 static double arguments[OPERANDS] = {
@@ -39,6 +42,97 @@
 };
 
-static double results_trunc[OPERANDS] = {
-	3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
+static double arguments_acos[OPERANDS] = {
+	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
+	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
+	0.540302305868
+};
+
+static double arguments_asin[OPERANDS] = {
+	-0.350783227690, -0.863209366649, -0.506365641110, -0.262374853704,
+	0.158533380044, 0.0, 0.980815184715, -0.206379975025, -0.044182448332,
+	0.841470984808
+};
+
+static double arguments_atan[OPERANDS] = {
+	3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
+	2.718281828459045, 9.9, 0.001
+};
+
+static double arguments_exp[OPERANDS] = {
+	3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.1, -66.0
+};
+
+static double arguments_log[OPERANDS] = {
+	3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
+	2.718281828459045, 9.9, 0.001
+};
+
+static double arguments_sqrt[OPERANDS] = {
+	3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
+	2.718281828459045, 9.9, 0.001
+};
+
+static double arguments_tanh[OPERANDS] = {
+	3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.000001, -66000000.0
+};
+
+static double results_acos[OPERANDS] = {
+	2.783185307180, 2.100000000000, 0.530964914873, 0.265482457437,
+	0.159205070272, 0.000000000000, 1.766992524091, 0.207873834887,
+	3.097395817941, 1.000000000000
+};
+
+static double results_asin[OPERANDS] = {
+	-0.358407346411, -1.041592653590, -0.530964914874, -0.265482457437,
+	0.159205070273, 0.000000000000, 1.374600129498, -0.207873834889,
+	-0.044196835651, 1.000000000000
+};
+
+static double results_atan[OPERANDS] = {
+	1.292496667790, 1.560796660108, 1.550798992822, 1.569494779052,
+	1.569870829603, 0.785398163397, 1.555645970920, 1.218282905017,
+	1.470127674637, 0.000999999667
+};
+
+static double results_ceil[OPERANDS] = {
+	4.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 769.0, 1081.0, -600.0, 1.0
+};
+
+static double results_cos[OPERANDS] = {
+	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
+	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
+	0.540302305868
+};
+
+static double results_cosh[OPERANDS] = {
+	16.572824671057, 4.144313170410, 2592352764293536022528.000000000000,
+	1.000000000000, 1.543080634815, 270182.468624271103, 1.668518553822,
+	122.348009517829, 1.005004168056, 23035933171656458903220125696.0
+};
+
+static double results_fabs[OPERANDS] = {
+	3.5, 2.1, 100.0, 50.0, 1024.0, 0.0, 768.3156, 1080.499999, 600.0, 1.0
+};
+
+static double results_floor[OPERANDS] = {
+	3.0, -3.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
+};
+
+static double results_exp[OPERANDS] = {
+	33.115451958692, 0.122456428253, 5184705528587072045056.0,
+	1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
+	0.004086771438, 1.105170918076, 0.000000000000
+};
+
+static double results_log[OPERANDS] = {
+	1.252762968495, 4.605170185988, 3.912023005428, 6.644200586236,
+	6.985179175021, 0.000000000000, 4.189654742026, 1.000000000000,
+	2.292534757141, -6.907755278982
+};
+
+static double results_log10[OPERANDS] = {
+	0.544068044350, 2.000000000000, 1.698970004336, 2.885539651261,
+	3.033624770817, 0.000000000000, 1.819543935542, 0.434294481903,
+	0.995635194598, -3.000000000000
 };
 
@@ -49,53 +143,413 @@
 };
 
-static double results_cos[OPERANDS] = {
-	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
-	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
-	0.540302305868
-};
+static double results_sinh[OPERANDS] = {
+	16.542627287635, -4.021856742157, 2592352764293536022528.000000000000,
+	0.000000000000, 1.175201193644, 270182.468622420449, -1.335647470124,
+	-122.343922746391, 0.100166750020, -23035933171656458903220125696.0
+};
+
+static double results_sqrt[OPERANDS] = {
+	1.870828693387, 10.000000000000, 7.071067811865, 27.718506453271,
+	32.870959812576, 1.000000000000, 8.124038404636, 1.648721270700,
+	3.146426544510, 0.031622776602
+};
+
+static double results_tan[OPERANDS] = {
+	0.374585640159, 1.709846542905, -0.587213915157, -0.271900611998,
+	0.160563932839, 0.000000000000, -5.031371570891, -0.210920691722,
+	0.044225635601, 1.557407724655
+};
+
+static double results_tanh[OPERANDS] = {
+	0.998177897611, -0.970451936613, 1.000000000000, 0.000000000000,
+	0.761594155956, 0.999999999993, -0.800499021761, -0.999966597156,
+	0.000001000000, -1.000000000000
+};
+
+static double results_trunc[OPERANDS] = {
+	3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
+};
+
+static bool cmp_float(float a, float b)
+{
+	float r;
+
+	/* XXX Need fabsf() */
+	if (b < 1.0 / PRECISIONF && b > -1.0 / PRECISIONF)
+		r = a;
+	else
+		r = a / b - 1.0;
+
+	/* XXX Need fabsf() */
+	if (r < 0.0)
+		r = -r;
+
+	return r < 1.0 / PRECISIONF;
+}
+
+static bool cmp_double(double a, double b)
+{
+	double r;
+
+	/* XXX Need fabs() */
+	if (b < 1.0 / PRECISION && b > -1.0 / PRECISION)
+		r = a;
+	else
+		r = a / b - 1.0;
+
+	/* XXX Need fabs() */
+	if (r < 0.0)
+		r = -r;
+
+	return r < 1.0 / PRECISION;
+}
 
 const char *test_float2(void)
 {
 	bool fail = false;
-	
+if (0) {
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = acos(arguments_acos[i]);
+
+		if (!cmp_double(res, results_acos[i])) {
+			TPRINTF("Double precision acos failed "
+			    "(%lf != %lf, arg %u)\n", res, results_acos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = acosf(arguments_acos[i]);
+
+		if (!cmp_float(res, results_acos[i])) {
+			TPRINTF("Single precision acos failed "
+			    "(%f != %lf, arg %u)\n", res, results_acos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = asin(arguments_asin[i]);
+
+		if (!cmp_double(res, results_asin[i])) {
+			TPRINTF("Double precision asin failed "
+			    "(%lf != %lf, arg %u)\n", res, results_asin[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = asinf(arguments_asin[i]);
+
+		if (!cmp_float(res, results_asin[i])) {
+			TPRINTF("Single precision asin failed "
+			    "(%f != %lf, arg %u)\n", res, results_asin[i], i);
+			fail = true;
+		}
+	}
+}
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = atan(arguments_atan[i]);
+
+		if (!cmp_double(res, results_atan[i])) {
+			TPRINTF("Double precision atan failed "
+			    "(%.12lf != %.12lf, arg %u)\n", res, results_atan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = atanf(arguments_atan[i]);
+
+		if (!cmp_float(res, results_atan[i])) {
+			TPRINTF("Single precision atan failed "
+			    "(%f != %lf, arg %u)\n", res, results_atan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = ceil(arguments[i]);
+
+		if (!cmp_double(res, results_ceil[i])) {
+			TPRINTF("Double precision ceil failed "
+			    "(%lf != %lf, arg %u)\n", res, results_ceil[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = ceilf(arguments[i]);
+
+		if (!cmp_float(res, results_ceil[i])) {
+			TPRINTF("Single precision ceil failed "
+			    "(%f != %lf, arg %u)\n", res, results_ceil[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = cos(arguments[i]);
+
+		if (!cmp_double(res, results_cos[i])) {
+			TPRINTF("Double precision cos failed "
+			    "(%lf != %lf, arg %u)\n", res, results_cos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = cosf(arguments[i]);
+
+		if (!cmp_float(res, results_cos[i])) {
+			TPRINTF("Single precision cos failed "
+			    "(%f != %lf, arg %u)\n", res, results_cos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = cosh(arguments_exp[i]);
+
+		if (!cmp_double(res, results_cosh[i])) {
+			TPRINTF("Double precision cosh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_cosh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = coshf(arguments_exp[i]);
+
+		if (!cmp_float(res, results_cosh[i])) {
+			TPRINTF("Single precision cosh failed "
+			    "(%f != %lf, arg %u)\n", res, results_cosh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = exp(arguments_exp[i]);
+
+		if (!cmp_double(res, results_exp[i])) {
+			TPRINTF("Double precision exp failed "
+			    "(%lf != %lf, arg %u)\n", res, results_exp[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = expf(arguments_exp[i]);
+
+		if (!cmp_float(res, results_exp[i])) {
+			TPRINTF("Single precision exp failed "
+			    "(%f != %lf, arg %u)\n", res, results_exp[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = fabs(arguments[i]);
+
+		if (!cmp_double(res, results_fabs[i])) {
+			TPRINTF("Double precision fabs failed "
+			    "(%lf != %lf, arg %u)\n", res, results_fabs[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = fabsf(arguments[i]);
+
+		if (!cmp_float(res, results_fabs[i])) {
+			TPRINTF("Single precision fabs failed "
+			    "(%f != %lf, arg %u)\n", res, results_fabs[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = floor(arguments[i]);
+
+		if (!cmp_double(res, results_floor[i])) {
+			TPRINTF("Double precision floor failed "
+			    "(%lf != %lf, arg %u)\n", res, results_floor[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = floorf(arguments[i]);
+
+		if (!cmp_float(res, results_floor[i])) {
+			TPRINTF("Single precision floor failed "
+			    "(%f != %lf, arg %u)\n", res, results_floor[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = log(arguments_log[i]);
+
+		if (!cmp_double(res, results_log[i])) {
+			TPRINTF("Double precision log failed "
+			    "(%lf != %lf, arg %u)\n", res, results_log[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = logf(arguments_log[i]);
+
+		if (!cmp_float(res, results_log[i])) {
+			TPRINTF("Single precision log failed "
+			    "(%f != %lf, arg %u)\n", res, results_log[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = log10(arguments_log[i]);
+
+		if (!cmp_double(res, results_log10[i])) {
+			TPRINTF("Double precision log10 failed "
+			    "(%lf != %lf, arg %u)\n", res, results_log10[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = log10f(arguments_log[i]);
+
+		if (!cmp_float(res, results_log10[i])) {
+			TPRINTF("Single precision log10 failed "
+			    "(%f != %lf, arg %u)\n", res, results_log10[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = sin(arguments[i]);
+
+		if (!cmp_double(res, results_sin[i])) {
+			TPRINTF("Double precision sin failed "
+			    "(%lf != %lf, arg %u)\n", res, results_sin[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = sinf(arguments[i]);
+
+		if (!cmp_float(res, results_sin[i])) {
+			TPRINTF("Single precision sin failed "
+			    "(%f != %lf, arg %u)\n", res, results_sin[i], i);
+			fail = true;
+		}
+	}
+;
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = sinh(arguments_exp[i]);
+
+		if (!cmp_double(res, results_sinh[i])) {
+			TPRINTF("Double precision sinh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_sinh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = sinhf(arguments_exp[i]);
+
+		if (!cmp_float(res, results_sinh[i])) {
+			TPRINTF("Single precision sinh failed "
+			    "(%f != %lf, arg %u)\n", res, results_sinh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = sqrt(arguments_sqrt[i]);
+
+		if (!cmp_double(res, results_sqrt[i])) {
+			TPRINTF("Double precision sqrt failed "
+			    "(%lf != %lf, arg %u)\n", res, results_sqrt[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = sqrtf(arguments_sqrt[i]);
+
+		if (!cmp_float(res, results_sqrt[i])) {
+			TPRINTF("Single precision sqrt failed "
+			    "(%f != %lf, arg %u)\n", res, results_sqrt[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = tan(arguments[i]);
+
+		if (!cmp_double(res, results_tan[i])) {
+			TPRINTF("Double precision tan failed "
+			    "(%lf != %lf, arg %u)\n", res, results_tan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = tanf(arguments[i]);
+
+		if (!cmp_float(res, results_tan[i])) {
+			TPRINTF("Single precision tan failed "
+			    "(%f != %lf, arg %u)\n", res, results_tan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = tanh(arguments_tanh[i]);
+
+		if (!cmp_double(res, results_tanh[i])) {
+			TPRINTF("Double precision tanh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_tanh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = tanhf(arguments_tanh[i]);
+
+		if (!cmp_float(res, results_tanh[i])) {
+			TPRINTF("Single precision tanh failed "
+			    "(%f != %lf, arg %u)\n", res, results_tanh[i], i);
+			fail = true;
+		}
+	}
+
 	for (unsigned int i = 0; i < OPERANDS; i++) {
 		double res = trunc(arguments[i]);
-		int64_t res_int = (int64_t) (res * PRECISION);
-		int64_t corr_int = (int64_t) (results_trunc[i] * PRECISION);
-		
-		if (res_int != corr_int) {
-			TPRINTF("Double truncation failed (%" PRId64 " != %" PRId64
-			    ", arg %u)\n", res_int, corr_int, i);
-			fail = true;
-		}
-	}
-	
-	for (unsigned int i = 0; i < OPERANDS; i++) {
-		double res = sin(arguments[i]);
-		int64_t res_int = (int64_t) (res * PRECISION);
-		int64_t corr_int = (int64_t) (results_sin[i] * PRECISION);
-		
-		if (res_int != corr_int) {
-			TPRINTF("Double sine failed (%" PRId64 " != %" PRId64
-			    ", arg %u)\n", res_int, corr_int, i);
-			fail = true;
-		}
-	}
-	
-	for (unsigned int i = 0; i < OPERANDS; i++) {
-		double res = cos(arguments[i]);
-		int64_t res_int = (int64_t) (res * PRECISION);
-		int64_t corr_int = (int64_t) (results_cos[i] * PRECISION);
-		
-		if (res_int != corr_int) {
-			TPRINTF("Double cosine failed (%" PRId64 " != %" PRId64
-			    ", arg %u)\n", res_int, corr_int, i);
-			fail = true;
-		}
-	}
-	
+
+		if (!cmp_double(res, results_trunc[i])) {
+			TPRINTF("Double precision trunc failed "
+			    "(%lf != %lf, arg %u)\n", res, results_trunc[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = truncf(arguments[i]);
+
+		if (!cmp_float(res, results_trunc[i])) {
+			TPRINTF("Single precision trunc failed "
+			    "(%f != %lf, arg %u)\n", res, results_trunc[i], i);
+			fail = true;
+		}
+	}
+
 	if (fail)
 		return "Floating point imprecision";
-	
+
 	return NULL;
 }
Index: uspace/app/tester/hw/misc/virtchar1.c
===================================================================
--- uspace/app/tester/hw/misc/virtchar1.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/hw/misc/virtchar1.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -58,5 +58,5 @@
 	int fd = open(path, O_RDONLY);
 	if (fd < 0) {
-		TPRINTF("   ...error: %s\n", str_error(fd));
+		TPRINTF("   ...error: %s\n", str_error(errno));
 		if (fd == ENOENT) {
 			TPRINTF("   (error was ENOENT: " \
@@ -69,5 +69,5 @@
 	
 	TPRINTF(" Asking for session...\n");
-	async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
+	async_sess_t *sess = vfs_fd_session(fd, INTERFACE_DDF);
 	if (!sess) {
 		close(fd);
Index: uspace/app/tester/hw/serial/serial1.c
===================================================================
--- uspace/app/tester/hw/serial/serial1.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/hw/serial/serial1.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -76,5 +76,5 @@
 		return "Failed getting serial port service ID";
 	
-	async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
+	async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
 	    IPC_FLAG_BLOCKING);
 	if (!sess)
Index: uspace/app/tester/mm/common.c
===================================================================
--- uspace/app/tester/mm/common.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/mm/common.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -309,5 +309,5 @@
 		return NULL;
 	
-	unsigned int idx = rand() % mem_blocks_count;
+	unsigned long idx = rand() % mem_blocks_count;
 	link_t *entry = list_nth(&mem_blocks, idx);
 	
Index: uspace/app/tester/tester.h
===================================================================
--- uspace/app/tester/tester.h	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/tester.h	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -60,5 +60,5 @@
 	do { \
 		if (!test_quiet) { \
-			fprintf(stderr, (format), ##__VA_ARGS__); \
+			fprintf(stdout, (format), ##__VA_ARGS__); \
 		} \
 	} while (0)
Index: uspace/app/tester/vfs/vfs1.c
===================================================================
--- uspace/app/tester/vfs/vfs1.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tester/vfs/vfs1.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -70,7 +70,6 @@
 const char *test_vfs1(void)
 {
-	int rc;
-	if ((rc = mkdir(TEST_DIRECTORY, 0)) != 0) {
-		TPRINTF("rc=%d\n", rc);
+	if (mkdir(TEST_DIRECTORY, 0) != 0) {
+		TPRINTF("rc=%d\n", errno);
 		return "mkdir() failed";
 	}
@@ -93,5 +92,7 @@
 	
 	char buf[BUF_SIZE];
+	TPRINTF("read..\n");
 	while ((cnt = read(fd0, buf, BUF_SIZE))) {
+		TPRINTF("read returns %zd\n", cnt);
 		if (cnt < 0)
 			return "read() failed";
@@ -112,13 +113,13 @@
 		return rv;
 	
-	if (rename(TEST_FILE, TEST_FILE2))
+	if (rename(TEST_FILE, TEST_FILE2) != 0)
 		return "rename() failed";
 	TPRINTF("Renamed %s to %s\n", TEST_FILE, TEST_FILE2);
 	
-	if (unlink(TEST_FILE2))
+	if (unlink(TEST_FILE2) != 0)
 		return "unlink() failed";
 	TPRINTF("Unlinked %s\n", TEST_FILE2);
 	
-	if (rmdir(TEST_DIRECTORY))
+	if (rmdir(TEST_DIRECTORY) != 0)
 		return "rmdir() failed";
 	TPRINTF("Removed directory %s\n", TEST_DIRECTORY);
Index: uspace/app/tetris/scores.c
===================================================================
--- uspace/app/tetris/scores.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/tetris/scores.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -233,4 +233,9 @@
 
 	f = fopen("/data/tetris.sco", "wb");
+	if (f == NULL) {
+		printf("Error creating table\n");
+		return;
+	}
+	
 	cnt = fwrite(scores, sizeof(struct highscore), NUMSPOTS, f);
 	rc = fclose(f);
Index: uspace/app/trace/errors.c
===================================================================
--- uspace/app/trace/errors.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/trace/errors.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -46,5 +46,5 @@
 	[-EPERM]	= { "EPERM",		"Permission denied" },
 	[-EHANGUP]	= { "EHANGUP",		"Answerbox closed connection" },
-	[-EEXISTS]	= { "EEXISTS",		"Entry already exists" },
+	[-EEXIST]	= { "EEXIST",		"Entry already exists" },
 	[-EBADMEM]	= { "EBADMEM",		"Bad memory pointer" },
 
Index: uspace/app/trace/ipcp.c
===================================================================
--- uspace/app/trace/ipcp.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/trace/ipcp.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -303,5 +303,5 @@
 	    (retval == 0)) {
 		/* Connected to a service (through NS) */
-		service = IPC_GET_ARG1(pcall->question);
+		service = IPC_GET_ARG2(pcall->question);
 		proto = proto_get_by_srv(service);
 		if (proto == NULL)
Index: uspace/app/trace/trace.c
===================================================================
--- uspace/app/trace/trace.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/trace/trace.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -57,5 +57,5 @@
 #include "proto.h"
 #include <ipc/services.h>
-#include "../../srv/vfs/vfs.h"
+#include <ipc/vfs.h>
 #include <ipc/console.h>
 
@@ -528,15 +528,15 @@
 	int fd_stderr;
 	
-	if ((stdin != NULL) && (fhandle(stdin, &fd_stdin) == EOK))
+	if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK))
 		files[0] = &fd_stdin;
 	else
 		files[0] = NULL;
 	
-	if ((stdout != NULL) && (fhandle(stdout, &fd_stdout) == EOK))
+	if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK))
 		files[1] = &fd_stdout;
 	else
 		files[1] = NULL;
 	
-	if ((stderr != NULL) && (fhandle(stderr, &fd_stderr) == EOK))
+	if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK))
 		files[2] = &fd_stderr;
 	else
Index: uspace/app/untar/main.c
===================================================================
--- uspace/app/untar/main.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/untar/main.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -103,13 +103,10 @@
 static int handle_directory(const tar_header_t *header, FILE *tarfile)
 {
-	int rc = mkdir(header->filename, 0755);
-	if ((rc == EEXIST) || (rc == EEXISTS)) {
-		// printf("Note: directory %s already exists.\n", header->filename);
-		rc = EOK;
-	}
-	if (rc != EOK) {
-		fprintf(stderr, "Failed to create directory %s: %s.\n",
-		    header->filename, str_error(rc));
-		return rc;
+	if (mkdir(header->filename, 0755) != 0) {
+		if (errno != EEXIST) {
+			fprintf(stderr, "Failed to create directory %s: %s.\n",
+			    header->filename, str_error(errno));
+			return errno;
+		}
 	}
 
Index: uspace/app/viewer/viewer.c
===================================================================
--- uspace/app/viewer/viewer.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/viewer/viewer.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -98,10 +98,10 @@
 {
 	int fd = open(fname, O_RDONLY);
-	if (fd < 0)
+	if (fd != 0)
 		return false;
 	
 	struct stat stat;
 	int rc = fstat(fd, &stat);
-	if (rc != EOK) {
+	if (rc != 0) {
 		close(fd);
 		return false;
@@ -114,5 +114,5 @@
 	}
 	
-	ssize_t rd = read_all(fd, tga, stat.size);
+	ssize_t rd = read(fd, tga, stat.size);
 	if ((rd < 0) || (rd != (ssize_t) stat.size)) {
 		free(tga);
Index: uspace/app/vuhid/device.c
===================================================================
--- uspace/app/vuhid/device.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/vuhid/device.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -123,5 +123,5 @@
 	/* Already used interface. */
 	if (iface->vuhid_data != NULL) {
-		return EEXISTS;
+		return EEXIST;
 	}
 
Index: uspace/app/wifi_supplicant/wifi_supplicant.c
===================================================================
--- uspace/app/wifi_supplicant/wifi_supplicant.c	(revision 2dab624aa5d6fe9c08338ae8393149d20ee5082b)
+++ uspace/app/wifi_supplicant/wifi_supplicant.c	(revision eed70f147d6cb10436c97e198628b915af0bbb95)
@@ -121,5 +121,5 @@
 	
 	async_sess_t *sess =
-	    loc_service_connect(EXCHANGE_SERIALIZE, wifis[i], 0);
+	    loc_service_connect(wifis[i], INTERFACE_DDF, 0);
 	if (sess == NULL) {
 		printf("Error connecting to service.\n");