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

Changeset fcab7ef in mainline


Ignore:
Timestamp:
2017-03-26T20:46:56Z (3 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
fe91f66
Parents:
f644472
Message:

Merge dup2() into vfs_clone()

Location:
uspace
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/getterm/getterm.c

    rf644472 rfcab7ef  
    4343#include <errno.h>
    4444#include <loc.h>
     45#include <vfs/vfs.h>
    4546#include "version.h"
    4647#include "welcome.h"
     
    7172       
    7273        if (oldfd != fd) {
    73                 if (dup2(oldfd, fd) != fd)
     74                if (vfs_clone(oldfd, fd, false) != fd)
    7475                        return;
    7576               
  • uspace/app/redir/redir.c

    rf644472 rfcab7ef  
    4444#include <str_error.h>
    4545#include <errno.h>
     46#include <vfs/vfs.h>
    4647
    4748#define NAME  "redir"
     
    6566       
    6667        if (oldfd != fd) {
    67                 if (dup2(oldfd, fd) != fd)
     68                if (vfs_clone(oldfd, fd, false) != fd)
    6869                        return;
    6970               
  • uspace/lib/bithenge/src/failure.c

    rf644472 rfcab7ef  
    152152                if (null == -1)
    153153                        exit(127);
    154                 dup2(null, STDOUT_FILENO);
    155                 dup2(null, STDERR_FILENO);
     154                vfs_clone(null, STDOUT_FILENO, false);
     155                vfs_clone(null, STDERR_FILENO, false);
    156156                close(null);
    157157                return 1;
  • uspace/lib/c/generic/elf/elf_mod.c

    rf644472 rfcab7ef  
    9696        elf_ld_t elf;
    9797
    98         int ofile = vfs_clone(file, true);
     98        int ofile = vfs_clone(file, -1, true);
    9999        int rc = _vfs_open(ofile, MODE_READ);
    100100        if (rc != EOK) {
  • uspace/lib/c/generic/io/io.c

    rf644472 rfcab7ef  
    114114        int infd = inbox_get("stdin");
    115115        if (infd >= 0) {
    116                 int stdinfd = vfs_clone(infd, false);
     116                int stdinfd = vfs_clone(infd, -1, false);
    117117                assert(stdinfd == 0);
    118118                _vfs_open(stdinfd, MODE_READ);
     
    125125        int outfd = inbox_get("stdout");
    126126        if (outfd >= 0) {
    127                 int stdoutfd = vfs_clone(outfd, false);
     127                int stdoutfd = vfs_clone(outfd, -1, false);
    128128                assert(stdoutfd <= 1);
    129                 while (stdoutfd < 1) {
    130                         stdoutfd = vfs_clone(outfd, false);
    131                 }
     129                while (stdoutfd < 1)
     130                        stdoutfd = vfs_clone(outfd, -1, false);
    132131                _vfs_open(stdoutfd, MODE_APPEND);
    133132                stdout = fdopen(stdoutfd, "a");
     
    139138        int errfd = inbox_get("stderr");
    140139        if (errfd >= 0) {
    141                 int stderrfd = vfs_clone(errfd, false);
     140                int stderrfd = vfs_clone(errfd, -1, false);
    142141                assert(stderrfd <= 2);
    143                 while (stderrfd < 2) {
    144                         stderrfd = vfs_clone(errfd, false);
    145                 }
     142                while (stderrfd < 2)
     143                        stderrfd = vfs_clone(errfd, -1, false);
    146144                _vfs_open(stderrfd, MODE_APPEND);
    147145                stderr = fdopen(stderrfd, "a");
  • uspace/lib/c/generic/vfs/vfs.c

    rf644472 rfcab7ef  
    7676                r = ENOENT;
    7777        else
    78                 r = vfs_clone(root_fd, true);
     78                r = vfs_clone(root_fd, -1, true);
    7979        fibril_mutex_unlock(&root_mutex);
    8080        return r;
     
    8686        if (root_fd >= 0)
    8787                close(root_fd);
    88         root_fd = vfs_clone(nroot, true);
     88        root_fd = vfs_clone(nroot, -1, true);
    8989        fibril_mutex_unlock(&root_mutex);
    9090}
     
    10711071}
    10721072
    1073 /** Duplicate open file.
    1074  *
    1075  * Duplicate open file under a new file descriptor.
    1076  *
    1077  * @param oldfd Old file descriptor
    1078  * @param newfd New file descriptor
    1079  * @return 0 on success. On error -1 is returned and errno is set
    1080  */
    1081 int dup2(int oldfd, int newfd)
    1082 {
    1083         async_exch_t *exch = vfs_exchange_begin();
    1084        
    1085         sysarg_t ret;
    1086         sysarg_t rc = async_req_2_1(exch, VFS_IN_DUP, oldfd, newfd, &ret);
    1087        
    1088         vfs_exchange_end(exch);
    1089        
    1090         if (rc == EOK)
    1091                 rc = ret;
    1092        
    1093         if (rc != EOK) {
    1094                 errno = rc;
    1095                 return -1;
    1096         }
    1097        
    1098         return 0;
    1099 }
    1100 
    11011073static void process_mp(const char *path, struct stat *stat, list_t *mtab_list)
    11021074{
     
    12541226}
    12551227
    1256 int vfs_clone(int file, bool high_descriptor)
     1228int vfs_clone(int file_from, int file_to, bool high_descriptor)
    12571229{
    12581230        async_exch_t *vfs_exch = vfs_exchange_begin();
    1259         int rc = async_req_2_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file,
    1260             (sysarg_t) high_descriptor);
     1231        int rc = async_req_3_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
     1232            (sysarg_t) file_to, (sysarg_t) high_descriptor);
    12611233        vfs_exchange_end(vfs_exch);
    12621234        return rc;
  • uspace/lib/c/include/ipc/vfs.h

    rf644472 rfcab7ef  
    7373        VFS_IN_REGISTER,
    7474        VFS_IN_RENAME,
    75         VFS_IN_DUP,
    7675        VFS_IN_WAIT_HANDLE,
    7776        VFS_IN_STATFS,
  • uspace/lib/c/include/unistd.h

    rf644472 rfcab7ef  
    5858#define getpagesize()  (PAGE_SIZE)
    5959
    60 extern int dup2(int, int);
    61 
    6260extern ssize_t write(int, aoff64_t *, const void *, size_t);
    6361extern ssize_t read(int, aoff64_t *, void *, size_t);
  • uspace/lib/c/include/vfs/vfs.h

    rf644472 rfcab7ef  
    6969extern int vfs_receive_handle(bool);
    7070
    71 extern int vfs_clone(int, bool);
     71extern int vfs_clone(int, int, bool);
    7272extern int vfs_root(void);
    7373extern void vfs_root_set(int);
  • uspace/lib/posix/source/unistd.c

    rf644472 rfcab7ef  
    306306int posix_dup2(int fildes, int fildes2)
    307307{
    308         return negerrno(dup2, fildes, fildes2);
     308        return negerrno(vfs_clone, fildes, fildes2, false);
    309309}
    310310
  • uspace/srv/vfs/vfs.h

    rf644472 rfcab7ef  
    204204extern int vfs_open_node_remote(vfs_node_t *);
    205205
    206 extern int vfs_op_clone(int oldfd, bool desc);
     206extern int vfs_op_clone(int oldfd, int newfd, bool desc);
    207207extern int vfs_op_close(int fd);
    208 extern int vfs_op_dup(int oldfd, int newfd);
    209208extern int vfs_op_fstat(int fd);
    210209extern int vfs_op_mount(int mpfd, unsigned servid, unsigned flags, unsigned instance, const char *opts, const char *fsname, int *outfd);
  • uspace/srv/vfs/vfs_file.c

    rf644472 rfcab7ef  
    304304
    305305        fibril_mutex_lock(&VFS_DATA->lock);     
    306         if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (FILES[fd] != NULL)) {
     306        if ((fd < 0) || (fd >= MAX_OPEN_FILES)) {
    307307                fibril_mutex_unlock(&VFS_DATA->lock);
    308                 return EINVAL;
     308                return EBADF;
     309        }
     310        if (FILES[fd] != NULL) {
     311                fibril_mutex_unlock(&VFS_DATA->lock);
     312                return EEXIST;
    309313        }
    310314       
  • uspace/srv/vfs/vfs_ipc.c

    rf644472 rfcab7ef  
    3737{
    3838        int oldfd = IPC_GET_ARG1(*request);
    39         bool desc = IPC_GET_ARG2(*request);
    40        
    41         int ret = vfs_op_clone(oldfd, desc);
     39        int newfd = IPC_GET_ARG2(*request);
     40        bool desc = IPC_GET_ARG3(*request);
     41       
     42        int ret = vfs_op_clone(oldfd, newfd, desc);
    4243        async_answer_0(rid, ret);
    4344}
     
    4849        int rc = vfs_op_close(fd);
    4950        async_answer_0(rid, rc);
    50 }
    51 
    52 static void vfs_in_dup(ipc_callid_t rid, ipc_call_t *request)
    53 {
    54         int oldfd = IPC_GET_ARG1(*request);
    55         int newfd = IPC_GET_ARG2(*request);
    56         int rc = vfs_op_dup(oldfd, newfd);
    57         async_answer_1(rid, rc, newfd);
    5851}
    5952
     
    279272                        vfs_in_close(callid, &call);
    280273                        break;
    281                 case VFS_IN_DUP:
    282                         vfs_in_dup(callid, &call);
    283                         break;
    284274                case VFS_IN_FSTAT:
    285275                        vfs_in_fstat(callid, &call);
  • uspace/srv/vfs/vfs_ops.c

    rf644472 rfcab7ef  
    8888}
    8989
    90 int vfs_op_clone(int oldfd, bool desc)
    91 {
     90int vfs_op_clone(int oldfd, int newfd, bool desc)
     91{
     92        int rc;
     93
     94        /* If the file descriptors are the same, do nothing. */
     95        if (oldfd == newfd)
     96                return EOK;
     97       
    9298        /* Lookup the file structure corresponding to fd. */
    9399        vfs_file_t *oldfile = vfs_file_get(oldfd);
     
    96102
    97103        assert(oldfile->node != NULL);
    98        
    99         vfs_file_t *newfile;
    100         int newfd = vfs_fd_alloc(&newfile, desc);
    101         if (newfd >= 0) {
    102                 newfile->node = oldfile->node;
    103                 newfile->permissions = oldfile->permissions;
    104                 vfs_node_addref(newfile->node);
    105        
    106                 vfs_file_put(newfile);
     104
     105        if (newfd != -1) {
     106                /* Make sure newfd is closed. */
     107                (void) vfs_fd_free(newfd);
     108                /* Assign the old file to newfd. */
     109                rc = vfs_fd_assign(oldfile, newfd);
     110        } else {
     111                vfs_file_t *newfile;
     112                int newfd = vfs_fd_alloc(&newfile, desc);
     113                if (newfd >= 0) {
     114                        newfile->node = oldfile->node;
     115                        newfile->permissions = oldfile->permissions;
     116                        vfs_node_addref(newfile->node);
     117       
     118                        vfs_file_put(newfile);
     119                }
     120                rc = newfd;
    107121        }
    108122        vfs_file_put(oldfile);
    109123       
    110         return newfd;
     124        return rc;
    111125}
    112126
     
    114128{
    115129        return vfs_fd_free(fd);
    116 }
    117 
    118 int vfs_op_dup(int oldfd, int newfd)
    119 {
    120         /* If the file descriptors are the same, do nothing. */
    121         if (oldfd == newfd)
    122                 return EOK;
    123        
    124         /* Lookup the file structure corresponding to oldfd. */
    125         vfs_file_t *oldfile = vfs_file_get(oldfd);
    126         if (!oldfile)
    127                 return EBADF;
    128        
    129         /* Make sure newfd is closed. */
    130         (void) vfs_fd_free(newfd);
    131        
    132         /* Assign the old file to newfd. */
    133         int ret = vfs_fd_assign(oldfile, newfd);
    134         vfs_file_put(oldfile);
    135        
    136         return ret;
    137130}
    138131
Note: See TracChangeset for help on using the changeset viewer.