Changeset 6afc9d7 in mainline


Ignore:
Timestamp:
2015-10-06T19:01:36Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0328987
Parents:
f1f7584
Message:

UNIX-like I/O functions should use errno to return error code for many reasons.

Files:
51 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/console/console.c

    rf1f7584 r6afc9d7  
    437437        }
    438438
    439         return size;
     439        return EOK;
    440440}
    441441
  • uspace/app/bdsh/cmds/builtins/cd/cd.c

    rf1f7584 r6afc9d7  
    5757        previous_directory_set = true;
    5858
    59         int rc = chdir(new_dir);
    60         if (rc != EOK) {
    61                 return rc;
    62         }
     59        if (chdir(new_dir) != 0)
     60                return errno;
    6361
    6462        str_cpy(previous_directory, PATH_MAX, previous_directory_tmp);
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    rf1f7584 r6afc9d7  
    244244               
    245245                bytes = read(fd, buff + copied_bytes, bytes_to_read);
    246                 bytes += copied_bytes;
    247246                copied_bytes = 0;
    248247
  • uspace/app/bdsh/cmds/modules/cp/cp.c

    rf1f7584 r6afc9d7  
    2727 */
    2828
     29#include <errno.h>
    2930#include <stdio.h>
    3031#include <stdlib.h>
     
    8485        int r = stat(path, &s);
    8586
    86         if (r)
     87        if (r != 0)
    8788                return TYPE_NONE;
    8889        else if (s.is_directory)
     
    234235                         */
    235236                        if (force && !interactive) {
    236                                 if (unlink(dest_path)) {
     237                                if (unlink(dest_path) != 0) {
    237238                                        printf("Unable to remove %s\n",
    238239                                            dest_path);
     
    245246                                if (overwrite) {
    246247                                        printf("Overwriting file: %s\n", dest_path);
    247                                         if (unlink(dest_path)) {
     248                                        if (unlink(dest_path) != 0) {
    248249                                                printf("Unable to remove %s\n", dest_path);
    249250                                                goto exit;
     
    294295                                merge_paths(dest_path, PATH_MAX, src_dirname);
    295296
    296                                 if (mkdir(dest_path, 0) == -1) {
     297                                if (mkdir(dest_path, 0) != 0) {
    297298                                        printf("Unable to create "
    298299                                            "dest directory %s\n", dest_path);
     
    308309                         * e.g. cp -r /src /data/new_dir_src
    309310                         */
    310                         if (mkdir(dest_path, 0)) {
     311                        if (mkdir(dest_path, 0) != 0) {
    311312                                printf("Unable to create "
    312313                                    "dest directory %s\n", dest_path);
     
    405406        }
    406407
    407         while ((bytes = read_all(fd1, buff, blen)) > 0) {
    408                 if ((bytes = write_all(fd2, buff, bytes)) < 0)
     408        while ((bytes = read(fd1, buff, blen)) > 0) {
     409                if ((bytes = write(fd2, buff, bytes)) < 0)
    409410                        break;
    410411                copied += bytes;
     
    412413
    413414        if (bytes < 0) {
    414                 printf("\nError copying %s, (%d)\n", src, bytes);
     415                printf("\nError copying %s, (%d)\n", src, errno);
    415416                copied = bytes;
    416417        }
  • uspace/app/bdsh/cmds/modules/ls/ls.c

    rf1f7584 r6afc9d7  
    3131 * As more stuff is completed and exposed in libc, this will improve */
    3232
     33#include <errno.h>
    3334#include <stdio.h>
    3435#include <stdlib.h>
     
    187188                if (rc != 0) {
    188189                        printf("ls: skipping bogus node %s\n", buff);
    189                         printf("rc=%d\n", rc);
     190                        printf("error=%d\n", errno);
    190191                        goto out;
    191192                }
     
    314315static unsigned int ls_scope(const char *path, struct dir_elem_t *de)
    315316{
    316         if (stat(path, &de->s)) {
     317        if (stat(path, &de->s) != 0) {
    317318                cli_error(CL_ENOENT, "%s", path);
    318319                return LS_BOGUS;
     
    376377                }
    377378        }
    378        
     379
    379380        argc -= optind;
    380        
     381
    381382        de.name = (char *) malloc(PATH_MAX);
    382383        if (!de.name) {
    383                 cli_error(CL_ENOMEM, "%s: ", cmdname);
     384                cli_error(CL_ENOMEM, "%s: Out of memory", cmdname);
    384385                return CMD_FAILURE;
    385386        }
    386387        memset(de.name, 0, PATH_MAX);
    387        
    388         if (argc == 0)
    389                 getcwd(de.name, PATH_MAX);
    390         else
     388
     389        if (argc == 0) {
     390                if (getcwd(de.name, PATH_MAX) == NULL) {
     391                        cli_error(CL_EFAIL, "%s: Failed determining working "
     392                            "directory", cmdname);
     393                        return CMD_FAILURE;
     394                }
     395        } else {
    391396                str_cpy(de.name, PATH_MAX, argv[optind]);
     397        }
    392398
    393399        scope = ls_scope(de.name, &de);
  • uspace/app/bdsh/cmds/modules/mkdir/mkdir.c

    rf1f7584 r6afc9d7  
    8989{
    9090        /* Ensure we would always work with absolute and canonified path. */
    91         char *path = absolutize(user_path, NULL);
     91        char *path = vfs_absolutize(user_path, NULL);
    9292        if (path == NULL) {
    9393                cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
     
    9595        }
    9696
    97         int rc;
    9897        int ret = 0;
    9998
    10099        if (!create_parents) {
    101                 rc = mkdir(path, 0);
    102                 if (rc != EOK) {
     100                if (mkdir(path, 0) != 0) {
    103101                        cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    104                             cmdname, path, str_error(rc));
     102                            cmdname, path, str_error(errno));
    105103                        ret = 1;
    106104                }
     
    137135                        char slash_char = path[prev_off];
    138136                        path[prev_off] = 0;
    139                         rc = mkdir(path, 0);
    140                         if (rc == EEXIST) {
    141                                 rc = EOK;
    142                         }
    143 
    144                         if (rc != EOK) {
     137
     138                        if (mkdir(path, 0) != 0 && errno != EEXIST) {
    145139                                cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    146                                     cmdname, path, str_error(rc));
     140                                    cmdname, path, str_error(errno));
    147141                                ret = 1;
    148142                                goto leave;
     
    152146                }
    153147                /* Create the final directory. */
    154                 rc = mkdir(path, 0);
    155                 if (rc != EOK) {
     148                if (mkdir(path, 0) != 0) {
    156149                        cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    157                             cmdname, path, str_error(rc));
     150                            cmdname, path, str_error(errno));
    158151                        ret = 1;
    159152                }
     
    214207
    215208        if (follow && (argv[optind] != NULL)) {
    216                 chdir(argv[optind]);
     209                if (chdir(argv[optind]) != 0)
     210                        printf("%s: Error switching to directory.", cmdname);
    217211        }
    218212
  • uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

    rf1f7584 r6afc9d7  
    2727 */
    2828
     29#include <errno.h>
    2930#include <stdio.h>
    3031#include <stdlib.h>
     
    166167
    167168                if ((rc2 = lseek(fd, file_size - 1, SEEK_SET)) < 0)
    168                         goto exit;
     169                        goto error;
    169170
    170171                rc2 = write(fd, &byte, sizeof(char));
    171                 goto exit;
     172                if (rc2 < 0)
     173                        goto error;
     174                return CMD_SUCCESS;
    172175        }
    173176
     
    183186                rc = write(fd, buffer, to_write);
    184187                if (rc <= 0) {
    185                         printf("%s: Error writing file (%zd).\n", cmdname, rc);
     188                        printf("%s: Error writing file (%d).\n", cmdname, errno);
    186189                        close(fd);
    187190                        return CMD_FAILURE;
     
    191194
    192195        free(buffer);
    193 exit:
    194         rc = close(fd);
    195 
    196         if (rc != 0 || rc2 < 0) {
    197                 printf("%s: Error writing file (%zd).\n", cmdname, rc);
    198                 return CMD_FAILURE;
    199         }
     196
     197        if (close(fd) < 0)
     198                goto error;
    200199
    201200        return CMD_SUCCESS;
     201error:
     202        printf("%s: Error writing file (%d).\n", cmdname, errno);
     203        return CMD_FAILURE;
    202204}
  • uspace/app/bdsh/cmds/modules/mount/mount.c

    rf1f7584 r6afc9d7  
    7272        int rc;
    7373
    74         get_mtab_list(&mtab_list);
     74        vfs_get_mtab_list(&mtab_list);
    7575
    7676        list_foreach(mtab_list, link, mtab_ent_t, mtab_ent) {
     
    150150                mopts = t_argv[4];
    151151
    152         rc = mount(t_argv[1], t_argv[2], dev, mopts, 0, instance);
     152        rc = vfs_mount(t_argv[1], t_argv[2], dev, mopts, 0, instance);
    153153        if (rc != EOK) {
    154154                printf("Unable to mount %s filesystem to %s on %s (rc=%d)\n",
  • uspace/app/bdsh/cmds/modules/mv/mv.c

    rf1f7584 r6afc9d7  
    6060
    6161        rc = rename(argv[1], argv[2]);
    62         if (rc != EOK) {
    63                 printf("Unable to rename %s to %s (rc=%d)\n",
    64                     argv[1], argv[2], rc);
     62        if (rc != 0) {
     63                printf("Unable to rename %s to %s (error=%d)\n",
     64                    argv[1], argv[2], errno);
    6565                return CMD_FAILURE;
    6666        }
  • uspace/app/bdsh/cmds/modules/pwd/pwd.c

    rf1f7584 r6afc9d7  
    5656
    5757        memset(buff, 0, PATH_MAX);
    58         getcwd(buff, PATH_MAX);
    5958
    60         if (! buff) {
     59        if (getcwd(buff, PATH_MAX) == NULL) {
    6160                cli_error(CL_EFAIL,
    6261                        "Unable to determine the current working directory");
  • uspace/app/bdsh/cmds/modules/rm/rm.c

    rf1f7584 r6afc9d7  
    2727 */
    2828
     29#include <errno.h>
    2930#include <stdio.h>
    3031#include <stdlib.h>
     
    131132static unsigned int rm_single(const char *path)
    132133{
    133         if (unlink(path)) {
     134        if (unlink(path) != 0) {
    134135                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
    135136                return 1;
     
    150151
    151152        fd = open(path, O_RDONLY);
    152         if (fd > 0) {
     153        if (fd >= 0) {
    153154                close(fd);
    154155                return RM_FILE;
     
    210211        rc = rmdir(path);
    211212        if (rc == 0)
    212                 return ret;
     213                return errno;
    213214
    214215        cli_error(CL_ENOTSUP, "Can not remove %s", path);
  • uspace/app/bdsh/cmds/modules/touch/touch.c

    rf1f7584 r6afc9d7  
    123123               
    124124                /* Check whether file exists if -c (--no-create) option is given */
    125                 if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == EOK)))
     125                if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == 0)))
    126126                        fd = open(buff, O_RDWR | O_CREAT);
    127127               
  • uspace/app/bdsh/cmds/modules/unmount/unmount.c

    rf1f7584 r6afc9d7  
    6666        }
    6767
    68         rc = unmount(argv[1]);
     68        rc = vfs_unmount(argv[1]);
    6969        if (rc != EOK) {
    7070                printf("Unable to unmount %s (rc=%d)\n", argv[1], rc);
  • uspace/app/bdsh/compl.c

    rf1f7584 r6afc9d7  
    360360                                asprintf(&ent_path, "%s/%s", *cs->path, dent->d_name);
    361361                                struct stat ent_stat;
    362                                 if (stat(ent_path, &ent_stat) != EOK) {
     362                                if (stat(ent_path, &ent_stat) != 0) {
    363363                                        /* Error */
    364364                                        free(ent_path);
  • uspace/app/bdsh/exec.c

    rf1f7584 r6afc9d7  
    6161
    6262        fd = open(f, O_RDONLY);
    63         if (fd > -1) {
     63        if (fd >= 0) {
    6464                close(fd);
    6565                return 0;
     
    113113       
    114114        for (i = 0; i < 3 && files[i] != NULL; i++) {
    115                 if (fhandle(files[i], &file_handles[i]) == EOK) {
     115                if (vfs_fhandle(files[i], &file_handles[i]) == EOK) {
    116116                        file_handles_p[i] = &file_handles[i];
    117117                }
  • uspace/app/df/df.c

    rf1f7584 r6afc9d7  
    119119
    120120        LIST_INITIALIZE(mtab_list);
    121         get_mtab_list(&mtab_list);
     121        vfs_get_mtab_list(&mtab_list);
    122122
    123123        print_header();
    124124        list_foreach(mtab_list, link, mtab_ent_t, mtab_ent) {
    125                 statfs(mtab_ent->mp, &st);
    126                 print_statfs(&st, mtab_ent->fs_name, mtab_ent->mp);
     125                if (statfs(mtab_ent->mp, &st) == 0) {
     126                        print_statfs(&st, mtab_ent->fs_name, mtab_ent->mp);
     127                } else {
     128                        fprintf(stderr, "Cannot get information for '%s' (%d).\n",
     129                            mtab_ent->mp, errno);
     130                }
    127131        }
    128132
  • uspace/app/init/init.c

    rf1f7584 r6afc9d7  
    126126                opts = "restore";
    127127       
    128         int rc = mount(fstype, ROOT_MOUNT_POINT, ROOT_DEVICE, opts,
     128        int rc = vfs_mount(fstype, ROOT_MOUNT_POINT, ROOT_DEVICE, opts,
    129129            IPC_FLAG_BLOCKING, 0);
    130130        return mount_report("Root filesystem", ROOT_MOUNT_POINT, fstype,
     
    143143static bool mount_locfs(void)
    144144{
    145         int rc = mount(LOCFS_FS_TYPE, LOCFS_MOUNT_POINT, "", "",
     145        int rc = vfs_mount(LOCFS_FS_TYPE, LOCFS_MOUNT_POINT, "", "",
    146146            IPC_FLAG_BLOCKING, 0);
    147147        return mount_report("Location service filesystem", LOCFS_MOUNT_POINT,
     
    152152{
    153153        struct stat s;
    154         if (stat(path, &s) == ENOENT) {
     154        if (stat(path, &s) != 0) {
    155155                printf("%s: Unable to stat %s\n", NAME, path);
    156156                return ENOENT;
     
    299299static bool mount_tmpfs(void)
    300300{
    301         int rc = mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0, 0);
     301        int rc = vfs_mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0, 0);
    302302        return mount_report("Temporary filesystem", TMPFS_MOUNT_POINT,
    303303            TMPFS_FS_TYPE, NULL, rc);
  • uspace/app/taskdump/elf_core.c

    rf1f7584 r6afc9d7  
    207207        }
    208208
    209         rc = write_all(fd, &elf_hdr, sizeof(elf_hdr));
     209        rc = write(fd, &elf_hdr, sizeof(elf_hdr));
    210210        if (rc != sizeof(elf_hdr)) {
    211211                printf("Failed writing ELF header.\n");
     
    215215
    216216        for (i = 0; i < n_ph; ++i) {
    217                 rc = write_all(fd, &p_hdr[i], sizeof(p_hdr[i]));
     217                rc = write(fd, &p_hdr[i], sizeof(p_hdr[i]));
    218218                if (rc != sizeof(p_hdr[i])) {
    219219                        printf("Failed writing program header.\n");
     
    236236        note.type = NT_PRSTATUS;
    237237
    238         rc = write_all(fd, &note, sizeof(elf_note_t));
     238        rc = write(fd, &note, sizeof(elf_note_t));
    239239        if (rc != sizeof(elf_note_t)) {
    240240                printf("Failed writing note header.\n");
     
    243243        }
    244244
    245         rc = write_all(fd, "CORE", note.namesz);
     245        rc = write(fd, "CORE", note.namesz);
    246246        if (rc != (ssize_t) note.namesz) {
    247247                printf("Failed writing note header.\n");
     
    257257        }
    258258
    259         rc = write_all(fd, &pr_status, sizeof(elf_prstatus_t));
     259        rc = write(fd, &pr_status, sizeof(elf_prstatus_t));
    260260        if (rc != sizeof(elf_prstatus_t)) {
    261261                printf("Failed writing register data.\n");
     
    321321                }
    322322
    323                 rc = write_all(fd, buffer, to_copy);
     323                rc = write(fd, buffer, to_copy);
    324324                if (rc != (ssize_t) to_copy) {
    325325                        printf("Failed writing memory contents.\n");
  • uspace/app/taskdump/symtab.c

    rf1f7584 r6afc9d7  
    8888        }
    8989
    90         rc = read_all(fd, &elf_hdr, sizeof(elf_header_t));
     90        rc = read(fd, &elf_hdr, sizeof(elf_header_t));
    9191        if (rc != sizeof(elf_header_t)) {
    9292                printf("failed reading elf header\n");
     
    310310                return EIO;
    311311
    312         rc = read_all(fd, sec_hdr, sizeof(elf_section_header_t));
     312        rc = read(fd, sec_hdr, sizeof(elf_section_header_t));
    313313        if (rc != sizeof(elf_section_header_t))
    314314                return EIO;
     
    346346        }
    347347
    348         rc = read_all(fd, *ptr, size);
     348        rc = read(fd, *ptr, size);
    349349        if (rc != (ssize_t) size) {
    350350                printf("failed reading chunk\n");
  • uspace/app/tester/hw/misc/virtchar1.c

    rf1f7584 r6afc9d7  
    5858        int fd = open(path, O_RDONLY);
    5959        if (fd < 0) {
    60                 TPRINTF("   ...error: %s\n", str_error(fd));
     60                TPRINTF("   ...error: %s\n", str_error(errno));
    6161                if (fd == ENOENT) {
    6262                        TPRINTF("   (error was ENOENT: " \
     
    6969       
    7070        TPRINTF(" Asking for session...\n");
    71         async_sess_t *sess = fd_session(fd, INTERFACE_DDF);
     71        async_sess_t *sess = vfs_fd_session(fd, INTERFACE_DDF);
    7272        if (!sess) {
    7373                close(fd);
  • uspace/app/tester/vfs/vfs1.c

    rf1f7584 r6afc9d7  
    7070const char *test_vfs1(void)
    7171{
    72         int rc;
    73         if ((rc = mkdir(TEST_DIRECTORY, 0)) != 0) {
    74                 TPRINTF("rc=%d\n", rc);
     72        if (mkdir(TEST_DIRECTORY, 0) != 0) {
     73                TPRINTF("rc=%d\n", errno);
    7574                return "mkdir() failed";
    7675        }
     
    9392       
    9493        char buf[BUF_SIZE];
     94        TPRINTF("read..\n");
    9595        while ((cnt = read(fd0, buf, BUF_SIZE))) {
     96                TPRINTF("read returns %zd\n", cnt);
    9697                if (cnt < 0)
    9798                        return "read() failed";
     
    112113                return rv;
    113114       
    114         if (rename(TEST_FILE, TEST_FILE2))
     115        if (rename(TEST_FILE, TEST_FILE2) != 0)
    115116                return "rename() failed";
    116117        TPRINTF("Renamed %s to %s\n", TEST_FILE, TEST_FILE2);
    117118       
    118         if (unlink(TEST_FILE2))
     119        if (unlink(TEST_FILE2) != 0)
    119120                return "unlink() failed";
    120121        TPRINTF("Unlinked %s\n", TEST_FILE2);
    121122       
    122         if (rmdir(TEST_DIRECTORY))
     123        if (rmdir(TEST_DIRECTORY) != 0)
    123124                return "rmdir() failed";
    124125        TPRINTF("Removed directory %s\n", TEST_DIRECTORY);
  • uspace/app/trace/trace.c

    rf1f7584 r6afc9d7  
    5757#include "proto.h"
    5858#include <ipc/services.h>
    59 #include "../../srv/vfs/vfs.h"
     59#include <ipc/vfs.h>
    6060#include <ipc/console.h>
    6161
     
    528528        int fd_stderr;
    529529       
    530         if ((stdin != NULL) && (fhandle(stdin, &fd_stdin) == EOK))
     530        if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK))
    531531                files[0] = &fd_stdin;
    532532        else
    533533                files[0] = NULL;
    534534       
    535         if ((stdout != NULL) && (fhandle(stdout, &fd_stdout) == EOK))
     535        if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK))
    536536                files[1] = &fd_stdout;
    537537        else
    538538                files[1] = NULL;
    539539       
    540         if ((stderr != NULL) && (fhandle(stderr, &fd_stderr) == EOK))
     540        if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK))
    541541                files[2] = &fd_stderr;
    542542        else
  • uspace/app/untar/main.c

    rf1f7584 r6afc9d7  
    103103static int handle_directory(const tar_header_t *header, FILE *tarfile)
    104104{
    105         int rc = mkdir(header->filename, 0755);
    106         if (rc == EEXIST) {
    107                 // printf("Note: directory %s already exists.\n", header->filename);
    108                 rc = EOK;
    109         }
    110         if (rc != EOK) {
    111                 fprintf(stderr, "Failed to create directory %s: %s.\n",
    112                     header->filename, str_error(rc));
    113                 return rc;
     105        if (mkdir(header->filename, 0755) != 0) {
     106                if (errno != EEXIST) {
     107                        fprintf(stderr, "Failed to create directory %s: %s.\n",
     108                            header->filename, str_error(errno));
     109                        return errno;
     110                }
    114111        }
    115112
  • uspace/app/viewer/viewer.c

    rf1f7584 r6afc9d7  
    9898{
    9999        int fd = open(fname, O_RDONLY);
    100         if (fd < 0)
     100        if (fd != 0)
    101101                return false;
    102102       
    103103        struct stat stat;
    104104        int rc = fstat(fd, &stat);
    105         if (rc != EOK) {
     105        if (rc != 0) {
    106106                close(fd);
    107107                return false;
     
    114114        }
    115115       
    116         ssize_t rd = read_all(fd, tga, stat.size);
     116        ssize_t rd = read(fd, tga, stat.size);
    117117        if ((rd < 0) || (rd != (ssize_t) stat.size)) {
    118118                free(tga);
  • uspace/drv/bus/isa/isa.c

    rf1f7584 r6afc9d7  
    270270        }
    271271
    272         r = read_all(fd, buf, len);
     272        r = read(fd, buf, len);
    273273        if (r < 0) {
    274274                ddf_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
  • uspace/lib/bithenge/src/file.c

    rf1f7584 r6afc9d7  
    114114        struct stat stat;
    115115        int rc = fstat(fd, &stat);
    116         if (rc != EOK) {
     116        if (rc != 0) {
    117117                if (needs_close)
    118118                        close(fd);
     
    157157        int fd = open(filename, O_RDONLY);
    158158        if (fd < 0)
    159                 return fd;
     159                return errno;
    160160
    161161        return new_file_blob(out, fd, true);
  • uspace/lib/c/generic/elf/elf_load.c

    rf1f7584 r6afc9d7  
    9797        int fd;
    9898        int rc;
    99        
     99
    100100        fd = open(file_name, O_RDONLY);
    101101        if (fd < 0) {
     
    147147        int i, rc;
    148148
    149         rc = read_all(elf->fd, header, sizeof(elf_header_t));
     149        rc = read(elf->fd, header, sizeof(elf_header_t));
    150150        if (rc != sizeof(elf_header_t)) {
    151151                DPRINTF("Read error.\n");
     
    209209                        + i * sizeof(elf_segment_header_t), SEEK_SET);
    210210
    211                 rc = read_all(elf->fd, &segment_hdr,
     211                rc = read(elf->fd, &segment_hdr,
    212212                    sizeof(elf_segment_header_t));
    213213                if (rc != sizeof(elf_segment_header_t)) {
     
    231231                    + i * sizeof(elf_section_header_t), SEEK_SET);
    232232
    233                 rc = read_all(elf->fd, &section_hdr,
     233                rc = read(elf->fd, &section_hdr,
    234234                    sizeof(elf_section_header_t));
    235235                if (rc != sizeof(elf_section_header_t)) {
     
    399399                if (now > left) now = left;
    400400
    401                 rc = read_all(elf->fd, dp, now);
     401                rc = read(elf->fd, dp, now);
    402402
    403403                if (rc != (ssize_t) now) {
  • uspace/lib/c/generic/io/console.c

    rf1f7584 r6afc9d7  
    4949                return NULL;
    5050       
    51         ctrl->input_sess = fsession(ifile, INTERFACE_CONSOLE);
     51        ctrl->input_sess = vfs_fsession(ifile, INTERFACE_CONSOLE);
    5252        if (!ctrl->input_sess) {
    5353                free(ctrl);
     
    5555        }
    5656       
    57         ctrl->output_sess = fsession(ofile, INTERFACE_CONSOLE);
     57        ctrl->output_sess = vfs_fsession(ofile, INTERFACE_CONSOLE);
    5858        if (!ctrl->output_sess) {
    5959                free(ctrl);
  • uspace/lib/c/generic/io/io.c

    rf1f7584 r6afc9d7  
    231231        if (stream->buf == NULL) {
    232232                errno = ENOMEM;
    233                 return -1;
     233                return EOF;
    234234        }
    235235       
     
    365365 * @param nmemb  Number of records to read.
    366366 * @param stream Pointer to the stream.
     367 *
     368 * @return Number of elements successfully read. On error this is less than
     369 *         nmemb, stream error indicator is set and errno is set.
    367370 */
    368371static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
     
    379382                ssize_t rd = read(stream->fd, buf + done, left);
    380383               
    381                 if (rd < 0)
     384                if (rd < 0) {
     385                        /* errno was set by read() */
    382386                        stream->error = true;
    383                 else if (rd == 0)
     387                } else if (rd == 0) {
    384388                        stream->eof = true;
    385                 else {
     389                } else {
    386390                        left -= rd;
    387391                        done += rd;
     
    398402 * @param nmemb  Number of records to write.
    399403 * @param stream Pointer to the stream.
     404 *
     405 * @return Number of elements successfully written. On error this is less than
     406 *         nmemb, stream error indicator is set and errno is set.
    400407 */
    401408static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
     
    403410        size_t left;
    404411        size_t done;
     412        int rc;
    405413
    406414        if (size == 0 || nmemb == 0)
     
    412420        while ((left > 0) && (!stream->error)) {
    413421                ssize_t wr;
     422                size_t uwr;
    414423               
    415                 if (stream->kio)
    416                         wr = kio_write(buf + done, left);
    417                 else
     424                if (stream->kio) {
     425                        uwr = 0;
     426                        rc = kio_write(buf + done, left, &uwr);
     427                        if (rc != EOK)
     428                                errno = rc;
     429                } else {
    418430                        wr = write(stream->fd, buf + done, left);
     431                        if (wr >= 0) {
     432                                uwr = (size_t)wr;
     433                                rc = EOK;
     434                        } else {
     435                                /* errno was set by write */
     436                                uwr = 0;
     437                                rc = errno;
     438                        }
     439                }
    419440               
    420                 if (wr <= 0)
     441                if (rc != EOK) {
     442                        /* errno was set above */
    421443                        stream->error = true;
    422                 else {
    423                         left -= wr;
    424                         done += wr;
     444                } else {
     445                        left -= uwr;
     446                        done += uwr;
    425447                }
    426448        }
     
    432454}
    433455
    434 /** Read some data in stream buffer. */
     456/** Read some data in stream buffer.
     457 *
     458 * On error, stream error indicator is set and errno is set.
     459 */
    435460static void _ffillbuf(FILE *stream)
    436461{
     
    441466        rc = read(stream->fd, stream->buf, stream->buf_size);
    442467        if (rc < 0) {
     468                /* errno was set by read() */
    443469                stream->error = true;
    444470                return;
     
    465491
    466492        /* If buffer has prefetched read data, we need to seek back. */
    467         if (bytes_used > 0 && stream->buf_state == _bs_read)
    468                 lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
     493        if (bytes_used > 0 && stream->buf_state == _bs_read) {
     494                off64_t rc;
     495                rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
     496                if (rc == (off64_t)-1) {
     497                        /* errno was set by lseek */
     498                        stream->error = 1;
     499                        return;
     500                }
     501        }
    469502
    470503        /* If buffer has unwritten data, we need to write them out. */
    471         if (bytes_used > 0 && stream->buf_state == _bs_write)
     504        if (bytes_used > 0 && stream->buf_state == _bs_write) {
    472505                (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
     506                /* On error stream error indicator and errno are set by _fwrite */
     507                if (stream->error)
     508                        return;
     509        }
    473510
    474511        stream->buf_head = stream->buf;
     
    528565                        _ffillbuf(stream);
    529566
    530                 if (stream->error || stream->eof)
     567                if (stream->error || stream->eof) {
     568                        /* On error errno was set by _ffillbuf() */
    531569                        break;
     570                }
    532571
    533572                data_avail = stream->buf_head - stream->buf_tail;
     
    584623        if (stream->buf_state == _bs_read)
    585624                _fflushbuf(stream);
    586 
    587625
    588626        /* Perform lazy allocation of stream buffer. */
     
    622660                        /* Only need to drain buffer. */
    623661                        _fflushbuf(stream);
    624                         need_flush = false;
     662                        if (!stream->error)
     663                                need_flush = false;
    625664                }
    626665        }
     
    734773        off64_t rc;
    735774
     775        if (stream->error)
     776                return EOF;
     777
    736778        _fflushbuf(stream);
     779        if (stream->error) {
     780                /* errno was set by _fflushbuf() */
     781                return EOF;
     782        }
     783
    737784        stream->ungetc_chars = 0;
    738785
    739786        rc = lseek(stream->fd, offset, whence);
    740787        if (rc == (off64_t) (-1)) {
    741                 /* errno has been set by lseek64. */
    742                 return -1;
     788                /* errno has been set by lseek() */
     789                return EOF;
    743790        }
    744791
     
    749796off64_t ftell(FILE *stream)
    750797{
     798        off64_t pos;
     799       
     800        if (stream->error)
     801                return EOF;
     802       
    751803        _fflushbuf(stream);
    752         return lseek(stream->fd, 0, SEEK_CUR) - stream->ungetc_chars;
     804        if (stream->error) {
     805                /* errno was set by _fflushbuf() */
     806                return EOF;
     807        }
     808
     809        pos = lseek(stream->fd, 0, SEEK_CUR);
     810        if (pos == (off64_t) -1) {
     811                /* errno was set by lseek */
     812                return (off64_t) -1;
     813        }
     814       
     815        return pos - stream->ungetc_chars;
    753816}
    754817
     
    760823int fflush(FILE *stream)
    761824{
     825        if (stream->error)
     826                return EOF;
     827       
    762828        _fflushbuf(stream);
     829        if (stream->error) {
     830                /* errno was set by _fflushbuf() */
     831                return EOF;
     832        }
    763833       
    764834        if (stream->kio) {
    765835                kio_update();
    766                 return EOK;
     836                return 0;
    767837        }
    768838       
     
    773843                 */
    774844                stream->need_sync = false;
    775                 return fsync(stream->fd);
    776         }
    777        
    778         return ENOENT;
     845                if (fsync(stream->fd) != 0) {
     846                        /* errno was set by fsync() */
     847                        return EOF;
     848                }
     849
     850                return 0;
     851        }
     852       
     853        return 0;
    779854}
    780855
     
    799874        if (stream->kio) {
    800875                errno = EBADF;
    801                 return -1;
     876                return EOF;
    802877        }
    803878       
     
    805880}
    806881
    807 async_sess_t *fsession(FILE *stream, iface_t iface)
     882async_sess_t *vfs_fsession(FILE *stream, iface_t iface)
    808883{
    809884        if (stream->fd >= 0) {
    810885                if (stream->sess == NULL)
    811                         stream->sess = fd_session(stream->fd, iface);
     886                        stream->sess = vfs_fd_session(stream->fd, iface);
    812887               
    813888                return stream->sess;
     
    817892}
    818893
    819 int fhandle(FILE *stream, int *handle)
     894int vfs_fhandle(FILE *stream, int *handle)
    820895{
    821896        if (stream->fd >= 0) {
  • uspace/lib/c/generic/io/kio.c

    rf1f7584 r6afc9d7  
    4343#include <io/printf_core.h>
    4444
    45 size_t kio_write(const void *buf, size_t size)
     45int kio_write(const void *buf, size_t size, size_t *nwritten)
    4646{
    47         ssize_t ret = (ssize_t) __SYSCALL3(SYS_KIO, KIO_WRITE, (sysarg_t) buf, size);
     47        int rc = (int) __SYSCALL3(SYS_KIO, KIO_WRITE, (sysarg_t) buf, size);
    4848       
    49         if (ret >= 0)
    50                 return (size_t) ret;
    51        
    52         return 0;
     49        if (rc == EOK)
     50                *nwritten = size;
     51        return rc;
    5352}
    5453
     
    8483static int kio_vprintf_str_write(const char *str, size_t size, void *data)
    8584{
    86         size_t wr = kio_write(str, size);
     85        size_t wr;
     86       
     87        wr = 0;
     88        (void) kio_write(str, size, &wr);
    8789        return str_nlength(str, wr);
    8890}
     
    9294        size_t offset = 0;
    9395        size_t chars = 0;
     96        size_t wr;
    9497       
    9598        while (offset < size) {
     
    98101               
    99102                if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
    100                         kio_write(buf, sz);
     103                        kio_write(buf, sz, &wr);
    101104               
    102105                chars++;
  • uspace/lib/c/generic/loader.c

    rf1f7584 r6afc9d7  
    124124                return ENOMEM;
    125125       
    126         if (!getcwd(cwd, MAX_PATH_LEN + 1))
     126        if (getcwd(cwd, MAX_PATH_LEN + 1) == NULL)
    127127                str_cpy(cwd, MAX_PATH_LEN + 1, "/");
    128128       
     
    162162{
    163163        size_t pa_len;
    164         char *pa = absolutize(path, &pa_len);
     164        char *pa = vfs_absolutize(path, &pa_len);
    165165        if (!pa)
    166166                return ENOMEM;
  • uspace/lib/c/generic/task.c

    rf1f7584 r6afc9d7  
    112112        int fd_stderr;
    113113       
    114         if ((stdin != NULL) && (fhandle(stdin, &fd_stdin) == EOK))
     114        if ((stdin != NULL) && (vfs_fhandle(stdin, &fd_stdin) == EOK))
    115115                files[0] = &fd_stdin;
    116116        else
    117117                files[0] = NULL;
    118118       
    119         if ((stdout != NULL) && (fhandle(stdout, &fd_stdout) == EOK))
     119        if ((stdout != NULL) && (vfs_fhandle(stdout, &fd_stdout) == EOK))
    120120                files[1] = &fd_stdout;
    121121        else
    122122                files[1] = NULL;
    123123       
    124         if ((stderr != NULL) && (fhandle(stderr, &fd_stderr) == EOK))
     124        if ((stderr != NULL) && (vfs_fhandle(stderr, &fd_stderr) == EOK))
    125125                files[2] = &fd_stderr;
    126126        else
  • uspace/lib/c/generic/vfs/vfs.c

    rf1f7584 r6afc9d7  
    9393}
    9494
    95 char *absolutize(const char *path, size_t *retlen)
     95char *vfs_absolutize(const char *path, size_t *retlen)
    9696{
    9797        char *ncwd_path;
     
    101101        size_t size = str_size(path);
    102102        if (*path != '/') {
    103                 if (!cwd_path) {
     103                if (cwd_path == NULL) {
    104104                        fibril_mutex_unlock(&cwd_mutex);
    105105                        return NULL;
    106106                }
    107107                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
    108                 if (!ncwd_path_nc) {
     108                if (ncwd_path_nc == NULL) {
    109109                        fibril_mutex_unlock(&cwd_mutex);
    110110                        return NULL;
     
    115115        } else {
    116116                ncwd_path_nc = malloc(size + 1);
    117                 if (!ncwd_path_nc) {
     117                if (ncwd_path_nc == NULL) {
    118118                        fibril_mutex_unlock(&cwd_mutex);
    119119                        return NULL;
     
    123123        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
    124124        ncwd_path = canonify(ncwd_path_nc, retlen);
    125         if (!ncwd_path) {
     125        if (ncwd_path == NULL) {
    126126                fibril_mutex_unlock(&cwd_mutex);
    127127                free(ncwd_path_nc);
     
    135135        ncwd_path = str_dup(ncwd_path);
    136136        free(ncwd_path_nc);
    137         if (!ncwd_path) {
     137        if (ncwd_path == NULL) {
    138138                fibril_mutex_unlock(&cwd_mutex);
    139139                return NULL;
     
    143143}
    144144
    145 int mount(const char *fs_name, const char *mp, const char *fqsn,
     145int vfs_mount(const char *fs_name, const char *mp, const char *fqsn,
    146146    const char *opts, unsigned int flags, unsigned int instance)
    147147{
     
    171171       
    172172        size_t mpa_size;
    173         char *mpa = absolutize(mp, &mpa_size);
    174         if (!mpa) {
     173        char *mpa = vfs_absolutize(mp, &mpa_size);
     174        if (mpa == NULL) {
    175175                if (null_id != -1)
    176176                        loc_null_destroy(null_id);
     
    255255}
    256256
    257 int unmount(const char *mp)
     257int vfs_unmount(const char *mp)
    258258{
    259259        sysarg_t rc;
     
    263263        char *mpa;
    264264       
    265         mpa = absolutize(mp, &mpa_size);
    266         if (!mpa)
     265        mpa = vfs_absolutize(mp, &mpa_size);
     266        if (mpa == NULL)
    267267                return ENOMEM;
    268268       
     
    289289}
    290290
    291 static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
     291/** Open file (internal).
     292 *
     293 * @param abs Absolute path to file
     294 * @param abs_size Size of @a abs string
     295 * @param lflag L_xxx flags
     296 * @param oflag O_xxx flags
     297 * @param fd Place to store new file descriptor
     298 *
     299 * @return EOK on success, non-zero error code on error
     300 */
     301static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag,
     302    int *fd)
    292303{
    293304        async_exch_t *exch = vfs_exchange_begin();
     
    315326            return (int) rc;
    316327       
    317         return (int) IPC_GET_ARG1(answer);
    318 }
    319 
     328        *fd = (int) IPC_GET_ARG1(answer);
     329        return EOK;
     330}
     331
     332/** Open file.
     333 *
     334 * @param path File path
     335 * @param oflag O_xxx flags
     336 * @param mode File mode (only with O_CREAT)
     337 *
     338 * @return Nonnegative file descriptor on success. On error -1 is returned
     339 *         and errno is set.
     340 */
    320341int open(const char *path, int oflag, ...)
    321342{
    322343        size_t abs_size;
    323         char *abs = absolutize(path, &abs_size);
    324         if (!abs)
    325                 return ENOMEM;
    326        
    327         int ret = open_internal(abs, abs_size, L_FILE, oflag);
     344        char *abs = vfs_absolutize(path, &abs_size);
     345        int fd = -1;
     346       
     347        if (abs == NULL) {
     348                errno = ENOMEM;
     349                return -1;
     350        }
     351       
     352        int rc = open_internal(abs, abs_size, L_FILE, oflag, &fd);
    328353        free(abs);
    329354       
    330         return ret;
    331 }
    332 
     355        if (rc != EOK) {
     356                errno = rc;
     357                return -1;
     358        }
     359       
     360        return fd;
     361}
     362
     363/** Close file.
     364 *
     365 * @param fildes File descriptor
     366 * @return Zero on success. On error -1 is returned and errno is set.
     367 */
    333368int close(int fildes)
    334369{
     
    339374        vfs_exchange_end(exch);
    340375       
    341         return (int) rc;
    342 }
    343 
    344 ssize_t read(int fildes, void *buf, size_t nbyte)
     376        if (rc != EOK) {
     377                errno = rc;
     378                return -1;
     379        }
     380       
     381        return 0;
     382}
     383
     384/** Read bytes from file.
     385 *
     386 * Read up to @a nbyte bytes from file. The actual number of bytes read
     387 * may be lower, but greater than zero if there are any bytes available.
     388 * If there are no bytes available for reading, then the function will
     389 * return success with zero bytes read.
     390 *
     391 * @param fildes File descriptor
     392 * @param buf Buffer
     393 * @param nbyte Maximum number of bytes to read
     394 * @param nread Place to store actual number of bytes read (0 or more)
     395 *
     396 * @return EOK on success, non-zero error code on error.
     397 */
     398static int _read_short(int fildes, void *buf, size_t nbyte, ssize_t *nread)
    345399{
    346400        sysarg_t rc;
     
    357411        if (rc != EOK) {
    358412                vfs_exchange_end(exch);
    359 
     413               
    360414                sysarg_t rc_orig;
    361415                async_wait_for(req, &rc_orig);
    362 
     416               
    363417                if (rc_orig == EOK)
    364                         return (ssize_t) rc;
     418                        return rc;
    365419                else
    366                         return (ssize_t) rc_orig;
    367         }
     420                        return rc_orig;
     421        }
     422       
    368423        vfs_exchange_end(exch);
    369424        async_wait_for(req, &rc);
    370         if (rc == EOK)
    371                 return (ssize_t) IPC_GET_ARG1(answer);
    372         else
     425       
     426        if (rc != EOK)
    373427                return rc;
    374 }
    375 
    376 ssize_t write(int fildes, const void *buf, size_t nbyte)
     428       
     429        *nread = (ssize_t) IPC_GET_ARG1(answer);
     430        return EOK;
     431}
     432
     433/** Write bytes to file.
     434 *
     435 * Write up to @a nbyte bytes from file. The actual number of bytes written
     436 * may be lower, but greater than zero.
     437 *
     438 * @param fildes File descriptor
     439 * @param buf Buffer
     440 * @param nbyte Maximum number of bytes to write
     441 * @param nread Place to store actual number of bytes written (0 or more)
     442 *
     443 * @return EOK on success, non-zero error code on error.
     444 */
     445static int _write_short(int fildes, const void *buf, size_t nbyte,
     446    ssize_t *nwritten)
    377447{
    378448        sysarg_t rc;
     
    389459        if (rc != EOK) {
    390460                vfs_exchange_end(exch);
    391 
     461               
    392462                sysarg_t rc_orig;
    393463                async_wait_for(req, &rc_orig);
    394 
     464               
    395465                if (rc_orig == EOK)
    396                         return (ssize_t) rc;
     466                        return rc;
    397467                else
    398                         return (ssize_t) rc_orig;
    399         }
     468                        return rc_orig;
     469        }
     470       
    400471        vfs_exchange_end(exch);
    401472        async_wait_for(req, &rc);
    402         if (rc == EOK)
    403                 return (ssize_t) IPC_GET_ARG1(answer);
    404         else
    405                 return -1;
    406 }
    407 
    408 /** Read entire buffer.
    409  *
    410  * In face of short reads this function continues reading until either
    411  * the entire buffer is read or no more data is available (at end of file).
     473       
     474        if (rc != EOK)
     475                return rc;
     476       
     477        *nwritten = (ssize_t) IPC_GET_ARG1(answer);
     478        return EOK;
     479}
     480
     481/** Read data.
     482 *
     483 * Read up to @a nbytes bytes from file if available. This function always reads
     484 * all the available bytes up to @a nbytes.
    412485 *
    413486 * @param fildes        File descriptor
     
    415488 * @param nbytes        Number of bytes to read
    416489 *
    417  * @return              On success, positive number of bytes read.
    418  *                      On failure, negative error code from read().
    419  */
    420 ssize_t read_all(int fildes, void *buf, size_t nbyte)
     490 * @return              On success, nonnegative number of bytes read.
     491 *                      On failure, -1 and sets errno.
     492 */
     493ssize_t read(int fildes, void *buf, size_t nbyte)
    421494{
    422495        ssize_t cnt = 0;
    423496        size_t nread = 0;
    424497        uint8_t *bp = (uint8_t *) buf;
    425 
     498        int rc;
     499       
    426500        do {
    427501                bp += cnt;
    428502                nread += cnt;
    429                 cnt = read(fildes, bp, nbyte - nread);
    430         } while (cnt > 0 && (nbyte - nread - cnt) > 0);
    431 
    432         if (cnt < 0)
    433                 return cnt;
    434 
     503                rc = _read_short(fildes, bp, nbyte - nread, &cnt);
     504        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
     505       
     506        if (rc != EOK) {
     507                errno = rc;
     508                return -1;
     509        }
     510       
    435511        return nread + cnt;
    436512}
    437513
    438 /** Write entire buffer.
     514/** Write data.
    439515 *
    440516 * This function fails if it cannot write exactly @a len bytes to the file.
     
    444520 * @param nbytes        Number of bytes to write
    445521 *
    446  * @return              EOK on error, return value from write() if writing
    447  *                      failed.
    448  */
    449 ssize_t write_all(int fildes, const void *buf, size_t nbyte)
     522 * @return              On success, nonnegative number of bytes written.
     523 *                      On failure, -1 and sets errno.
     524 */
     525ssize_t write(int fildes, const void *buf, size_t nbyte)
    450526{
    451527        ssize_t cnt = 0;
    452528        ssize_t nwritten = 0;
    453529        const uint8_t *bp = (uint8_t *) buf;
     530        int rc;
    454531
    455532        do {
    456533                bp += cnt;
    457534                nwritten += cnt;
    458                 cnt = write(fildes, bp, nbyte - nwritten);
    459         } while (cnt > 0 && ((ssize_t )nbyte - nwritten - cnt) > 0);
    460 
    461         if (cnt < 0)
    462                 return cnt;
    463 
    464         if ((ssize_t)nbyte - nwritten - cnt > 0)
    465                 return EIO;
     535                rc = _write_short(fildes, bp, nbyte - nwritten, &cnt);
     536        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
     537
     538        if (rc != EOK) {
     539                errno = rc;
     540                return -1;
     541        }
    466542
    467543        return nbyte;
    468544}
    469545
     546/** Synchronize file.
     547 *
     548 * @param fildes File descriptor
     549 * @return 0 on success. On error returns -1 and sets errno.
     550 */
    470551int fsync(int fildes)
    471552{
     
    474555        vfs_exchange_end(exch);
    475556       
    476         return (int) rc;
    477 }
    478 
     557        if (rc != EOK) {
     558                errno = rc;
     559                return -1;
     560        }
     561       
     562        return 0;
     563}
     564
     565/** Seek to a position.
     566 *
     567 * @param fildes File descriptor
     568 * @param offset Offset
     569 * @param whence SEEK_SET, SEEK_CUR or SEEK_END
     570 *
     571 * @return On success the nonnegative offset from start of file. On error
     572 *         returns (off64_t)-1 and sets errno.
     573 */
    479574off64_t lseek(int fildes, off64_t offset, int whence)
    480575{
     
    489584        vfs_exchange_end(exch);
    490585       
    491         if (rc != EOK)
     586        if (rc != EOK) {
     587                errno = rc;
    492588                return (off64_t) -1;
     589        }
    493590       
    494591        return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
    495592}
    496593
     594/** Truncate file to a specified length.
     595 *
     596 * Truncate file so that its size is exactly @a length
     597 *
     598 * @param fildes File descriptor
     599 * @param length Length
     600 *
     601 * @return 0 on success, -1 on error and sets errno.
     602 */
    497603int ftruncate(int fildes, aoff64_t length)
    498604{
     
    504610        vfs_exchange_end(exch);
    505611       
    506         return (int) rc;
    507 }
    508 
     612        if (rc != EOK) {
     613                errno = rc;
     614                return -1;
     615        }
     616       
     617        return 0;
     618}
     619
     620/** Get file status.
     621 *
     622 * @param fildes File descriptor
     623 * @param stat Place to store file information
     624 *
     625 * @return 0 on success, -1 on error and sets errno.
     626 */
    509627int fstat(int fildes, struct stat *stat)
    510628{
     
    518636        if (rc != EOK) {
    519637                vfs_exchange_end(exch);
    520 
     638               
    521639                sysarg_t rc_orig;
    522640                async_wait_for(req, &rc_orig);
    523 
    524                 if (rc_orig == EOK)
    525                         return (ssize_t) rc;
    526                 else
    527                         return (ssize_t) rc_orig;
    528         }
     641               
     642                if (rc_orig != EOK)
     643                        rc = rc_orig;
     644                if (rc != EOK) {
     645                        errno = rc;
     646                        return -1;
     647                }
     648               
     649                return 0;
     650        }
     651       
    529652        vfs_exchange_end(exch);
    530653        async_wait_for(req, &rc);
    531 
    532         return rc;
    533 }
    534 
     654       
     655        if (rc != EOK) {
     656                errno = rc;
     657                return -1;
     658        }
     659       
     660        return 0;
     661}
     662
     663/** Get file status.
     664 *
     665 * @param path Path to file
     666 * @param stat Place to store file information
     667 *
     668 * @return 0 on success, -1 on error and sets errno.
     669 */
    535670int stat(const char *path, struct stat *stat)
    536671{
     
    540675       
    541676        size_t pa_size;
    542         char *pa = absolutize(path, &pa_size);
    543         if (!pa)
    544                 return ENOMEM;
     677        char *pa = vfs_absolutize(path, &pa_size);
     678        if (pa == NULL) {
     679                errno = ENOMEM;
     680                return -1;
     681        }
    545682       
    546683        async_exch_t *exch = vfs_exchange_begin();
     
    552689                free(pa);
    553690                async_wait_for(req, &rc_orig);
     691                if (rc_orig != EOK)
     692                        rc = rc_orig;
     693                if (rc != EOK) {
     694                        errno = rc;
     695                        return -1;
     696                }
     697        }
     698        rc = async_data_read_start(exch, stat, sizeof(struct stat));
     699        if (rc != EOK) {
     700                vfs_exchange_end(exch);
     701                free(pa);
     702                async_wait_for(req, &rc_orig);
     703                if (rc_orig != EOK)
     704                        rc = rc_orig;
     705                if (rc != EOK) {
     706                        errno = rc;
     707                        return -1;
     708                }
     709        }
     710        vfs_exchange_end(exch);
     711        free(pa);
     712        async_wait_for(req, &rc);
     713        if (rc != EOK) {
     714                errno = rc;
     715                return -1;
     716        }
     717        return 0;
     718}
     719
     720/** Open directory.
     721 *
     722 * @param dirname Directory pathname
     723 *
     724 * @return Non-NULL pointer on success. On error returns @c NULL and sets errno.
     725 */
     726DIR *opendir(const char *dirname)
     727{
     728        DIR *dirp = malloc(sizeof(DIR));
     729        int fd = -1;
     730       
     731        if (dirp == NULL) {
     732                errno = ENOMEM;
     733                return NULL;
     734        }
     735       
     736        size_t abs_size;
     737        char *abs = vfs_absolutize(dirname, &abs_size);
     738        if (abs == NULL) {
     739                free(dirp);
     740                errno = ENOMEM;
     741                return NULL;
     742        }
     743       
     744        int rc = open_internal(abs, abs_size, L_DIRECTORY, 0, &fd);
     745        free(abs);
     746       
     747        if (rc != EOK) {
     748                free(dirp);
     749                errno = rc;
     750                return NULL;
     751        }
     752       
     753        dirp->fd = fd;
     754        return dirp;
     755}
     756
     757/** Read directory entry.
     758 *
     759 * @param dirp Open directory
     760 * @return Non-NULL pointer to directory entry on success. On error returns
     761 *         @c NULL and sets errno.
     762 */
     763struct dirent *readdir(DIR *dirp)
     764{
     765        int rc;
     766        ssize_t len;
     767       
     768        rc = _read_short(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1, &len);
     769        if (rc != EOK) {
     770                errno = rc;
     771                return NULL;
     772        }
     773       
     774        (void) len;
     775        return &dirp->res;
     776}
     777
     778/** Rewind directory position to the beginning.
     779 *
     780 * @param dirp Open directory
     781 */
     782void rewinddir(DIR *dirp)
     783{
     784        (void) lseek(dirp->fd, 0, SEEK_SET);
     785}
     786
     787/** Close directory.
     788 *
     789 * @param dirp Open directory
     790 * @return 0 on success. On error returns -1 and sets errno.
     791 */
     792int closedir(DIR *dirp)
     793{
     794        int rc;
     795       
     796        rc = close(dirp->fd);
     797        free(dirp);
     798
     799        /* On error errno was set by close() */
     800        return rc;
     801}
     802
     803/** Create directory.
     804 *
     805 * @param path Path
     806 * @param mode File mode
     807 * @return 0 on success. On error returns -1 and sets errno.
     808 */
     809int mkdir(const char *path, mode_t mode)
     810{
     811        sysarg_t rc;
     812        aid_t req;
     813       
     814        size_t pa_size;
     815        char *pa = vfs_absolutize(path, &pa_size);
     816        if (pa == NULL) {
     817                errno = ENOMEM;
     818                return -1;
     819        }
     820       
     821        async_exch_t *exch = vfs_exchange_begin();
     822       
     823        req = async_send_1(exch, VFS_IN_MKDIR, mode, NULL);
     824        rc = async_data_write_start(exch, pa, pa_size);
     825        if (rc != EOK) {
     826                vfs_exchange_end(exch);
     827                free(pa);
     828               
     829                sysarg_t rc_orig;
     830                async_wait_for(req, &rc_orig);
     831               
     832                if (rc_orig != EOK)
     833                        rc = rc_orig;
     834               
     835                if (rc != EOK) {
     836                        errno = rc;
     837                        return -1;
     838                }
     839               
     840                return 0;
     841        }
     842       
     843        vfs_exchange_end(exch);
     844        free(pa);
     845        async_wait_for(req, &rc);
     846       
     847        if (rc != EOK) {
     848                errno = rc;
     849                return -1;
     850        }
     851       
     852        return 0;
     853}
     854
     855/** Unlink a file or directory.
     856 *
     857 * @param path Path to file or empty directory
     858 * @param lflag L_xxx flag (L_NONE, L_FILE or L_DIRECTORY)
     859 * @return EOK on success, non-zero error code on error
     860 */
     861static int _unlink(const char *path, int lflag)
     862{
     863        sysarg_t rc;
     864        aid_t req;
     865       
     866        size_t pa_size;
     867        char *pa = vfs_absolutize(path, &pa_size);
     868        if (pa == NULL)
     869                return ENOMEM;
     870       
     871        async_exch_t *exch = vfs_exchange_begin();
     872       
     873        req = async_send_1(exch, VFS_IN_UNLINK, lflag, NULL);
     874        rc = async_data_write_start(exch, pa, pa_size);
     875        if (rc != EOK) {
     876                vfs_exchange_end(exch);
     877                free(pa);
     878
     879                sysarg_t rc_orig;
     880                async_wait_for(req, &rc_orig);
     881
    554882                if (rc_orig == EOK)
    555883                        return (int) rc;
     
    557885                        return (int) rc_orig;
    558886        }
    559         rc = async_data_read_start(exch, stat, sizeof(struct stat));
    560         if (rc != EOK) {
    561                 vfs_exchange_end(exch);
    562                 free(pa);
    563                 async_wait_for(req, &rc_orig);
    564                 if (rc_orig == EOK)
    565                         return (int) rc;
    566                 else
    567                         return (int) rc_orig;
    568         }
    569887        vfs_exchange_end(exch);
    570888        free(pa);
     
    573891}
    574892
    575 DIR *opendir(const char *dirname)
    576 {
    577         DIR *dirp = malloc(sizeof(DIR));
    578         if (!dirp)
    579                 return NULL;
    580        
    581         size_t abs_size;
    582         char *abs = absolutize(dirname, &abs_size);
    583         if (!abs) {
    584                 free(dirp);
    585                 return NULL;
    586         }
    587        
    588         int ret = open_internal(abs, abs_size, L_DIRECTORY, 0);
    589         free(abs);
    590        
    591         if (ret < 0) {
    592                 free(dirp);
    593                 return NULL;
    594         }
    595        
    596         dirp->fd = ret;
    597         return dirp;
    598 }
    599 
    600 struct dirent *readdir(DIR *dirp)
    601 {
    602         ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
    603         if (len <= 0)
    604                 return NULL;
    605         return &dirp->res;
    606 }
    607 
    608 void rewinddir(DIR *dirp)
    609 {
    610         (void) lseek(dirp->fd, 0, SEEK_SET);
    611 }
    612 
    613 int closedir(DIR *dirp)
    614 {
    615         (void) close(dirp->fd);
    616         free(dirp);
     893/** Unlink file or directory.
     894 *
     895 * @param path Path
     896 * @return EOk on success, error code on error
     897 */
     898int unlink(const char *path)
     899{
     900        int rc;
     901
     902        rc = _unlink(path, L_NONE);
     903        if (rc != EOK) {
     904                errno = rc;
     905                return -1;
     906        }
     907
    617908        return 0;
    618909}
    619910
    620 int mkdir(const char *path, mode_t mode)
    621 {
    622         sysarg_t rc;
    623         aid_t req;
    624        
    625         size_t pa_size;
    626         char *pa = absolutize(path, &pa_size);
    627         if (!pa)
    628                 return ENOMEM;
    629        
    630         async_exch_t *exch = vfs_exchange_begin();
    631        
    632         req = async_send_1(exch, VFS_IN_MKDIR, mode, NULL);
    633         rc = async_data_write_start(exch, pa, pa_size);
    634         if (rc != EOK) {
    635                 vfs_exchange_end(exch);
    636                 free(pa);
    637 
    638                 sysarg_t rc_orig;
    639                 async_wait_for(req, &rc_orig);
    640 
    641                 if (rc_orig == EOK)
    642                         return (int) rc;
    643                 else
    644                         return (int) rc_orig;
    645         }
    646         vfs_exchange_end(exch);
    647         free(pa);
    648         async_wait_for(req, &rc);
    649         return rc;
    650 }
    651 
    652 static int _unlink(const char *path, int lflag)
    653 {
    654         sysarg_t rc;
    655         aid_t req;
    656        
    657         size_t pa_size;
    658         char *pa = absolutize(path, &pa_size);
    659         if (!pa)
    660                 return ENOMEM;
    661        
    662         async_exch_t *exch = vfs_exchange_begin();
    663        
    664         req = async_send_1(exch, VFS_IN_UNLINK, lflag, NULL);
    665         rc = async_data_write_start(exch, pa, pa_size);
    666         if (rc != EOK) {
    667                 vfs_exchange_end(exch);
    668                 free(pa);
    669 
    670                 sysarg_t rc_orig;
    671                 async_wait_for(req, &rc_orig);
    672 
    673                 if (rc_orig == EOK)
    674                         return (int) rc;
    675                 else
    676                         return (int) rc_orig;
    677         }
    678         vfs_exchange_end(exch);
    679         free(pa);
    680         async_wait_for(req, &rc);
    681         return rc;
    682 }
    683 
    684 int unlink(const char *path)
    685 {
    686         return _unlink(path, L_NONE);
    687 }
    688 
     911/** Remove empty directory.
     912 *
     913 * @param path Path
     914 * @return 0 on success. On error returns -1 and sets errno.
     915 */
    689916int rmdir(const char *path)
    690917{
    691         return _unlink(path, L_DIRECTORY);
    692 }
    693 
     918        int rc;
     919
     920        rc = _unlink(path, L_DIRECTORY);
     921        if (rc != EOK) {
     922                errno = rc;
     923                return -1;
     924        }
     925
     926        return 0;
     927}
     928
     929/** Rename directory entry.
     930 *
     931 * @param old Old name
     932 * @param new New name
     933 *
     934 * @return 0 on success. On error returns -1 and sets errno.
     935 */
    694936int rename(const char *old, const char *new)
    695937{
     
    699941       
    700942        size_t olda_size;
    701         char *olda = absolutize(old, &olda_size);
    702         if (!olda)
    703                 return ENOMEM;
     943        char *olda = vfs_absolutize(old, &olda_size);
     944        if (olda == NULL) {
     945                errno = ENOMEM;
     946                return -1;
     947        }
    704948
    705949        size_t newa_size;
    706         char *newa = absolutize(new, &newa_size);
    707         if (!newa) {
     950        char *newa = vfs_absolutize(new, &newa_size);
     951        if (newa == NULL) {
    708952                free(olda);
    709                 return ENOMEM;
     953                errno = ENOMEM;
     954                return -1;
    710955        }
    711956       
     
    719964                free(newa);
    720965                async_wait_for(req, &rc_orig);
    721                 if (rc_orig == EOK)
    722                         return (int) rc;
    723                 else
    724                         return (int) rc_orig;
     966                if (rc_orig != EOK)
     967                        rc = rc_orig;
     968                if (rc != EOK) {
     969                        errno = rc;
     970                        return -1;
     971                }
     972                return 0;
    725973        }
    726974        rc = async_data_write_start(exch, newa, newa_size);
     
    730978                free(newa);
    731979                async_wait_for(req, &rc_orig);
    732                 if (rc_orig == EOK)
    733                         return (int) rc;
    734                 else
    735                         return (int) rc_orig;
     980                if (rc_orig != EOK)
     981                        rc = rc_orig;
     982                if (rc != EOK) {
     983                        errno = rc;
     984                        return -1;
     985                }
     986                return 0;
    736987        }
    737988        vfs_exchange_end(exch);
     
    739990        free(newa);
    740991        async_wait_for(req, &rc);
    741         return rc;
    742 }
    743 
     992
     993        if (rc != EOK) {
     994                errno = rc;
     995                return -1;
     996        }
     997
     998        return 0;
     999}
     1000
     1001/** Remove directory entry.
     1002 *
     1003 * @param path Path
     1004 * @return 0 on success. On error returns -1 and sets errno.
     1005 */
    7441006int remove(const char *path)
    7451007{
     
    7471009}
    7481010
     1011/** Change working directory.
     1012 *
     1013 * @param path Path
     1014 * @return 0 on success. On error returns -1 and sets errno.
     1015 */
    7491016int chdir(const char *path)
    7501017{
    7511018        size_t abs_size;
    752         char *abs = absolutize(path, &abs_size);
    753         if (!abs)
    754                 return ENOMEM;
    755        
    756         int fd = open_internal(abs, abs_size, L_DIRECTORY, O_DESC);
    757        
    758         if (fd < 0) {
     1019        char *abs = vfs_absolutize(path, &abs_size);
     1020        int fd = -1;
     1021       
     1022        if (abs == NULL) {
     1023                errno = ENOMEM;
     1024                return -1;
     1025        }
     1026       
     1027        int rc = open_internal(abs, abs_size, L_DIRECTORY, O_DESC, &fd);
     1028       
     1029        if (rc != EOK) {
    7591030                free(abs);
    760                 return ENOENT;
     1031                errno = rc;
     1032                return -1;
    7611033        }
    7621034       
     
    7651037        if (cwd_fd >= 0)
    7661038                close(cwd_fd);
    767        
    7681039       
    7691040        if (cwd_path)
     
    7751046       
    7761047        fibril_mutex_unlock(&cwd_mutex);
    777         return EOK;
    778 }
    779 
     1048        return 0;
     1049}
     1050
     1051/** Get current working directory path.
     1052 *
     1053 * @param buf Buffer
     1054 * @param size Size of @a buf
     1055 * @return On success returns @a buf. On failure returns @c NULL and sets errno.
     1056 */
    7801057char *getcwd(char *buf, size_t size)
    7811058{
    782         if (size == 0)
     1059        if (size == 0) {
     1060                errno = EINVAL;
    7831061                return NULL;
     1062        }
    7841063       
    7851064        fibril_mutex_lock(&cwd_mutex);
     
    7871066        if ((cwd_size == 0) || (size < cwd_size + 1)) {
    7881067                fibril_mutex_unlock(&cwd_mutex);
     1068                errno = ERANGE;
    7891069                return NULL;
    7901070        }
     
    7961076}
    7971077
    798 async_sess_t *fd_session(int fildes, iface_t iface)
     1078/** Open session to service represented by a special file.
     1079 *
     1080 * Given that the file referred to by @a fildes represents a service,
     1081 * open a session to that service.
     1082 *
     1083 * @param fildes File descriptor
     1084 * @param iface Interface to connect to (XXX Should be automatic)
     1085 * @return On success returns session pointer. On error returns @c NULL.
     1086 */
     1087async_sess_t *vfs_fd_session(int fildes, iface_t iface)
    7991088{
    8001089        struct stat stat;
    8011090        int rc = fstat(fildes, &stat);
    802         if (rc != 0) {
    803                 errno = rc;
     1091        if (rc != 0)
    8041092                return NULL;
    805         }
    806        
    807         if (!stat.service) {
    808                 errno = ENOENT;
     1093       
     1094        if (stat.service == 0)
    8091095                return NULL;
    810         }
    8111096       
    8121097        return loc_service_connect(stat.service, iface, 0);
    8131098}
    8141099
     1100/** Duplicate open file.
     1101 *
     1102 * Duplicate open file under a new file descriptor.
     1103 *
     1104 * @param oldfd Old file descriptor
     1105 * @param newfd New file descriptor
     1106 * @return 0 on success. On error -1 is returned and errno is set
     1107 */
    8151108int dup2(int oldfd, int newfd)
    8161109{
     
    8231116       
    8241117        if (rc == EOK)
    825                 return (int) ret;
    826        
    827         return (int) rc;
    828 }
    829 
    830 int fd_wait(void)
     1118                rc = ret;
     1119       
     1120        if (rc != EOK) {
     1121                errno = rc;
     1122                return -1;
     1123        }
     1124       
     1125        return 0;
     1126}
     1127
     1128int vfs_fd_wait(void)
    8311129{
    8321130        async_exch_t *exch = vfs_exchange_begin();
     
    8431141}
    8441142
    845 int get_mtab_list(list_t *mtab_list)
     1143int vfs_get_mtab_list(list_t *mtab_list)
    8461144{
    8471145        sysarg_t rc;
     
    8631161
    8641162                mtab_ent = malloc(sizeof(mtab_ent_t));
    865                 if (!mtab_ent) {
     1163                if (mtab_ent == NULL) {
    8661164                        rc = ENOMEM;
    8671165                        goto exit;
     
    9041202}
    9051203
     1204/** Get filesystem statistics.
     1205 *
     1206 * @param path Mount point path
     1207 * @param st Buffer for storing information
     1208 * @return 0 on success. On error -1 is returned and errno is set.
     1209 */
    9061210int statfs(const char *path, struct statfs *st)
    9071211{
     
    9101214        size_t pa_size;
    9111215
    912         char *pa = absolutize(path, &pa_size);
    913         if (!pa)
    914                 return ENOMEM;
     1216        char *pa = vfs_absolutize(path, &pa_size);
     1217        if (pa == NULL) {
     1218                errno = ENOMEM;
     1219                return -1;
     1220        }
    9151221
    9161222        async_exch_t *exch = vfs_exchange_begin();
     
    9271233        free(pa);
    9281234        async_wait_for(req, &rc_orig);
    929         return (int) (rc_orig != EOK ? rc_orig : rc);
     1235        rc = (rc_orig != EOK ? rc_orig : rc);
     1236
     1237        if (rc != EOK) {
     1238                errno = rc;
     1239                return -1;
     1240        }
     1241
     1242        return 0;
    9301243}
    9311244
  • uspace/lib/c/include/io/kio.h

    rf1f7584 r6afc9d7  
    4040#include <io/verify.h>
    4141
    42 extern size_t kio_write(const void *, size_t);
     42extern int kio_write(const void *, size_t, size_t *);
    4343extern void kio_update(void);
    4444extern void kio_command(const void *, size_t);
  • uspace/lib/c/include/sys/statfs.h

    rf1f7584 r6afc9d7  
    4646
    4747extern int statfs(const char *, struct statfs *);
     48
    4849#endif
    4950
  • uspace/lib/c/include/unistd.h

    rf1f7584 r6afc9d7  
    6363extern ssize_t read(int, void *, size_t);
    6464
    65 extern ssize_t read_all(int, void *, size_t);
    66 extern ssize_t write_all(int, const void *, size_t);
    67 
    6865extern off64_t lseek(int, off64_t, int);
    6966extern int ftruncate(int, aoff64_t);
  • uspace/lib/c/include/vfs/vfs.h

    rf1f7584 r6afc9d7  
    5050
    5151
    52 extern char *absolutize(const char *, size_t *);
     52extern char *vfs_absolutize(const char *, size_t *);
    5353
    54 extern int mount(const char *, const char *, const char *, const char *,
     54extern int vfs_mount(const char *, const char *, const char *, const char *,
    5555    unsigned int, unsigned int);
    56 extern int unmount(const char *);
     56extern int vfs_unmount(const char *);
    5757
    58 extern int fhandle(FILE *, int *);
     58extern int vfs_fhandle(FILE *, int *);
    5959
    60 extern int fd_wait(void);
    61 extern int get_mtab_list(list_t *mtab_list);
     60extern int vfs_fd_wait(void);
     61extern int vfs_get_mtab_list(list_t *mtab_list);
    6262
    6363extern async_exch_t *vfs_exchange_begin(void);
    6464extern void vfs_exchange_end(async_exch_t *);
     65
    6566#endif
    6667
  • uspace/lib/c/include/vfs/vfs_sess.h

    rf1f7584 r6afc9d7  
    3939#include <stdio.h>
    4040
    41 extern async_sess_t *fd_session(int, iface_t);
    42 extern async_sess_t *fsession(FILE *, iface_t);
     41extern async_sess_t *vfs_fd_session(int, iface_t);
     42extern async_sess_t *vfs_fsession(FILE *, iface_t);
    4343
    4444#endif
  • uspace/lib/pcut/src/os/helenos.c

    rf1f7584 r6afc9d7  
    220220        fibril_mutex_unlock(&forced_termination_mutex);
    221221
    222         read_all(tempfile, extra_output_buffer, OUTPUT_BUFFER_SIZE);
     222        read(tempfile, extra_output_buffer, OUTPUT_BUFFER_SIZE);
    223223
    224224leave_close_tempfile:
  • uspace/lib/posix/source/fcntl.c

    rf1f7584 r6afc9d7  
    112112        }
    113113
    114         int rc = open(pathname, flags, mode);
    115         if (rc < 0) {
    116                 errno = -rc;
    117                 rc = -1;
    118         }
    119 
    120         return rc;
     114        return negerrno(open, pathname, flags, mode);
    121115}
    122116
  • uspace/lib/posix/source/internal/common.h

    rf1f7584 r6afc9d7  
    4848        } while (0)
    4949
    50 /* A little helper macro to avoid typing this over and over. */
     50/* Convert negative error return value to positive errno */
    5151#define errnify(func, ...) ({ \
    5252        int rc = func(__VA_ARGS__); \
     
    5858})
    5959
     60/* Convert negative errno to positive errno */
     61#define negerrno(func, ...) ({ \
     62        int rc = func(__VA_ARGS__); \
     63        if (rc < 0) { \
     64                errno = -errno; \
     65        } \
     66        rc; \
     67})
     68
    6069#endif /* LIBPOSIX_COMMON_H_ */
    6170
  • uspace/lib/posix/source/stdio.c

    rf1f7584 r6afc9d7  
    315315int posix_fflush(FILE *stream)
    316316{
    317         int rc = fflush(stream);
    318         if (rc < 0) {
    319                 errno = -rc;
    320                 return EOF;
    321         } else {
    322                 return 0;
    323         }
     317        return negerrno(fflush, stream);
    324318}
    325319
     
    351345{
    352346        ssize_t wr = write(*(int *) fd, str, size);
     347        if (wr < 0)
     348                return errno;
    353349        return str_nlength(str, wr);
    354350}
     
    579575int posix_remove(const char *path)
    580576{
    581         struct stat st;
    582         int rc = stat(path, &st);
    583        
    584         if (rc != EOK) {
    585                 errno = -rc;
    586                 return -1;
    587         }
    588        
    589         if (st.is_directory) {
    590                 rc = rmdir(path);
    591         } else {
    592                 rc = unlink(path);
    593         }
    594        
    595         if (rc != EOK) {
    596                 errno = -rc;
    597                 return -1;
    598         }
    599         return 0;
     577        return negerrno(remove, path);
    600578}
    601579
     
    609587int posix_rename(const char *old, const char *new)
    610588{
    611         return errnify(rename, old, new);
     589        return negerrno(rename, old, new);
    612590}
    613591
  • uspace/lib/posix/source/stdlib.c

    rf1f7584 r6afc9d7  
    278278         * to be updated when that support is implemented.
    279279         */
    280         char* absolute = absolutize(name, NULL);
     280        char* absolute = vfs_absolutize(name, NULL);
    281281       
    282282        if (absolute == NULL) {
  • uspace/lib/posix/source/sys/stat.c

    rf1f7584 r6afc9d7  
    8080{
    8181        struct stat hst;
    82         int rc = fstat(fd, &hst);
    83         if (rc < 0) {
    84                 /* fstat() returns negative error code instead of using errno. */
    85                 errno = -rc;
    86                 return -1;
    87         }
     82        int rc = negerrno(fstat, fd, &hst);
     83        if (rc < 0)
     84                return rc;
    8885        stat_to_posix(st, &hst);
    8986        return 0;
     
    113110{
    114111        struct stat hst;
    115         int rc = stat(path, &hst);
    116         if (rc < 0) {
    117                 /* stat() returns negative error code instead of using errno. */
    118                 errno = -rc;
    119                 return -1;
    120         }
     112        int rc = negerrno(stat, path, &hst);
     113        if (rc < 0)
     114                return rc;
    121115        stat_to_posix(st, &hst);
    122116        return 0;
  • uspace/lib/posix/source/unistd.c

    rf1f7584 r6afc9d7  
    105105char *posix_getcwd(char *buf, size_t size)
    106106{
    107         /* Native getcwd() does not set any errno despite the fact that general
    108          * usage pattern of this function depends on it (caller is repeatedly
    109          * guessing the required size of the buffer by checking for ERANGE on
    110          * failure). */
    111         if (size == 0) {
    112                 errno = EINVAL;
     107        char *p = getcwd(buf, size);
     108
     109        if (p == NULL) {
     110                errno = -errno;
    113111                return NULL;
    114112        }
    115        
    116         /* Save the original value to comply with the "no modification on
    117          * success" semantics.
    118          */
    119         int orig_errno = errno;
    120         errno = EOK;
    121        
    122         char *ret = getcwd(buf, size);
    123         if (ret == NULL) {
    124                 /* Check errno to avoid shadowing other possible errors. */
    125                 if (errno == EOK) {
    126                         errno = ERANGE;
    127                 }
    128         } else {
    129                 /* Success, restore previous errno value. */
    130                 errno = orig_errno;
    131         }
    132        
    133         return ret;
     113
     114        return p;
    134115}
    135116
     
    141122int posix_chdir(const char *path)
    142123{
    143         return errnify(chdir, path);
     124        return negerrno(chdir, path);
    144125}
    145126
     
    194175int posix_close(int fildes)
    195176{
    196         return errnify(close, fildes);
     177        return negerrno(close, fildes);
    197178}
    198179
     
    207188ssize_t posix_read(int fildes, void *buf, size_t nbyte)
    208189{
    209         return errnify(read, fildes, buf, nbyte);
     190        return negerrno(read, fildes, buf, nbyte);
    210191}
    211192
     
    220201ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
    221202{
    222         return errnify(write, fildes, buf, nbyte);
     203        return negerrno(write, fildes, buf, nbyte);
    223204}
    224205
     
    234215posix_off_t posix_lseek(int fildes, posix_off_t offset, int whence)
    235216{
    236         return errnify(lseek, fildes, offset, whence);
     217        return negerrno(lseek, fildes, offset, whence);
    237218}
    238219
     
    245226int posix_fsync(int fildes)
    246227{
    247         return errnify(fsync, fildes);
     228        return negerrno(fsync, fildes);
    248229}
    249230
     
    257238int posix_ftruncate(int fildes, posix_off_t length)
    258239{
    259         return errnify(ftruncate, fildes, (aoff64_t) length);
     240        return negerrno(ftruncate, fildes, (aoff64_t) length);
    260241}
    261242
     
    268249int posix_rmdir(const char *path)
    269250{
    270         return errnify(rmdir, path);
     251        return negerrno(rmdir, path);
    271252}
    272253
     
    279260int posix_unlink(const char *path)
    280261{
    281         return errnify(unlink, path);
     262        return negerrno(unlink, path);
    282263}
    283264
     
    303284int posix_dup2(int fildes, int fildes2)
    304285{
    305         return errnify(dup2, fildes, fildes2);
     286        return negerrno(dup2, fildes, fildes2);
    306287}
    307288
     
    321302                 * Check file existence by attempting to open it.
    322303                 */
    323                 int fd = open(path, O_RDONLY);
     304                int fd = negerrno(open, path, O_RDONLY);
    324305                if (fd < 0) {
    325                         errno = -fd;
     306                        /* errno was set by open() */
    326307                        return -1;
    327308                }
  • uspace/srv/devman/driver.c

    rf1f7584 r6afc9d7  
    142142        /* Check whether the driver's binary exists. */
    143143        struct stat s;
    144         if (stat(drv->binary_path, &s) == ENOENT) { /* FIXME!! */
     144        if (stat(drv->binary_path, &s) != 0) {
    145145                log_msg(LOG_DEFAULT, LVL_ERROR, "Driver not found at path `%s'.",
    146146                    drv->binary_path);
  • uspace/srv/devman/match.c

    rf1f7584 r6afc9d7  
    3131 */
    3232
     33#include <errno.h>
    3334#include <fcntl.h>
    3435#include <io/log.h>
     
    197198        if (fd < 0) {
    198199                log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to open `%s' for reading: %s.",
    199                     conf_path, str_error(fd));
     200                    conf_path, str_error(errno));
    200201                goto cleanup;
    201202        }
     
    217218        }
    218219       
    219         ssize_t read_bytes = read_all(fd, buf, len);
     220        ssize_t read_bytes = read(fd, buf, len);
    220221        if (read_bytes <= 0) {
    221                 log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to read file '%s' (%zd).", conf_path,
    222                     read_bytes);
     222                log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to read file '%s' (%d).", conf_path,
     223                    errno);
    223224                goto cleanup;
    224225        }
  • uspace/srv/loader/main.c

    rf1f7584 r6afc9d7  
    249249                }
    250250                async_state_change_finalize(callid, vfs_exch);
    251                 fd = fd_wait();
     251                fd = vfs_fd_wait();
    252252                assert(fd == (int) filc);
    253253        }
  • uspace/srv/vfs/vfs.c

    rf1f7584 r6afc9d7  
    7474                        break;
    7575                case VFS_IN_MOUNT:
    76                         vfs_mount(callid, &call);
     76                        vfs_mount_srv(callid, &call);
    7777                        break;
    7878                case VFS_IN_UNMOUNT:
    79                         vfs_unmount(callid, &call);
     79                        vfs_unmount_srv(callid, &call);
    8080                        break;
    8181                case VFS_IN_OPEN:
  • uspace/srv/vfs/vfs.h

    rf1f7584 r6afc9d7  
    205205
    206206extern void vfs_register(ipc_callid_t, ipc_call_t *);
    207 extern void vfs_mount(ipc_callid_t, ipc_call_t *);
    208 extern void vfs_unmount(ipc_callid_t, ipc_call_t *);
     207extern void vfs_mount_srv(ipc_callid_t, ipc_call_t *);
     208extern void vfs_unmount_srv(ipc_callid_t, ipc_call_t *);
    209209extern void vfs_open(ipc_callid_t, ipc_call_t *);
    210210extern void vfs_sync(ipc_callid_t, ipc_call_t *);
  • uspace/srv/vfs/vfs_ops.c

    rf1f7584 r6afc9d7  
    266266}
    267267
    268 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
     268void vfs_mount_srv(ipc_callid_t rid, ipc_call_t *request)
    269269{
    270270        service_id_t service_id;
     
    405405}
    406406
    407 void vfs_unmount(ipc_callid_t rid, ipc_call_t *request)
     407void vfs_unmount_srv(ipc_callid_t rid, ipc_call_t *request)
    408408{
    409409        int rc;
Note: See TracChangeset for help on using the changeset viewer.