Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libc/generic/vfs/vfs.c

    r1313ee9 r3734106  
    5757static futex_t cwd_futex = FUTEX_INITIALIZER;
    5858
    59 static int cwd_fd = -1;
    60 static char *cwd_path = NULL;
    61 static size_t cwd_size = 0;
     59DIR *cwd_dir = NULL;
     60char *cwd_path = NULL;
     61size_t cwd_size = 0;
    6262
    6363char *absolutize(const char *path, size_t *retlen)
    … …  
    117117}
    118118
    119 int mount(const char *fs_name, const char *mp, const char *fqdn,
     119int mount(const char *fs_name, const char *mp, const char *dev,
    120120    const char *opts, unsigned int flags)
    121121{
    … …  
    126126        dev_handle_t dev_handle;
    127127       
    128         res = devmap_device_get_handle(fqdn, &dev_handle, flags);
     128        res = devmap_device_get_handle(dev, &dev_handle, flags);
    129129        if (res != EOK)
    130130                return res;
    … …  
    140140       
    141141        req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
    142         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
     142        rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    143143        if (rc != EOK) {
    144144                async_wait_for(req, &rc_orig);
    … …  
    152152        }
    153153       
    154         rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
     154        rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
    155155        if (rc != EOK) {
    156156                async_wait_for(req, &rc_orig);
    … …  
    164164        }
    165165
    166         rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
     166        rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    167167        if (rc != EOK) {
    168168                async_wait_for(req, &rc_orig);
    … …  
    197197}
    198198
    199 static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
    200 {
    201         futex_down(&vfs_phone_futex);
    202         async_serialize_start();
    203         vfs_connect();
    204        
     199static int _open(const char *path, int lflag, int oflag, ...)
     200{
     201        ipcarg_t rc;
    205202        ipc_call_t answer;
    206         aid_t req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
    207         ipcarg_t rc = async_data_write_start(vfs_phone, abs, abs_size);
    208        
     203        aid_t req;
     204       
     205        size_t pa_size;
     206        char *pa = absolutize(path, &pa_size);
     207        if (!pa)
     208                return ENOMEM;
     209       
     210        futex_down(&vfs_phone_futex);
     211        async_serialize_start();
     212        vfs_connect();
     213       
     214        req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
     215        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    209216        if (rc != EOK) {
    210217                ipcarg_t rc_orig;
    211                 async_wait_for(req, &rc_orig);
    212                
    213                 async_serialize_end();
    214                 futex_up(&vfs_phone_futex);
    215                
    216                 if (rc_orig == EOK)
    217                         return (int) rc;
    218                 else
    219                         return (int) rc_orig;
    220         }
    221        
    222         async_wait_for(req, &rc);
    223         async_serialize_end();
    224         futex_up(&vfs_phone_futex);
     218       
     219                async_wait_for(req, &rc_orig);
     220                async_serialize_end();
     221                futex_up(&vfs_phone_futex);
     222                free(pa);
     223                if (rc_orig == EOK)
     224                        return (int) rc;
     225                else
     226                        return (int) rc_orig;
     227        }
     228        async_wait_for(req, &rc);
     229        async_serialize_end();
     230        futex_up(&vfs_phone_futex);
     231        free(pa);
    225232       
    226233        if (rc != EOK)
    … …  
    232239int open(const char *path, int oflag, ...)
    233240{
    234         size_t abs_size;
    235         char *abs = absolutize(path, &abs_size);
    236         if (!abs)
    237                 return ENOMEM;
    238        
    239         int ret = open_internal(abs, abs_size, L_FILE, oflag);
    240         free(abs);
    241        
    242         return ret;
     241        return _open(path, L_FILE, oflag);
    243242}
    244243
    … …  
    291290       
    292291        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    293         rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
     292        rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
    294293        if (rc != EOK) {
    295294                ipcarg_t rc_orig;
    … …  
    323322       
    324323        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    325         rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
     324        rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
    326325        if (rc != EOK) {
    327326                ipcarg_t rc_orig;
    … …  
    403402       
    404403        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
    405         rc = async_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
     404        rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
    406405        if (rc != EOK) {
    407406                ipcarg_t rc_orig;
    … …  
    438437       
    439438        req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
    440         rc = async_data_write_start(vfs_phone, pa, pa_size);
     439        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    441440        if (rc != EOK) {
    442441                async_wait_for(req, &rc_orig);
    … …  
    449448                        return (int) rc_orig;
    450449        }
    451         rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
     450        rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
    452451        if (rc != EOK) {
    453452                async_wait_for(req, &rc_orig);
    … …  
    472471        if (!dirp)
    473472                return NULL;
    474        
    475         size_t abs_size;
    476         char *abs = absolutize(dirname, &abs_size);
    477         if (!abs) {
    478                 free(dirp);
    479                 return ENOMEM;
    480         }
    481        
    482         int ret = open_internal(abs, abs_size, L_DIRECTORY, 0);
    483         free(abs);
    484        
    485         if (ret < 0) {
     473        dirp->fd = _open(dirname, L_DIRECTORY, 0);
     474        if (dirp->fd < 0) {
    486475                free(dirp);
    487476                return NULL;
    488477        }
    489        
    490         dirp->fd = ret;
    491478        return dirp;
    492479}
    … …  
    527514       
    528515        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
    529         rc = async_data_write_start(vfs_phone, pa, pa_size);
     516        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    530517        if (rc != EOK) {
    531518                ipcarg_t rc_orig;
    … …  
    562549       
    563550        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
    564         rc = async_data_write_start(vfs_phone, pa, pa_size);
     551        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    565552        if (rc != EOK) {
    566553                ipcarg_t rc_orig;
    … …  
    615602       
    616603        req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
    617         rc = async_data_write_start(vfs_phone, olda, olda_size);
     604        rc = ipc_data_write_start(vfs_phone, olda, olda_size);
    618605        if (rc != EOK) {
    619606                async_wait_for(req, &rc_orig);
    … …  
    627614                        return (int) rc_orig;
    628615        }
    629         rc = async_data_write_start(vfs_phone, newa, newa_size);
     616        rc = ipc_data_write_start(vfs_phone, newa, newa_size);
    630617        if (rc != EOK) {
    631618                async_wait_for(req, &rc_orig);
    … …  
    649636int chdir(const char *path)
    650637{
    651         size_t abs_size;
    652         char *abs = absolutize(path, &abs_size);
    653         if (!abs)
     638        size_t pa_size;
     639        char *pa = absolutize(path, &pa_size);
     640        if (!pa)
    654641                return ENOMEM;
    655        
    656         int fd = open_internal(abs, abs_size, L_DIRECTORY, O_DESC);
    657        
    658         if (fd < 0) {
    659                 free(abs);
     642
     643        DIR *d = opendir(pa);
     644        if (!d) {
     645                free(pa);
    660646                return ENOENT;
    661647        }
    662        
     648
    663649        futex_down(&cwd_futex);
    664        
    665         if (cwd_fd >= 0)
    666                 close(cwd_fd);
    667        
    668        
    669         if (cwd_path)
    670                 free(cwd_path);
    671        
    672         cwd_fd = fd;
    673         cwd_path = abs;
    674         cwd_size = abs_size;
    675        
     650        if (cwd_dir) {
     651                closedir(cwd_dir);
     652                cwd_dir = NULL;
     653                free(cwd_path);
     654                cwd_path = NULL;
     655                cwd_size = 0;
     656        }
     657        cwd_dir = d;
     658        cwd_path = pa;
     659        cwd_size = pa_size;
    676660        futex_up(&cwd_futex);
    677661        return EOK;
    … …  
    680664char *getcwd(char *buf, size_t size)
    681665{
    682         if (size == 0)
     666        if (!size)
    683667                return NULL;
    684        
    685668        futex_down(&cwd_futex);
    686        
    687         if ((cwd_size == 0) || (size < cwd_size + 1)) {
     669        if (size < cwd_size + 1) {
    688670                futex_up(&cwd_futex);
    689671                return NULL;
    690672        }
    691        
    692673        str_cpy(buf, size, cwd_path);
    693674        futex_up(&cwd_futex);
    694        
    695675        return buf;
    696676}
    … …  
    703683        rc = fstat(fildes, &stat);
    704684
    705         if (!stat.device)
     685        if (!stat.devfs_stat.device)
    706686                return -1;
    707687       
    708         return devmap_device_connect(stat.device, 0);
     688        return devmap_device_connect(stat.devfs_stat.device, 0);
    709689}
    710690
    … …  
    725705}
    726706
    727 int dup2(int oldfd, int newfd)
    728 {
    729         futex_down(&vfs_phone_futex);
    730         async_serialize_start();
    731         vfs_connect();
    732        
    733         ipcarg_t ret;
    734         ipcarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
    735        
    736         async_serialize_end();
    737         futex_up(&vfs_phone_futex);
    738        
    739         if (rc == EOK)
    740                 return (int) ret;
    741        
    742         return (int) rc;
    743 }
    744 
    745707/** @}
    746708 */
Note: See TracChangeset for help on using the changeset viewer.