Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r25bef0ff r79ae36dd  
    7878        size_t rsize;
    7979        unsigned rlnkcnt;
     80        async_exch_t *exch;
    8081        sysarg_t rc;
    81         int phone;
    8282        aid_t msg;
    8383        ipc_call_t answer;
    … …  
    123123                       
    124124                        /* Tell the mountee that it is being mounted. */
    125                         phone = vfs_grab_phone(fs_handle);
    126                         msg = async_send_1(phone, VFS_OUT_MOUNTED,
     125                        exch = vfs_exchange_grab(fs_handle);
     126                        msg = async_send_1(exch, VFS_OUT_MOUNTED,
    127127                            (sysarg_t) devmap_handle, &answer);
    128                         /* send the mount options */
    129                         rc = async_data_write_start(phone, (void *)opts,
     128                        /* Send the mount options */
     129                        rc = async_data_write_start(exch, (void *)opts,
    130130                            str_size(opts));
     131                        vfs_exchange_release(exch);
     132                       
    131133                        if (rc != EOK) {
    132134                                async_wait_for(msg, NULL);
    133                                 vfs_release_phone(fs_handle, phone);
    134135                                fibril_rwlock_write_unlock(&namespace_rwlock);
    135136                                async_answer_0(rid, rc);
    … …  
    137138                        }
    138139                        async_wait_for(msg, &rc);
    139                         vfs_release_phone(fs_handle, phone);
    140140                       
    141141                        if (rc != EOK) {
    … …  
    182182         */
    183183       
    184         int mountee_phone = vfs_grab_phone(fs_handle);
    185         assert(mountee_phone >= 0);
    186 
    187         phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    188         msg = async_send_4(phone, VFS_OUT_MOUNT,
     184        async_exch_t *mountee_exch = vfs_exchange_grab(fs_handle);
     185        assert(mountee_exch);
     186       
     187        exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
     188        msg = async_send_4(exch, VFS_OUT_MOUNT,
    189189            (sysarg_t) mp_res.triplet.devmap_handle,
    190190            (sysarg_t) mp_res.triplet.index,
    … …  
    192192            (sysarg_t) devmap_handle, &answer);
    193193       
    194         /* send connection */
    195         rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
    196         if (rc != EOK) {
     194        /* Send connection */
     195        rc = async_exchange_clone(exch, mountee_exch);
     196        vfs_exchange_release(mountee_exch);
     197       
     198        if (rc != EOK) {
     199                vfs_exchange_release(exch);
    197200                async_wait_for(msg, NULL);
    198                 vfs_release_phone(fs_handle, mountee_phone);
    199                 vfs_release_phone(mp_res.triplet.fs_handle, phone);
     201               
    200202                /* Mount failed, drop reference to mp_node. */
    201203                if (mp_node)
    202204                        vfs_node_put(mp_node);
    203                 async_answer_0(rid, rc);
    204                 fibril_rwlock_write_unlock(&namespace_rwlock);
    205                 return;
    206         }
    207 
    208         vfs_release_phone(fs_handle, mountee_phone);
     205               
     206                async_answer_0(rid, rc);
     207                fibril_rwlock_write_unlock(&namespace_rwlock);
     208                return;
     209        }
    209210       
    210211        /* send the mount options */
    211         rc = async_data_write_start(phone, (void *)opts, str_size(opts));
    212         if (rc != EOK) {
     212        rc = async_data_write_start(exch, (void *) opts, str_size(opts));
     213        if (rc != EOK) {
     214                vfs_exchange_release(exch);
    213215                async_wait_for(msg, NULL);
    214                 vfs_release_phone(mp_res.triplet.fs_handle, phone);
     216               
    215217                /* Mount failed, drop reference to mp_node. */
    216218                if (mp_node)
    217219                        vfs_node_put(mp_node);
    218                 fibril_rwlock_write_unlock(&namespace_rwlock);
    219                 async_answer_0(rid, rc);
    220                 return;
    221         }
     220               
     221                fibril_rwlock_write_unlock(&namespace_rwlock);
     222                async_answer_0(rid, rc);
     223                return;
     224        }
     225       
     226        vfs_exchange_release(exch);
    222227        async_wait_for(msg, &rc);
    223         vfs_release_phone(mp_res.triplet.fs_handle, phone);
    224228       
    225229        if (rc == EOK) {
    … …  
    227231                rsize = (size_t) IPC_GET_ARG2(answer);
    228232                rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
    229        
     233               
    230234                mr_res.triplet.fs_handle = fs_handle;
    231235                mr_res.triplet.devmap_handle = devmap_handle;
    … …  
    234238                mr_res.lnkcnt = rlnkcnt;
    235239                mr_res.type = VFS_NODE_DIRECTORY;
    236        
     240               
    237241                /* Add reference to the mounted root. */
    238242                mr_node = vfs_node_get(&mr_res);
    … …  
    243247                        vfs_node_put(mp_node);
    244248        }
    245 
     249       
    246250        async_answer_0(rid, rc);
    247251        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    303307       
    304308        /*
    305          * Wait for IPC_M_PING so that we can return an error if we don't know
     309         * Wait for VFS_IN_PING so that we can return an error if we don't know
    306310         * fs_name.
    307311         */
    308312        ipc_call_t data;
    309313        ipc_callid_t callid = async_get_call(&data);
    310         if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
     314        if (IPC_GET_IMETHOD(data) != VFS_IN_PING) {
    311315                async_answer_0(callid, ENOTSUP);
    312316                async_answer_0(rid, ENOTSUP);
    … …  
    358362        vfs_lookup_res_t mr_res;
    359363        vfs_node_t *mr_node;
    360         int phone;
    361 
     364        async_exch_t *exch;
     365       
    362366        /*
    363367         * Receive the mount point path.
    … …  
    367371        if (rc != EOK)
    368372                async_answer_0(rid, rc);
    369 
     373       
    370374        /*
    371375         * Taking the namespace lock will do two things for us. First, it will
    … …  
    395399                return;
    396400        }
    397 
     401       
    398402        /*
    399403         * Count the total number of references for the mounted file system. We
    … …  
    411415                return;
    412416        }
    413 
     417       
    414418        if (str_cmp(mp, "/") == 0) {
    415 
     419               
    416420                /*
    417421                 * Unmounting the root file system.
    … …  
    420424                 * VFS_OUT_UNMOUNTED directly to the mounted file system.
    421425                 */
    422 
     426               
    423427                free(mp);
    424                 phone = vfs_grab_phone(mr_node->fs_handle);
    425                 rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
     428               
     429                exch = vfs_exchange_grab(mr_node->fs_handle);
     430                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    426431                    mr_node->devmap_handle);
    427                 vfs_release_phone(mr_node->fs_handle, phone);
     432                vfs_exchange_release(exch);
     433               
    428434                if (rc != EOK) {
    429435                        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    432438                        return;
    433439                }
     440               
    434441                rootfs.fs_handle = 0;
    435442                rootfs.devmap_handle = 0;
    436443        } else {
    437 
     444               
    438445                /*
    439446                 * Unmounting a non-root file system.
    … …  
    442449                 * file system, so we delegate the operation to it.
    443450                 */
    444 
     451               
    445452                rc = vfs_lookup_internal(mp, L_MP, &mp_res, NULL);
    446453                free(mp);
    … …  
    451458                        return;
    452459                }
     460               
    453461                vfs_node_t *mp_node = vfs_node_get(&mp_res);
    454462                if (!mp_node) {
    … …  
    458466                        return;
    459467                }
    460 
    461                 phone = vfs_grab_phone(mp_node->fs_handle);
    462                 rc = async_req_2_0(phone, VFS_OUT_UNMOUNT,
     468               
     469                exch = vfs_exchange_grab(mp_node->fs_handle);
     470                rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
    463471                    mp_node->devmap_handle, mp_node->index);
    464                 vfs_release_phone(mp_node->fs_handle, phone);
     472                vfs_exchange_release(exch);
     473               
    465474                if (rc != EOK) {
    466475                        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    470479                        return;
    471480                }
    472 
     481               
    473482                /* Drop the reference we got above. */
    474483                vfs_node_put(mp_node);
    … …  
    476485                vfs_node_put(mp_node);
    477486        }
    478 
    479 
     487       
    480488        /*
    481489         * All went well, the mounted file system was successfully unmounted.
    … …  
    483491         */
    484492        vfs_node_forget(mr_node);
    485 
     493       
    486494        fibril_rwlock_write_unlock(&namespace_rwlock);
    487495        async_answer_0(rid, EOK);
    … …  
    698706         */
    699707        fibril_mutex_lock(&file->lock);
    700         int fs_phone = vfs_grab_phone(file->node->fs_handle);
     708        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
    701709       
    702710        /* Make a VFS_OUT_SYMC request at the destination FS server. */
    703711        aid_t msg;
    704712        ipc_call_t answer;
    705         msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
     713        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
    706714            file->node->index, &answer);
    707 
     715       
     716        vfs_exchange_release(fs_exch);
     717       
    708718        /* Wait for reply from the FS server. */
    709719        sysarg_t rc;
    710720        async_wait_for(msg, &rc);
    711721       
    712         vfs_release_phone(file->node->fs_handle, fs_phone);
    713722        fibril_mutex_unlock(&file->lock);
    714 
     723       
    715724        vfs_file_put(file);
    716725        async_answer_0(rid, rc);
    … …  
    720729{
    721730        int fd = IPC_GET_ARG1(*request);
    722         int ret;
    723        
    724         ret = vfs_fd_free(fd);
     731        int ret = vfs_fd_free(fd);
    725732        async_answer_0(rid, ret);
    726733}
    … …  
    728735static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
    729736{
    730         vfs_info_t *vi;
    731 
    732737        /*
    733738         * The following code strongly depends on the fact that the files data
    … …  
    739744         * open files supports parallel access!
    740745         */
    741 
     746       
    742747        int fd = IPC_GET_ARG1(*request);
    743748       
    … …  
    754759         */
    755760        fibril_mutex_lock(&file->lock);
    756 
    757         vi = fs_handle_to_info(file->node->fs_handle);
    758         assert(vi);
    759 
     761       
     762        vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle);
     763        assert(fs_info);
     764       
    760765        /*
    761766         * Lock the file's node so that no other client can read/write to it at
    … …  
    763768         * write implementation does not modify the file size.
    764769         */
    765         if (read || (vi->concurrent_read_write && vi->write_retains_size))
     770        if ((read) ||
     771            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
    766772                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    767773        else
    768774                fibril_rwlock_write_lock(&file->node->contents_rwlock);
    769 
     775       
    770776        if (file->node->type == VFS_NODE_DIRECTORY) {
    771777                /*
    … …  
    777783        }
    778784       
    779         int fs_phone = vfs_grab_phone(file->node->fs_handle);
     785        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
    780786       
    781787        /*
    … …  
    789795        ipc_call_t answer;
    790796        if (read) {
    791                 rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
     797                rc = async_data_read_forward_3_1(fs_exch, VFS_OUT_READ,
    792798                    file->node->devmap_handle, file->node->index, file->pos,
    793799                    &answer);
    … …  
    796802                        file->pos = file->node->size;
    797803               
    798                 rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
     804                rc = async_data_write_forward_3_1(fs_exch, VFS_OUT_WRITE,
    799805                    file->node->devmap_handle, file->node->index, file->pos,
    800806                    &answer);
    801807        }
    802808       
    803         vfs_release_phone(file->node->fs_handle, fs_phone);
     809        vfs_exchange_release(fs_exch);
    804810       
    805811        size_t bytes = IPC_GET_ARG1(answer);
    … …  
    809815       
    810816        /* Unlock the VFS node. */
    811         if (read || (vi->concurrent_read_write && vi->write_retains_size))
     817        if ((read) ||
     818            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
    812819                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    813820        else {
    … …  
    929936    fs_index_t index, aoff64_t size)
    930937{
    931         sysarg_t rc;
    932         int fs_phone;
    933        
    934         fs_phone = vfs_grab_phone(fs_handle);
    935         rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (sysarg_t) devmap_handle,
    936             (sysarg_t) index, LOWER32(size), UPPER32(size));
    937         vfs_release_phone(fs_handle, fs_phone);
    938         return (int)rc;
     938        async_exch_t *exch = vfs_exchange_grab(fs_handle);
     939        sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
     940            (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
     941            UPPER32(size));
     942        vfs_exchange_release(exch);
     943       
     944        return (int) rc;
    939945}
    940946
    … …  
    986992        fibril_mutex_lock(&file->lock);
    987993
    988         int fs_phone = vfs_grab_phone(file->node->fs_handle);
     994        async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
    989995       
    990996        aid_t msg;
    991         msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
     997        msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
    992998            file->node->index, true, NULL);
    993         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     999        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1000       
     1001        vfs_exchange_release(exch);
     1002       
    9941003        async_wait_for(msg, &rc);
    995         vfs_release_phone(file->node->fs_handle, fs_phone);
    996 
     1004       
    9971005        fibril_mutex_unlock(&file->lock);
    9981006        vfs_file_put(file);
    … …  
    10371045        fibril_rwlock_read_unlock(&namespace_rwlock);
    10381046
    1039         int fs_phone = vfs_grab_phone(node->fs_handle);
     1047        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
     1048       
    10401049        aid_t msg;
    1041         msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
     1050        msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
    10421051            node->index, false, NULL);
    1043         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1052        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1053       
     1054        vfs_exchange_release(exch);
    10441055       
    10451056        sysarg_t rv;
    10461057        async_wait_for(msg, &rv);
    1047         vfs_release_phone(node->fs_handle, fs_phone);
    10481058
    10491059        async_answer_0(rid, rv);
Note: See TracChangeset for help on using the changeset viewer.