Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/libc/generic/vfs/vfs.c

    red903174 r1313ee9  
    3535#include <vfs/vfs.h>
    3636#include <vfs/canonify.h>
    37 #include <macros.h>
    3837#include <stdlib.h>
    3938#include <unistd.h>
     
    121120    const char *opts, unsigned int flags)
    122121{
    123         int null_id = -1;
    124         char null[DEVMAP_NAME_MAXLEN];
    125        
    126         if (str_cmp(fqdn, "") == 0) {
    127                 /* No device specified, create a fresh
    128                    null/%d device instead */
    129                 null_id = devmap_null_create();
    130                
    131                 if (null_id == -1)
    132                         return ENOMEM;
    133                
    134                 snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
    135                 fqdn = null;
    136         }
    137        
     122        int res;
     123        ipcarg_t rc;
     124        ipcarg_t rc_orig;
     125        aid_t req;
    138126        dev_handle_t dev_handle;
    139         int res = devmap_device_get_handle(fqdn, &dev_handle, flags);
    140         if (res != EOK) {
    141                 if (null_id != -1)
    142                         devmap_null_destroy(null_id);
    143                
     127       
     128        res = devmap_device_get_handle(fqdn, &dev_handle, flags);
     129        if (res != EOK)
    144130                return res;
    145         }
    146131       
    147132        size_t mpa_size;
    148133        char *mpa = absolutize(mp, &mpa_size);
    149         if (!mpa) {
    150                 if (null_id != -1)
    151                         devmap_null_destroy(null_id);
    152                
    153                 return ENOMEM;
    154         }
    155        
    156         futex_down(&vfs_phone_futex);
    157         async_serialize_start();
    158         vfs_connect();
    159        
    160         ipcarg_t rc_orig;
    161         aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
    162         ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
     134        if (!mpa)
     135                return ENOMEM;
     136       
     137        futex_down(&vfs_phone_futex);
     138        async_serialize_start();
     139        vfs_connect();
     140       
     141        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);
    163143        if (rc != EOK) {
    164144                async_wait_for(req, &rc_orig);
     
    166146                futex_up(&vfs_phone_futex);
    167147                free(mpa);
    168                
    169                 if (null_id != -1)
    170                         devmap_null_destroy(null_id);
    171                
    172148                if (rc_orig == EOK)
    173149                        return (int) rc;
     
    182158                futex_up(&vfs_phone_futex);
    183159                free(mpa);
    184                
    185                 if (null_id != -1)
    186                         devmap_null_destroy(null_id);
    187                
    188                 if (rc_orig == EOK)
    189                         return (int) rc;
    190                 else
    191                         return (int) rc_orig;
    192         }
    193        
     160                if (rc_orig == EOK)
     161                        return (int) rc;
     162                else
     163                        return (int) rc_orig;
     164        }
     165
    194166        rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    195167        if (rc != EOK) {
     
    198170                futex_up(&vfs_phone_futex);
    199171                free(mpa);
    200                
    201                 if (null_id != -1)
    202                         devmap_null_destroy(null_id);
    203                
    204                 if (rc_orig == EOK)
    205                         return (int) rc;
    206                 else
    207                         return (int) rc_orig;
    208         }
    209        
     172                if (rc_orig == EOK)
     173                        return (int) rc;
     174                else
     175                        return (int) rc_orig;
     176        }
     177
    210178        /* Ask VFS whether it likes fs_name. */
    211179        rc = async_req_0_0(vfs_phone, IPC_M_PING);
     
    215183                futex_up(&vfs_phone_futex);
    216184                free(mpa);
    217                
    218                 if (null_id != -1)
    219                         devmap_null_destroy(null_id);
    220                
    221                 if (rc_orig == EOK)
    222                         return (int) rc;
    223                 else
    224                         return (int) rc_orig;
    225         }
    226        
    227         async_wait_for(req, &rc);
    228         async_serialize_end();
    229         futex_up(&vfs_phone_futex);
    230         free(mpa);
    231        
    232         if ((rc != EOK) && (null_id != -1))
    233                 devmap_null_destroy(null_id);
    234        
    235         return (int) rc;
    236 }
    237 
    238 int unmount(const char *mp)
    239 {
    240         ipcarg_t rc;
    241         ipcarg_t rc_orig;
    242         aid_t req;
    243         size_t mpa_size;
    244         char *mpa;
    245        
    246         mpa = absolutize(mp, &mpa_size);
    247         if (!mpa)
    248                 return ENOMEM;
    249        
    250         futex_down(&vfs_phone_futex);
    251         async_serialize_start();
    252         vfs_connect();
    253        
    254         req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
    255         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    256         if (rc != EOK) {
    257                 async_wait_for(req, &rc_orig);
    258                 async_serialize_end();
    259                 futex_up(&vfs_phone_futex);
    260                 free(mpa);
    261                 if (rc_orig == EOK)
    262                         return (int) rc;
    263                 else
    264                         return (int) rc_orig;
    265         }
    266        
    267 
     185                if (rc_orig == EOK)
     186                        return (int) rc;
     187                else
     188                        return (int) rc_orig;
     189        }
     190       
    268191        async_wait_for(req, &rc);
    269192        async_serialize_end();
     
    435358}
    436359
    437 off64_t lseek(int fildes, off64_t offset, int whence)
    438 {
    439         futex_down(&vfs_phone_futex);
    440         async_serialize_start();
    441         vfs_connect();
    442        
    443         ipcarg_t newoff_lo;
    444         ipcarg_t newoff_hi;
    445         ipcarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
    446             LOWER32(offset), UPPER32(offset), whence,
    447             &newoff_lo, &newoff_hi);
    448        
    449         async_serialize_end();
    450         futex_up(&vfs_phone_futex);
    451        
     360off_t lseek(int fildes, off_t offset, int whence)
     361{
     362        ipcarg_t rc;
     363
     364        futex_down(&vfs_phone_futex);
     365        async_serialize_start();
     366        vfs_connect();
     367       
     368        ipcarg_t newoffs;
     369        rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence,
     370            &newoffs);
     371
     372        async_serialize_end();
     373        futex_up(&vfs_phone_futex);
     374
    452375        if (rc != EOK)
    453                 return (off64_t) -1;
    454        
    455         return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
    456 }
    457 
    458 int ftruncate(int fildes, aoff64_t length)
    459 {
    460         ipcarg_t rc;
    461        
    462         futex_down(&vfs_phone_futex);
    463         async_serialize_start();
    464         vfs_connect();
    465        
    466         rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
    467             LOWER32(length), UPPER32(length));
    468         async_serialize_end();
    469         futex_up(&vfs_phone_futex);
    470        
     376                return (off_t) -1;
     377       
     378        return (off_t) newoffs;
     379}
     380
     381int ftruncate(int fildes, off_t length)
     382{
     383        ipcarg_t rc;
     384       
     385        futex_down(&vfs_phone_futex);
     386        async_serialize_start();
     387        vfs_connect();
     388       
     389        rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length);
     390        async_serialize_end();
     391        futex_up(&vfs_phone_futex);
    471392        return (int) rc;
    472393}
     
    482403       
    483404        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
    484         rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
     405        rc = async_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
    485406        if (rc != EOK) {
    486407                ipcarg_t rc_orig;
     
    556477        if (!abs) {
    557478                free(dirp);
    558                 return NULL;
     479                return ENOMEM;
    559480        }
    560481       
Note: See TracChangeset for help on using the changeset viewer.