Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r08232ee rdd2cfa7  
    4444#include <string.h>
    4545#include <bool.h>
    46 #include <fibril_synch.h>
     46#include <fibril_sync.h>
    4747#include <adt/list.h>
    4848#include <unistd.h>
    … …  
    125125                            (ipcarg_t) dev_handle, &answer);
    126126                        /* send the mount options */
    127                         rc = async_data_write_start(phone, (void *)opts,
     127                        rc = ipc_data_write_start(phone, (void *)opts,
    128128                            str_size(opts));
    129129                        if (rc != EOK) {
    … …  
    207207       
    208208        /* send the mount options */
    209         rc = async_data_write_start(phone, (void *)opts, str_size(opts));
     209        rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
    210210        if (rc != EOK) {
    211211                async_wait_for(msg, NULL);
    … …  
    268268        ipc_callid_t callid;
    269269        size_t size;
    270         if (!async_data_write_receive(&callid, &size)) {
     270        if (!ipc_data_write_receive(&callid, &size)) {
    271271                ipc_answer_0(callid, EINVAL);
    272272                ipc_answer_0(rid, EINVAL);
    … …  
    290290       
    291291        /* Deliver the mount point. */
    292         ipcarg_t retval = async_data_write_finalize(callid, mp, size);
     292        ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
    293293        if (retval != EOK) {
    294294                ipc_answer_0(rid, retval);
    … …  
    299299       
    300300        /* Now we expect to receive the mount options. */
    301         if (!async_data_write_receive(&callid, &size)) {
     301        if (!ipc_data_write_receive(&callid, &size)) {
    302302                ipc_answer_0(callid, EINVAL);
    303303                ipc_answer_0(rid, EINVAL);
    … …  
    324324
    325325        /* Deliver the mount options. */
    326         retval = async_data_write_finalize(callid, opts, size);
     326        retval = ipc_data_write_finalize(callid, opts, size);
    327327        if (retval != EOK) {
    328328                ipc_answer_0(rid, retval);
    … …  
    337337         * system.
    338338         */
    339         if (!async_data_write_receive(&callid, &size)) {
     339        if (!ipc_data_write_receive(&callid, &size)) {
    340340                ipc_answer_0(callid, EINVAL);
    341341                ipc_answer_0(rid, EINVAL);
    … …  
    370370       
    371371        /* Deliver the file system name. */
    372         retval = async_data_write_finalize(callid, fs_name, size);
     372        retval = ipc_data_write_finalize(callid, fs_name, size);
    373373        if (retval != EOK) {
    374374                ipc_answer_0(rid, retval);
    … …  
    469469       
    470470        ipc_callid_t callid;
    471         if (!async_data_write_receive(&callid, &len)) {
     471        if (!ipc_data_write_receive(&callid, &len)) {
    472472                ipc_answer_0(callid, EINVAL);
    473473                ipc_answer_0(rid, EINVAL);
    … …  
    483483       
    484484        int rc;
    485         if ((rc = async_data_write_finalize(callid, path, len))) {
     485        if ((rc = ipc_data_write_finalize(callid, path, len))) {
    486486                ipc_answer_0(rid, rc);
    487487                free(path);
    … …  
    543543         * structure.
    544544         */
    545         int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
     545        int fd = vfs_fd_alloc();
    546546        if (fd < 0) {
    547547                vfs_node_put(node);
    … …  
    620620         * structure.
    621621         */
    622         int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
     622        int fd = vfs_fd_alloc();
    623623        if (fd < 0) {
    624624                vfs_node_put(node);
    … …  
    679679}
    680680
    681 static int vfs_close_internal(vfs_file_t *file)
    682 {
    683         /*
    684          * Lock the open file structure so that no other thread can manipulate
    685          * the same open file at a time.
    686          */
    687         fibril_mutex_lock(&file->lock);
    688        
    689         if (file->refcnt <= 1) {
    690                 /* Only close the file on the destination FS server
    691                    if there are no more file descriptors (except the
    692                    present one) pointing to this file. */
    693                
    694                 int fs_phone = vfs_grab_phone(file->node->fs_handle);
    695                
    696                 /* Make a VFS_OUT_CLOSE request at the destination FS server. */
    697                 aid_t msg;
    698                 ipc_call_t answer;
    699                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
    700                     file->node->index, &answer);
    701                
    702                 /* Wait for reply from the FS server. */
    703                 ipcarg_t rc;
    704                 async_wait_for(msg, &rc);
    705                
    706                 vfs_release_phone(fs_phone);
    707                 fibril_mutex_unlock(&file->lock);
    708                
    709                 return IPC_GET_ARG1(answer);
    710         }
    711        
    712         fibril_mutex_unlock(&file->lock);
    713         return EOK;
    714 }
    715 
    716681void vfs_close(ipc_callid_t rid, ipc_call_t *request)
    717682{
    … …  
    725690        }
    726691       
    727         int ret = vfs_close_internal(file);
    728         if (ret != EOK)
    729                 ipc_answer_0(rid, ret);
    730        
    731         ret = vfs_fd_free(fd);
    732         ipc_answer_0(rid, ret);
     692        /*
     693         * Lock the open file structure so that no other thread can manipulate
     694         * the same open file at a time.
     695         */
     696        fibril_mutex_lock(&file->lock);
     697        int fs_phone = vfs_grab_phone(file->node->fs_handle);
     698       
     699        /* Make a VFS_OUT_CLOSE request at the destination FS server. */
     700        aid_t msg;
     701        ipc_call_t answer;
     702        msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
     703            file->node->index, &answer);
     704
     705        /* Wait for reply from the FS server. */
     706        ipcarg_t rc;
     707        async_wait_for(msg, &rc);
     708
     709        vfs_release_phone(fs_phone);
     710        fibril_mutex_unlock(&file->lock);
     711       
     712        int retval = IPC_GET_ARG1(answer);
     713        if (retval != EOK)
     714                ipc_answer_0(rid, retval);
     715       
     716        retval = vfs_fd_free(fd);
     717        ipc_answer_0(rid, retval);
    733718}
    734719
    … …  
    762747        int res;
    763748        if (read)
    764                 res = async_data_read_receive(&callid, NULL);
     749                res = ipc_data_read_receive(&callid, NULL);
    765750        else
    766                 res = async_data_write_receive(&callid, NULL);
     751                res = ipc_data_write_receive(&callid, NULL);
    767752        if (!res) {
    768753                ipc_answer_0(callid, EINVAL);
    … …  
    900885                }
    901886                newpos = size + off;
    902                 file->pos = newpos;
    903887                fibril_mutex_unlock(&file->lock);
    904888                ipc_answer_1(rid, EOK, newpos);
    … …  
    950934{
    951935        int fd = IPC_GET_ARG1(*request);
     936        size_t size = IPC_GET_ARG2(*request);
    952937        ipcarg_t rc;
    953938
    … …  
    959944
    960945        ipc_callid_t callid;
    961         if (!async_data_read_receive(&callid, NULL)) {
     946        if (!ipc_data_read_receive(&callid, NULL)) {
    962947                ipc_answer_0(callid, EINVAL);
    963948                ipc_answer_0(rid, EINVAL);
    … …  
    985970        ipc_callid_t callid;
    986971
    987         if (!async_data_write_receive(&callid, &len)) {
     972        if (!ipc_data_write_receive(&callid, &len)) {
    988973                ipc_answer_0(callid, EINVAL);
    989974                ipc_answer_0(rid, EINVAL);
    … …  
    997982        }
    998983        int rc;
    999         if ((rc = async_data_write_finalize(callid, path, len))) {
     984        if ((rc = ipc_data_write_finalize(callid, path, len))) {
    1000985                ipc_answer_0(rid, rc);
    1001986                free(path);
    … …  
    1004989        path[len] = '\0';
    1005990
    1006         if (!async_data_read_receive(&callid, NULL)) {
     991        if (!ipc_data_read_receive(&callid, NULL)) {
    1007992                free(path);
    1008993                ipc_answer_0(callid, EINVAL);
    … …  
    10531038        ipc_callid_t callid;
    10541039
    1055         if (!async_data_write_receive(&callid, &len)) {
     1040        if (!ipc_data_write_receive(&callid, &len)) {
    10561041                ipc_answer_0(callid, EINVAL);
    10571042                ipc_answer_0(rid, EINVAL);
    … …  
    10651050        }
    10661051        int rc;
    1067         if ((rc = async_data_write_finalize(callid, path, len))) {
     1052        if ((rc = ipc_data_write_finalize(callid, path, len))) {
    10681053                ipc_answer_0(rid, rc);
    10691054                free(path);
    … …  
    10901075        ipc_callid_t callid;
    10911076
    1092         if (!async_data_write_receive(&callid, &len)) {
     1077        if (!ipc_data_write_receive(&callid, &len)) {
    10931078                ipc_answer_0(callid, EINVAL);
    10941079                ipc_answer_0(rid, EINVAL);
    … …  
    11021087        }
    11031088        int rc;
    1104         if ((rc = async_data_write_finalize(callid, path, len))) {
     1089        if ((rc = ipc_data_write_finalize(callid, path, len))) {
    11051090                ipc_answer_0(rid, rc);
    11061091                free(path);
    … …  
    11411126
    11421127        /* Retrieve the old path. */
    1143         if (!async_data_write_receive(&callid, &olen)) {
     1128        if (!ipc_data_write_receive(&callid, &olen)) {
    11441129                ipc_answer_0(callid, EINVAL);
    11451130                ipc_answer_0(rid, EINVAL);
    … …  
    11521137                return;
    11531138        }
    1154         if ((rc = async_data_write_finalize(callid, old, olen))) {
     1139        if ((rc = ipc_data_write_finalize(callid, old, olen))) {
    11551140                ipc_answer_0(rid, rc);
    11561141                free(old);
    … …  
    11601145       
    11611146        /* Retrieve the new path. */
    1162         if (!async_data_write_receive(&callid, &nlen)) {
     1147        if (!ipc_data_write_receive(&callid, &nlen)) {
    11631148                ipc_answer_0(callid, EINVAL);
    11641149                ipc_answer_0(rid, EINVAL);
    … …  
    11731158                return;
    11741159        }
    1175         if ((rc = async_data_write_finalize(callid, new, nlen))) {
     1160        if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
    11761161                ipc_answer_0(rid, rc);
    11771162                free(old);
    … …  
    13261311}
    13271312
    1328 void vfs_dup(ipc_callid_t rid, ipc_call_t *request)
    1329 {
    1330         int oldfd = IPC_GET_ARG1(*request);
    1331         int newfd = IPC_GET_ARG2(*request);
    1332        
    1333         /* Lookup the file structure corresponding to oldfd. */
    1334         vfs_file_t *oldfile = vfs_file_get(oldfd);
    1335         if (!oldfile) {
    1336                 ipc_answer_0(rid, EBADF);
    1337                 return;
    1338         }
    1339        
    1340         /* If the file descriptors are the same, do nothing. */
    1341         if (oldfd == newfd) {
    1342                 ipc_answer_1(rid, EOK, newfd);
    1343                 return;
    1344         }
    1345        
    1346         /*
    1347          * Lock the open file structure so that no other thread can manipulate
    1348          * the same open file at a time.
    1349          */
    1350         fibril_mutex_lock(&oldfile->lock);
    1351        
    1352         /* Lookup an open file structure possibly corresponding to newfd. */
    1353         vfs_file_t *newfile = vfs_file_get(newfd);
    1354         if (newfile) {
    1355                 /* Close the originally opened file. */
    1356                 int ret = vfs_close_internal(newfile);
    1357                 if (ret != EOK) {
    1358                         ipc_answer_0(rid, ret);
    1359                         return;
    1360                 }
    1361                
    1362                 ret = vfs_fd_free(newfd);
    1363                 if (ret != EOK) {
    1364                         ipc_answer_0(rid, ret);
    1365                         return;
    1366                 }
    1367         }
    1368        
    1369         /* Assign the old file to newfd. */
    1370         int ret = vfs_fd_assign(oldfile, newfd);
    1371         fibril_mutex_unlock(&oldfile->lock);
    1372        
    1373         if (ret != EOK)
    1374                 ipc_answer_0(rid, ret);
    1375         else
    1376                 ipc_answer_1(rid, EOK, newfd);
    1377 }
    1378 
    13791313/**
    13801314 * @}
Note: See TracChangeset for help on using the changeset viewer.