Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 9c4cf0d in mainline


Ignore:
Timestamp:
2017-04-02T11:24:06Z (3 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
151f1cc
Parents:
b19e892
Message:

Rename close() to vfs_put()

This is motivated mainly by the fact that a file handle does not
necessarily correspond to an open file and close() was no longer the
the opposite operation to open().

Location:
uspace
Files:
36 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    rb19e892 r9c4cf0d  
    203203
    204204        if (NULL == (buff = (char *) malloc(blen + 1))) {
    205                 close(fd);
     205                vfs_put(fd);
    206206                printf("Unable to allocate enough memory to read %s\n",
    207207                    fname);
     
    213213
    214214                if (vfs_stat(fd, &st) != EOK) {
    215                         close(fd);
     215                        vfs_put(fd);
    216216                        free(buff);
    217217                        printf("Unable to vfs_stat %d\n", fd);
     
    287287        } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
    288288
    289         close(fd);
     289        vfs_put(fd);
    290290        if (bytes == -1) {
    291291                printf("Error reading %s\n", fname);
  • uspace/app/bdsh/cmds/modules/cmp/cmp.c

    rb19e892 r9c4cf0d  
    116116end:
    117117        if (fd[0] >= 0)
    118                 close(fd[0]);
     118                vfs_put(fd[0]);
    119119        if (fd[1] >= 0)
    120                 close(fd[1]);
     120                vfs_put(fd[1]);
    121121        return rc;
    122122}
  • uspace/app/bdsh/cmds/modules/cp/cp.c

    rb19e892 r9c4cf0d  
    391391        if (fd2 < 0) {
    392392                printf("Unable to open destination file %s\n", dest);
    393                 close(fd1);
     393                vfs_put(fd1);
    394394                return -1;
    395395        }
     
    397397        if (vfs_stat(fd1, &st) != EOK) {
    398398                printf("Unable to fstat %d\n", fd1);
    399                 close(fd1);
    400                 close(fd2);
     399                vfs_put(fd1);
     400                vfs_put(fd2);
    401401                return -1;     
    402402        }
     
    425425
    426426out:
    427         close(fd1);
    428         close(fd2);
     427        vfs_put(fd1);
     428        vfs_put(fd2);
    429429        if (buff)
    430430                free(buff);
  • uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

    rb19e892 r9c4cf0d  
    168168                rc2 = write(fd, &pos, &byte, sizeof(char));
    169169                if (rc2 < 0) {
    170                         close(fd);
     170                        vfs_put(fd);
    171171                        goto error;
    172172                }
     
    186186                if (rc <= 0) {
    187187                        printf("%s: Error writing file (%d).\n", cmdname, errno);
    188                         close(fd);
     188                        vfs_put(fd);
    189189                        free(buffer);
    190190                        return CMD_FAILURE;
     
    195195        free(buffer);
    196196
    197         if (close(fd) < 0)
     197        if (vfs_put(fd) < 0)
    198198                goto error;
    199199
  • uspace/app/bdsh/cmds/modules/rm/rm.c

    rb19e892 r9c4cf0d  
    152152        fd = vfs_lookup(path, WALK_REGULAR);
    153153        if (fd >= 0) {
    154                 close(fd);
     154                vfs_put(fd);
    155155                return RM_FILE;
    156156        }
  • uspace/app/bdsh/cmds/modules/touch/touch.c

    rb19e892 r9c4cf0d  
    133133                        continue;
    134134                } else {
    135                         close(fd);
     135                        vfs_put(fd);
    136136                        fd = -1;
    137137                }
  • uspace/app/bdsh/exec.c

    rb19e892 r9c4cf0d  
    6161        fd = vfs_lookup_open(f, WALK_REGULAR, MODE_READ);
    6262        if (fd >= 0) {
    63                 close(fd);
     63                vfs_put(fd);
    6464                return 0;
    6565        } else
  • uspace/app/getterm/getterm.c

    rb19e892 r9c4cf0d  
    7474                        return;
    7575               
    76                 if (close(oldfd))
     76                if (vfs_put(oldfd))
    7777                        return;
    7878        }
  • uspace/app/redir/redir.c

    rb19e892 r9c4cf0d  
    6969                        return;
    7070               
    71                 if (close(oldfd))
     71                if (vfs_put(oldfd))
    7272                        return;
    7373        }
  • uspace/app/sysinst/futil.c

    rb19e892 r9c4cf0d  
    8383        } while (true);
    8484
    85         (void) close(sf);
     85        (void) vfs_put(sf);
    8686
    87         rc = close(df);
     87        rc = vfs_put(df);
    8888        if (rc < 0)
    8989                return EIO;
     
    166166
    167167        if (vfs_stat(sf, &st) != EOK) {
    168                 close(sf);
     168                vfs_put(sf);
    169169                return EIO;
    170170        }       
     
    174174        data = calloc(fsize, 1);
    175175        if (data == NULL) {
    176                 close(sf);
     176                vfs_put(sf);
    177177                return ENOMEM;
    178178        }
     
    180180        nr = read(sf, (aoff64_t []) { 0 }, data, fsize);
    181181        if (nr != (ssize_t)fsize) {
    182                 close(sf);
     182                vfs_put(sf);
    183183                free(data);
    184184                return EIO;
    185185        }
    186186
    187         (void) close(sf);
     187        (void) vfs_put(sf);
    188188        *rdata = data;
    189189        *rsize = fsize;
  • uspace/app/taskdump/symtab.c

    rb19e892 r9c4cf0d  
    165165
    166166        free(shstrt);
    167         close(fd);
     167        vfs_put(fd);
    168168
    169169        if (stab->sym == NULL || stab->strtab == NULL) {
  • uspace/app/tester/hw/misc/virtchar1.c

    rb19e892 r9c4cf0d  
    6969        async_sess_t *sess = vfs_fd_session(fd, INTERFACE_DDF);
    7070        if (!sess) {
    71                 close(fd);
     71                vfs_put(fd);
    7272                TPRINTF("   ...error: %s\n", str_error(errno));
    7373                return "Failed to get session to device";
     
    9090        TPRINTF(" Closing session and file descriptor\n");
    9191        async_hangup(sess);
    92         close(fd);
     92        vfs_put(fd);
    9393       
    9494        return NULL;
  • uspace/app/tester/mm/pager1.c

    rb19e892 r9c4cf0d  
    5454
    5555        if (write(fd, (aoff64_t []) {0}, text, sizeof(text)) != sizeof(text)) {
    56                 close(fd);
     56                vfs_put(fd);
    5757                return NULL;
    5858        }
     
    6565
    6666        if (!vfs_pager_sess) {
    67                 close(fd);
     67                vfs_put(fd);
    6868                return NULL;
    6969        }
     
    7474            AS_AREA_READ | AS_AREA_CACHEABLE, vfs_pager_sess, fd, 0, 0);
    7575        if (result == AS_MAP_FAILED) {
    76                 close(fd);
     76                vfs_put(fd);
    7777                return NULL;
    7878        }
     
    102102
    103103        as_area_destroy(buffer);       
    104         close(fd);
     104        vfs_put(fd);
    105105       
    106106        return NULL;
  • uspace/app/tester/vfs/vfs1.c

    rb19e892 r9c4cf0d  
    108108        }
    109109       
    110         close(fd0);
     110        vfs_put(fd0);
    111111       
    112112        const char *rv = read_root();
  • uspace/app/trace/trace.c

    rb19e892 r9c4cf0d  
    531531        if (fd_root >= 0) {
    532532                rc = loader_add_inbox(ldr, "root", fd_root);
    533                 close(fd_root);
     533                vfs_put(fd_root);
    534534                if (rc != EOK)
    535535                        goto error;
     
    705705        o = oper_new("write", 3, arg_def, V_ERRNO, 1, resp_def);
    706706        proto_add_oper(p, VFS_IN_WRITE, o);
    707         o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def);
     707        o = oper_new("vfs_resize", 5, arg_def, V_ERRNO, 0, resp_def);
    708708        proto_add_oper(p, VFS_IN_RESIZE, o);
    709         o = oper_new("fstat", 1, arg_def, V_ERRNO, 0, resp_def);
     709        o = oper_new("vfs_stat", 1, arg_def, V_ERRNO, 0, resp_def);
    710710        proto_add_oper(p, VFS_IN_STAT, o);
    711         o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
    712         proto_add_oper(p, VFS_IN_CLOSE, o);
    713         o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def);
     711        o = oper_new("vfs_put", 1, arg_def, V_ERRNO, 0, resp_def);
     712        proto_add_oper(p, VFS_IN_PUT, o);
     713        o = oper_new("vfs_mount", 2, arg_def, V_ERRNO, 0, resp_def);
    714714        proto_add_oper(p, VFS_IN_MOUNT, o);
    715715/*      o = oper_new("unmount", 0, arg_def);
    716716        proto_add_oper(p, VFS_IN_UNMOUNT, o);*/
    717         o = oper_new("sync", 1, arg_def, V_ERRNO, 0, resp_def);
     717        o = oper_new("vfs_sync", 1, arg_def, V_ERRNO, 0, resp_def);
    718718        proto_add_oper(p, VFS_IN_SYNC, o);
    719719        o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
    720720        proto_add_oper(p, VFS_IN_RENAME, o);
    721         o = oper_new("statfs", 0, arg_def, V_ERRNO, 0, resp_def);
     721        o = oper_new("vfs_statfs", 0, arg_def, V_ERRNO, 0, resp_def);
    722722        proto_add_oper(p, VFS_IN_STATFS, o);
    723         o = oper_new("walk", 2, arg_def, V_INT_ERRNO, 0, resp_def);
     723        o = oper_new("vfs_walk", 2, arg_def, V_INT_ERRNO, 0, resp_def);
    724724        proto_add_oper(p, VFS_IN_WALK, o);
    725         o = oper_new("open", 2, arg_def, V_ERRNO, 0, resp_def);
     725        o = oper_new("vfs_open", 2, arg_def, V_ERRNO, 0, resp_def);
    726726        proto_add_oper(p, VFS_IN_OPEN, o);
    727         o = oper_new("unlink", 3, arg_def, V_ERRNO, 0, resp_def);
     727        o = oper_new("vfs_unlink", 3, arg_def, V_ERRNO, 0, resp_def);
    728728        proto_add_oper(p, VFS_IN_UNLINK, o);
    729729
  • uspace/app/viewer/viewer.c

    rb19e892 r9c4cf0d  
    116116        int rc = vfs_stat(fd, &stat);
    117117        if (rc != EOK) {
    118                 close(fd);
     118                vfs_put(fd);
    119119                return false;
    120120        }
     
    122122        void *tga = malloc(stat.size);
    123123        if (tga == NULL) {
    124                 close(fd);
     124                vfs_put(fd);
    125125                return false;
    126126        }
     
    129129        if ((rd < 0) || (rd != (ssize_t) stat.size)) {
    130130                free(tga);
    131                 close(fd);
    132                 return false;
    133         }
    134        
    135         close(fd);
     131                vfs_put(fd);
     132                return false;
     133        }
     134       
     135        vfs_put(fd);
    136136       
    137137        *p_local_surface = decode_tga(tga, stat.size, 0);
  • uspace/app/websrv/websrv.c

    rb19e892 r9c4cf0d  
    245245               
    246246                if (nr < 0) {
    247                         close(fd);
     247                        vfs_put(fd);
    248248                        return EIO;
    249249                }
     
    252252                if (rc != EOK) {
    253253                        fprintf(stderr, "tcp_conn_send() failed\n");
    254                         close(fd);
     254                        vfs_put(fd);
    255255                        return rc;
    256256                }
    257257        }
    258258       
    259         close(fd);
     259        vfs_put(fd);
    260260       
    261261        return EOK;
  • uspace/drv/bus/isa/isa.c

    rb19e892 r9c4cf0d  
    298298
    299299        if (opened)
    300                 close(fd);
     300                vfs_put(fd);
    301301
    302302        return buf;
  • uspace/lib/bithenge/src/failure.c

    rb19e892 r9c4cf0d  
    153153                vfs_clone(null, STDOUT_FILENO, false);
    154154                vfs_clone(null, STDERR_FILENO, false);
    155                 close(null);
     155                vfs_put(null);
    156156                return 1;
    157157        }
  • uspace/lib/bithenge/src/file.c

    rb19e892 r9c4cf0d  
    8888{
    8989        file_blob_t *blob = blob_as_file(base);
    90         close(blob->fd);
     90        vfs_put(blob->fd);
    9191        free(blob);
    9292}
     
    106106        if (rc != EOK) {
    107107                if (needs_close)
    108                         close(fd);
     108                        vfs_put(fd);
    109109                return rc;
    110110        }
     
    114114        if (!blob) {
    115115                if (needs_close)
    116                         close(fd);
     116                        vfs_put(fd);
    117117                return ENOMEM;
    118118        }
     
    121121                free(blob);
    122122                if (needs_close)
    123                         close(fd);
     123                        vfs_put(fd);
    124124                return rc;
    125125        }
  • uspace/lib/c/generic/elf/elf_mod.c

    rb19e892 r9c4cf0d  
    108108        rc = elf_load_module(&elf, so_bias);
    109109
    110         close(ofile);
     110        vfs_put(ofile);
    111111        return rc;
    112112}
     
    117117        int file = vfs_lookup(path, 0);
    118118        int rc = elf_load_file(file, so_bias, flags, info);
    119         close(file);
     119        vfs_put(file);
    120120        return rc;
    121121}
  • uspace/lib/c/generic/io/io.c

    rb19e892 r9c4cf0d  
    305305        if (rc != EOK) {
    306306                errno = rc;
    307                 close(file);
     307                vfs_put(file);
    308308                free(stream);
    309309                return NULL;
     
    314314                if (rc != EOK) {
    315315                        errno = rc;
    316                         close(file);
     316                        vfs_put(file);
    317317                        free(stream);
    318318                        return NULL;
     
    370370       
    371371        if (stream->fd >= 0)
    372                 rc = close(stream->fd);
     372                rc = vfs_put(stream->fd);
    373373       
    374374        list_remove(&stream->link);
  • uspace/lib/c/generic/loader.c

    rb19e892 r9c4cf0d  
    204204       
    205205        int rc = loader_set_program(ldr, name, fd);
    206         close(fd);
     206        vfs_put(fd);
    207207        return rc;
    208208}
  • uspace/lib/c/generic/task.c

    rb19e892 r9c4cf0d  
    181181        if (root >= 0) {
    182182                rc = loader_add_inbox(ldr, "root", root);
    183                 close(root);
     183                vfs_put(root);
    184184                if (rc != EOK)
    185185                        goto error;
  • uspace/lib/c/generic/vfs/inbox.c

    rb19e892 r9c4cf0d  
    11
    22#include <vfs/inbox.h>
     3#include <vfs/vfs.h>
    34
    45#include <adt/list.h>
     
    126127                int original = inbox_set(entries[i].name, entries[i].file);
    127128                if (original >= 0) {
    128                         close(original);
     129                        vfs_put(original);
    129130                }
    130131        }
  • uspace/lib/c/generic/vfs/vfs.c

    rb19e892 r9c4cf0d  
    8282        fibril_mutex_lock(&root_mutex);
    8383        if (root_fd >= 0)
    84                 close(root_fd);
     84                vfs_put(root_fd);
    8585        root_fd = vfs_clone(nroot, -1, true);
    8686        fibril_mutex_unlock(&root_mutex);
     
    149149        }
    150150        int rc = _vfs_walk(root, p, flags);
    151         close(root);
     151        vfs_put(root);
    152152        free(p);
    153153        return rc;
     
    171171        int rc = vfs_open(file, mode);
    172172        if (rc != EOK) {
    173                 close(file);
     173                vfs_put(file);
    174174                return rc;
    175175        }
     
    342342                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
    343343                            instance, NULL);
    344                         close(mpfd);
     344                        vfs_put(mpfd);
    345345                } else {
    346346                        rc = mpfd;
     
    363363       
    364364        int rc = vfs_unmount(mp);
    365         close(mp);
     365        vfs_put(mp);
    366366        return rc;
    367367}
     
    370370 *
    371371 * @param fildes File descriptor
    372  * @return Zero on success. On error -1 is returned and errno is set.
    373  */
    374 int close(int fildes)
     372 * @return EOK on success or a negative error code otherwise.
     373 */
     374int vfs_put(int fildes)
    375375{
    376376        sysarg_t rc;
    377377       
    378378        async_exch_t *exch = vfs_exchange_begin();
    379         rc = async_req_1_0(exch, VFS_IN_CLOSE, fildes);
     379        rc = async_req_1_0(exch, VFS_IN_PUT, fildes);
    380380        vfs_exchange_end(exch);
    381381       
     
    631631        int rc = vfs_stat(file, stat);
    632632
    633         close(file);
     633        vfs_put(file);
    634634
    635635        return rc;
     
    660660        if (rc < 0) {
    661661                free(dirp);
    662                 close(fd);
     662                vfs_put(fd);
    663663                errno = rc;
    664664                return NULL;
     
    711711        int rc;
    712712       
    713         rc = close(dirp->fd);
     713        rc = vfs_put(dirp->fd);
    714714        free(dirp);
    715715
     
    726726                return file;
    727727
    728         close(file);
     728        vfs_put(file);
    729729
    730730        return EOK;
     
    762762
    763763        free(pa);
    764         close(parent);
     764        vfs_put(parent);
    765765        return rc;
    766766}       
     
    816816        if (parent < 0) {
    817817                free(pa);
    818                 close(expect);
     818                vfs_put(expect);
    819819                return parent;
    820820        }
     
    823823       
    824824        free(pa);
    825         close(parent);
    826         close(expect);
     825        vfs_put(parent);
     826        vfs_put(expect);
    827827        return rc;
    828828}
     
    871871                free(olda);
    872872                free(newa);
    873                 close(root);
     873                vfs_put(root);
    874874                async_wait_for(req, &rc_orig);
    875875                if (rc_orig != EOK)
     
    886886                free(olda);
    887887                free(newa);
    888                 close(root);
     888                vfs_put(root);
    889889                async_wait_for(req, &rc_orig);
    890890                if (rc_orig != EOK)
     
    899899        free(olda);
    900900        free(newa);
    901         close(root);
     901        vfs_put(root);
    902902        async_wait_for(req, &rc);
    903903
     
    934934       
    935935        if (cwd_fd >= 0)
    936                 close(cwd_fd);
     936                vfs_put(cwd_fd);
    937937       
    938938        if (cwd_path)
     
    11241124        int rc = vfs_statfs(file, st);
    11251125
    1126         close(file);
     1126        vfs_put(file);
    11271127
    11281128        return rc;
  • uspace/lib/c/include/ipc/vfs.h

    rb19e892 r9c4cf0d  
    6767        VFS_IN_RESIZE,
    6868        VFS_IN_STAT,
    69         VFS_IN_CLOSE,
    7069        VFS_IN_MOUNT,
     70        VFS_IN_PUT,
    7171        VFS_IN_UNMOUNT,
    7272        VFS_IN_SYNC,
  • uspace/lib/c/include/unistd.h

    rb19e892 r9c4cf0d  
    6161extern ssize_t read(int, aoff64_t *, void *, size_t);
    6262
    63 extern int close(int);
    64 
    6563extern char *getcwd(char *, size_t);
    6664extern int chdir(const char *);
  • uspace/lib/c/include/vfs/vfs.h

    rb19e892 r9c4cf0d  
    9797    unsigned, int *);
    9898extern int vfs_open(int, int);
     99extern int vfs_put(int);
    99100extern int vfs_resize(int, aoff64_t);
    100101extern int vfs_root(void);
  • uspace/lib/pcut/src/os/helenos.c

    rb19e892 r9c4cf0d  
    218218
    219219leave_close_tempfile:
    220         close(tempfile);
     220        vfs_put(tempfile);
    221221        vfs_unlink_path(tempfile_name);
    222222
  • uspace/lib/posix/source/fcntl.c

    rb19e892 r9c4cf0d  
    142142        rc = rcerrno(vfs_open, file, mode);
    143143        if (rc != EOK) {
    144                 close (file);
     144                vfs_put(file);
    145145                return -1;
    146146        }
     
    150150                        rc = rcerrno(vfs_resize, file, 0);
    151151                        if (rc != EOK) {
    152                                 close(file);
     152                                vfs_put(file);
    153153                                return -1;
    154154                        }
  • uspace/lib/posix/source/unistd.c

    rb19e892 r9c4cf0d  
    179179{
    180180        posix_pos[fildes] = 0;
    181         return negerrno(close, fildes);
     181        int rc = rcerrno(vfs_put, fildes);
     182        if (rc != EOK)
     183                return -1;
     184        else
     185                return 0;
    182186}
    183187
     
    338342                if (fd < 0)
    339343                        return -1;
    340                 close(fd);
     344                posix_close(fd);
    341345                return 0;
    342346        } else {
  • uspace/srv/devman/match.c

    rb19e892 r9c4cf0d  
    243243       
    244244        if (opened)
    245                 close(fd);
     245                vfs_put(fd);
    246246       
    247247        return suc;
  • uspace/srv/vfs/vfs.h

    rb19e892 r9c4cf0d  
    205205
    206206extern int vfs_op_clone(int oldfd, int newfd, bool desc);
    207 extern int vfs_op_close(int fd);
    208207extern int vfs_op_mount(int mpfd, unsigned servid, unsigned flags, unsigned instance, const char *opts, const char *fsname, int *outfd);
    209208extern int vfs_op_mtab_get(void);
    210209extern int vfs_op_open(int fd, int flags);
     210extern int vfs_op_put(int fd);
    211211extern int vfs_op_read(int fd, aoff64_t, size_t *out_bytes);
    212212extern int vfs_op_rename(int basefd, char *old, char *new);
  • uspace/srv/vfs/vfs_ipc.c

    rb19e892 r9c4cf0d  
    4444}
    4545
    46 static void vfs_in_close(ipc_callid_t rid, ipc_call_t *request)
    47 {
    48         int fd = IPC_GET_ARG1(*request);
    49         int rc = vfs_op_close(fd);
    50         async_answer_0(rid, rc);
    51 }
    52 
    5346static void vfs_in_mount(ipc_callid_t rid, ipc_call_t *request)
    5447{
     
    10598}
    10699
     100static void vfs_in_put(ipc_callid_t rid, ipc_call_t *request)
     101{
     102        int fd = IPC_GET_ARG1(*request);
     103        int rc = vfs_op_put(fd);
     104        async_answer_0(rid, rc);
     105}
     106
    107107static void vfs_in_read(ipc_callid_t rid, ipc_call_t *request)
    108108{
     
    268268                        vfs_in_clone(callid, &call);
    269269                        break;
    270                 case VFS_IN_CLOSE:
    271                         vfs_in_close(callid, &call);
    272                         break;
    273270                case VFS_IN_MOUNT:
    274271                        vfs_in_mount(callid, &call);
     
    276273                case VFS_IN_OPEN:
    277274                        vfs_in_open(callid, &call);
     275                        break;
     276                case VFS_IN_PUT:
     277                        vfs_in_put(callid, &call);
    278278                        break;
    279279                case VFS_IN_READ:
  • uspace/srv/vfs/vfs_ops.c

    rb19e892 r9c4cf0d  
    124124}
    125125
    126 int vfs_op_close(int fd)
     126int vfs_op_put(int fd)
    127127{
    128128        return vfs_fd_free(fd);
Note: See TracChangeset for help on using the changeset viewer.