Changeset 6afc9d7 in mainline for uspace/app


Ignore:
Timestamp:
2015-10-06T19:01:36Z (10 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.

Location:
uspace/app
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • 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);
Note: See TracChangeset for help on using the changeset viewer.