Changeset ff381a7 in mainline for uspace/app

Timestamp:

2015-11-02T20:54:19Z (10 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

d8513177

Parents:

3feeab2 (diff), 5265eea4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/app

Files:

• barber/barber.c (modified) (1 diff)
• bdsh/cmds/builtins/cd/cd.c (modified) (1 diff)
• bdsh/cmds/modules/cat/cat.c (modified) (1 diff)
• bdsh/cmds/modules/cp/cp.c (modified) (8 diffs)
• bdsh/cmds/modules/ls/ls.c (modified) (4 diffs)
• bdsh/cmds/modules/mkdir/mkdir.c (modified) (5 diffs)
• bdsh/cmds/modules/mkfile/mkfile.c (modified) (4 diffs)
• bdsh/cmds/modules/mount/mount.c (modified) (2 diffs)
• bdsh/cmds/modules/mv/mv.c (modified) (1 diff)
• bdsh/cmds/modules/pwd/pwd.c (modified) (1 diff)
• bdsh/cmds/modules/rm/rm.c (modified) (4 diffs)
• bdsh/cmds/modules/touch/touch.c (modified) (1 diff)
• bdsh/cmds/modules/unmount/unmount.c (modified) (1 diff)
• bdsh/compl.c (modified) (1 diff)
• bdsh/config.h (modified) (1 diff)
• bdsh/errors.h (modified) (1 diff)
• bdsh/exec.c (modified) (2 diffs)
• blkdump/blkdump.c (modified) (1 diff)
• date/date.c (modified) (1 diff)
• df/df.c (modified) (1 diff)
• hdisk/hdisk.c (modified) (1 diff)
• init/init.c (modified) (4 diffs)
• mixerctl/mixerctl.c (modified) (1 diff)
• mkbd/main.c (modified) (1 diff)
• mkexfat/mkexfat.c (modified) (1 diff)
• mkfat/mkfat.c (modified) (1 diff)
• mkmfs/mkmfs.c (modified) (1 diff)
• nic/nic.c (modified) (2 diffs)
• sportdmp/sportdmp.c (modified) (1 diff)
• taskdump/elf_core.c (modified) (6 diffs)
• taskdump/symtab.c (modified) (3 diffs)
• tester/float/float2.c (modified) (5 diffs)
• tester/hw/misc/virtchar1.c (modified) (2 diffs)
• tester/hw/serial/serial1.c (modified) (1 diff)
• tester/mm/common.c (modified) (1 diff)
• tester/tester.h (modified) (1 diff)
• tester/vfs/vfs1.c (modified) (3 diffs)
• tetris/scores.c (modified) (1 diff)
• trace/errors.c (modified) (1 diff)
• trace/ipcp.c (modified) (1 diff)
• trace/trace.c (modified) (2 diffs)
• untar/main.c (modified) (1 diff)
• viewer/viewer.c (modified) (2 diffs)
• vuhid/device.c (modified) (1 diff)
• wifi_supplicant/wifi_supplicant.c (modified) (1 diff)

uspace/app/barber/barber.c

@@ -267 +267 @@
                         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);

uspace/app/bdsh/cmds/builtins/cd/cd.c

@@ -57 +57 @@
         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);

uspace/app/bdsh/cmds/modules/cat/cat.c

@@ -244 +244 @@
                 
                 bytes = read(fd, buff + copied_bytes, bytes_to_read);
-                bytes += copied_bytes;
                 copied_bytes = 0;
 

uspace/app/bdsh/cmds/modules/cp/cp.c

@@ -27 +27 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -84 +85 @@
         int r = stat(path, &s);
 
-        if (r)
+        if (r != 0)
                 return TYPE_NONE;
         else if (s.is_directory)
@@ -234 +235 @@
                          */
                         if (force && !interactive) {
-                                if (unlink(dest_path)) {
+                                if (unlink(dest_path) != 0) {
                                         printf("Unable to remove %s\n",
                                             dest_path);
@@ -245 +246 @@
                                 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 +295 @@
                                 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 +309 @@
                          * 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 +406 @@
         }
 
-        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 +413 @@
 
         if (bytes < 0) {
-                printf("\nError copying %s, (%d)\n", src, bytes);
+                printf("\nError copying %s, (%d)\n", src, errno);
                 copied = bytes;
         }

uspace/app/bdsh/cmds/modules/ls/ls.c

@@ -31 +31 @@
  * As more stuff is completed and exposed in libc, this will improve */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -187 +188 @@
                 if (rc != 0) {
                         printf("ls: skipping bogus node %s\n", buff);
-                        printf("rc=%d\n", rc);
+                        printf("error=%d\n", errno);
                         goto out;
                 }
@@ -314 +315 @@
 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 +377 @@
                 }
         }
-        
+
         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);

uspace/app/bdsh/cmds/modules/mkdir/mkdir.c

@@ -89 +89 @@
 {
         /* 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 +95 @@
         }
 
-        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 +135 @@
                         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 +146 @@
                 }
                 /* 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 +207 @@
 
         if (follow && (argv[optind] != NULL)) {
-                chdir(argv[optind]);
+                if (chdir(argv[optind]) != 0)
+                        printf("%s: Error switching to directory.", cmdname);
         }
 

uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

@@ -27 +27 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -166 +167 @@
 
                 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 +186 @@
                 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 +194 @@
 
         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;
 }

uspace/app/bdsh/cmds/modules/mount/mount.c

@@ -72 +72 @@
         int rc;
 
-        get_mtab_list(&mtab_list);
+        vfs_get_mtab_list(&mtab_list);
 
         list_foreach(mtab_list, link, mtab_ent_t, mtab_ent) {
@@ -150 +150 @@
                 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",

uspace/app/bdsh/cmds/modules/mv/mv.c

@@ -60 +60 @@
 
         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;
         }

uspace/app/bdsh/cmds/modules/pwd/pwd.c

@@ -56 +56 @@
 
         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");

uspace/app/bdsh/cmds/modules/rm/rm.c

@@ -27 +27 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -131 +132 @@
 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 +151 @@
 
         fd = open(path, O_RDONLY);
-        if (fd > 0) {
+        if (fd >= 0) {
                 close(fd);
                 return RM_FILE;
@@ -210 +211 @@
         rc = rmdir(path);
         if (rc == 0)
-                return ret;
+                return errno;
 
         cli_error(CL_ENOTSUP, "Can not remove %s", path);

uspace/app/bdsh/cmds/modules/touch/touch.c

@@ -123 +123 @@
                 
                 /* 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);
                 

uspace/app/bdsh/cmds/modules/unmount/unmount.c

@@ -66 +66 @@
         }
 
-        rc = unmount(argv[1]);
+        rc = vfs_unmount(argv[1]);
         if (rc != EOK) {
                 printf("Unable to unmount %s (rc=%d)\n", argv[1], rc);

uspace/app/bdsh/compl.c

@@ -360 +360 @@
                                 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);

uspace/app/bdsh/config.h

@@ -46 +46 @@
 /* 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 */

uspace/app/bdsh/errors.h

@@ -42 +42 @@
 #define CL_ENOTSUP 6
 #define CL_EEXEC   7
-#define CL_EEXISTS 8
+#define CL_EEXIST  8
 #define CL_ETOOBIG 9
 

uspace/app/bdsh/exec.c

@@ -61 +61 @@
 
         fd = open(f, O_RDONLY);
-        if (fd > -1) {
+        if (fd >= 0) {
                 close(fd);
                 return 0;
@@ -113 +113 @@
         
         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];
                 }

uspace/app/blkdump/blkdump.c

@@ -142 +142 @@
         }
 
-        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+        rc = block_init(service_id, 2048);
         if (rc != EOK)  {
                 printf(NAME ": Error initializing libblock.\n");

uspace/app/date/date.c

@@ -136 +136 @@
 
         /* 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");

uspace/app/df/df.c

@@ -119 +119 @@
 
         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);
+                }
         }
 

uspace/app/hdisk/hdisk.c

@@ -82 +82 @@
         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));

uspace/app/init/init.c

@@ -126 +126 @@
                 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 +143 @@
 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 +152 @@
 {
         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 +299 @@
 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);

uspace/app/mixerctl/mixerctl.c

@@ -155 +155 @@
         }
 
-        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);

uspace/app/mkbd/main.c

@@ -231 +231 @@
         }
         
-        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 %"

uspace/app/mkexfat/mkexfat.c

@@ -803 +803 @@
         }
 
-        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+        rc = block_init(service_id, 2048);
         if (rc != EOK) {
                 printf(NAME ": Error initializing libblock.\n");

uspace/app/mkfat/mkfat.c

@@ -162 +162 @@
         }
 
-        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+        rc = block_init(service_id, 2048);
         if (rc != EOK)  {
                 printf(NAME ": Error initializing libblock.\n");

uspace/app/mkmfs/mkmfs.c

@@ -209 +209 @@
         }
 
-        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+        rc = block_init(service_id, 2048);
         if (rc != EOK)  {
                 printf(NAME ": Error initializing libblock.\n");

uspace/app/nic/nic.c

@@ -99 +99 @@
         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 +117 @@
         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) {

uspace/app/sportdmp/sportdmp.c

@@ -111 +111 @@
 
 
-        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) {

uspace/app/taskdump/elf_core.c

@@ -207 +207 @@
         }
 
-        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 +215 @@
 
         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 +236 @@
         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 +243 @@
         }
 
-        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 +257 @@
         }
 
-        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 +321 @@
                 }
 
-                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");

uspace/app/taskdump/symtab.c

@@ -88 +88 @@
         }
 
-        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 +310 @@
                 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 +346 @@
         }
 
-        rc = read_all(fd, *ptr, size);
+        rc = read(fd, *ptr, size);
         if (rc != (ssize_t) size) {
                 printf("failed reading chunk\n");

uspace/app/tester/float/float2.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2014 Martin Decky
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +28 @@
  */
 
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -32 +34 @@
 #include "../tester.h"
 
-#define OPERANDS   10
-#define PRECISION  100000000
+#define OPERANDS         10
+#define PRECISIONF    10000
+#define PRECISION 100000000
 
 static double arguments[OPERANDS] = {
@@ -39 +42 @@
 };
 
-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 +143 @@
 };
 
-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;
 }

uspace/app/tester/hw/misc/virtchar1.c

@@ -58 +58 @@
         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 +69 @@
         
         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);

uspace/app/tester/hw/serial/serial1.c

@@ -76 +76 @@
                 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)

uspace/app/tester/mm/common.c

@@ -309 +309 @@
                 return NULL;
         
-        unsigned int idx = rand() % mem_blocks_count;
+        unsigned long idx = rand() % mem_blocks_count;
         link_t *entry = list_nth(&mem_blocks, idx);
         

uspace/app/tester/tester.h

@@ -60 +60 @@
         do { \
                 if (!test_quiet) { \
-                        fprintf(stderr, (format), ##__VA_ARGS__); \
+                        fprintf(stdout, (format), ##__VA_ARGS__); \
                 } \
         } while (0)

uspace/app/tester/vfs/vfs1.c

@@ -70 +70 @@
 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 +92 @@
         
         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 +113 @@
                 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);

uspace/app/tetris/scores.c

@@ -233 +233 @@
 
         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);

uspace/app/trace/errors.c

@@ -46 +46 @@
         [-EPERM]        = { "EPERM",            "Permission denied" },
         [-EHANGUP]      = { "EHANGUP",          "Answerbox closed connection" },
-        [-EEXISTS]      = { "EEXISTS",          "Entry already exists" },
+        [-EEXIST]       = { "EEXIST",           "Entry already exists" },
         [-EBADMEM]      = { "EBADMEM",          "Bad memory pointer" },
 

uspace/app/trace/ipcp.c

@@ -303 +303 @@
             (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)

uspace/app/trace/trace.c

@@ -57 +57 @@
 #include "proto.h"
 #include <ipc/services.h>
-#include "../../srv/vfs/vfs.h"
+#include <ipc/vfs.h>
 #include <ipc/console.h>
 
@@ -528 +528 @@
         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

uspace/app/untar/main.c

@@ -103 +103 @@
 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;
+                }
         }
 

uspace/app/viewer/viewer.c

@@ -98 +98 @@
 {
         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 +114 @@
         }
         
-        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);

uspace/app/vuhid/device.c

@@ -123 +123 @@
         /* Already used interface. */
         if (iface->vuhid_data != NULL) {
-                return EEXISTS;
+                return EEXIST;
         }
 

uspace/app/wifi_supplicant/wifi_supplicant.c

@@ -121 +121 @@
         
         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");