Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r1882525 rccca251  
    3737
    3838#include "vfs.h"
    39 #include <ipc/ipc.h>
    4039#include <macros.h>
    4140#include <stdint.h>
    … …  
    5554
    5655/* Forward declarations of static functions. */
    57 static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, aoff64_t);
     56static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
     57    aoff64_t);
    5858
    5959/**
    … …  
    6565vfs_pair_t rootfs = {
    6666        .fs_handle = 0,
    67         .dev_handle = 0
     67        .devmap_handle = 0
    6868};
    6969
    70 static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
     70static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
    7171    fs_handle_t fs_handle, char *mp, char *opts)
    7272{
    … …  
    7878        size_t rsize;
    7979        unsigned rlnkcnt;
    80         ipcarg_t rc;
     80        sysarg_t rc;
    8181        int phone;
    8282        aid_t msg;
    … …  
    9090                        /* Trying to mount root FS over root FS */
    9191                        fibril_rwlock_write_unlock(&namespace_rwlock);
    92                         ipc_answer_0(rid, EBUSY);
     92                        async_answer_0(rid, EBUSY);
    9393                        return;
    9494                }
    … …  
    9898                        /* The lookup failed for some reason. */
    9999                        fibril_rwlock_write_unlock(&namespace_rwlock);
    100                         ipc_answer_0(rid, rc);
     100                        async_answer_0(rid, rc);
    101101                        return;
    102102                }
    … …  
    105105                if (!mp_node) {
    106106                        fibril_rwlock_write_unlock(&namespace_rwlock);
    107                         ipc_answer_0(rid, ENOMEM);
     107                        async_answer_0(rid, ENOMEM);
    108108                        return;
    109109                }
    … …  
    125125                        phone = vfs_grab_phone(fs_handle);
    126126                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
    127                             (ipcarg_t) dev_handle, &answer);
     127                            (sysarg_t) devmap_handle, &answer);
    128128                        /* send the mount options */
    129129                        rc = async_data_write_start(phone, (void *)opts,
    … …  
    131131                        if (rc != EOK) {
    132132                                async_wait_for(msg, NULL);
    133                                 vfs_release_phone(phone);
     133                                vfs_release_phone(fs_handle, phone);
    134134                                fibril_rwlock_write_unlock(&namespace_rwlock);
    135                                 ipc_answer_0(rid, rc);
     135                                async_answer_0(rid, rc);
    136136                                return;
    137137                        }
    138138                        async_wait_for(msg, &rc);
    139                         vfs_release_phone(phone);
     139                        vfs_release_phone(fs_handle, phone);
    140140                       
    141141                        if (rc != EOK) {
    142142                                fibril_rwlock_write_unlock(&namespace_rwlock);
    143                                 ipc_answer_0(rid, rc);
     143                                async_answer_0(rid, rc);
    144144                                return;
    145145                        }
    … …  
    150150                       
    151151                        mr_res.triplet.fs_handle = fs_handle;
    152                         mr_res.triplet.dev_handle = dev_handle;
     152                        mr_res.triplet.devmap_handle = devmap_handle;
    153153                        mr_res.triplet.index = rindex;
    154154                        mr_res.size = rsize;
    … …  
    157157                       
    158158                        rootfs.fs_handle = fs_handle;
    159                         rootfs.dev_handle = dev_handle;
     159                        rootfs.devmap_handle = devmap_handle;
    160160                       
    161161                        /* Add reference to the mounted root. */
    … …  
    164164                       
    165165                        fibril_rwlock_write_unlock(&namespace_rwlock);
    166                         ipc_answer_0(rid, rc);
     166                        async_answer_0(rid, rc);
    167167                        return;
    168168                } else {
    … …  
    172172                         */
    173173                        fibril_rwlock_write_unlock(&namespace_rwlock);
    174                         ipc_answer_0(rid, ENOENT);
     174                        async_answer_0(rid, ENOENT);
    175175                        return;
    176176                }
    … …  
    187187        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    188188        msg = async_send_4(phone, VFS_OUT_MOUNT,
    189             (ipcarg_t) mp_res.triplet.dev_handle,
    190             (ipcarg_t) mp_res.triplet.index,
    191             (ipcarg_t) fs_handle,
    192             (ipcarg_t) dev_handle, &answer);
     189            (sysarg_t) mp_res.triplet.devmap_handle,
     190            (sysarg_t) mp_res.triplet.index,
     191            (sysarg_t) fs_handle,
     192            (sysarg_t) devmap_handle, &answer);
    193193       
    194194        /* send connection */
    … …  
    196196        if (rc != EOK) {
    197197                async_wait_for(msg, NULL);
    198                 vfs_release_phone(mountee_phone);
    199                 vfs_release_phone(phone);
     198                vfs_release_phone(fs_handle, mountee_phone);
     199                vfs_release_phone(mp_res.triplet.fs_handle, phone);
    200200                /* Mount failed, drop reference to mp_node. */
    201201                if (mp_node)
    202202                        vfs_node_put(mp_node);
    203                 ipc_answer_0(rid, rc);
     203                async_answer_0(rid, rc);
    204204                fibril_rwlock_write_unlock(&namespace_rwlock);
    205205                return;
    206206        }
    207207
    208         vfs_release_phone(mountee_phone);
     208        vfs_release_phone(fs_handle, mountee_phone);
    209209       
    210210        /* send the mount options */
    … …  
    212212        if (rc != EOK) {
    213213                async_wait_for(msg, NULL);
    214                 vfs_release_phone(phone);
     214                vfs_release_phone(mp_res.triplet.fs_handle, phone);
    215215                /* Mount failed, drop reference to mp_node. */
    216216                if (mp_node)
    217217                        vfs_node_put(mp_node);
    218218                fibril_rwlock_write_unlock(&namespace_rwlock);
    219                 ipc_answer_0(rid, rc);
     219                async_answer_0(rid, rc);
    220220                return;
    221221        }
    222222        async_wait_for(msg, &rc);
    223         vfs_release_phone(phone);
     223        vfs_release_phone(mp_res.triplet.fs_handle, phone);
    224224       
    225225        if (rc == EOK) {
    … …  
    229229       
    230230                mr_res.triplet.fs_handle = fs_handle;
    231                 mr_res.triplet.dev_handle = dev_handle;
     231                mr_res.triplet.devmap_handle = devmap_handle;
    232232                mr_res.triplet.index = rindex;
    233233                mr_res.size = rsize;
    … …  
    244244        }
    245245
    246         ipc_answer_0(rid, rc);
     246        async_answer_0(rid, rc);
    247247        fibril_rwlock_write_unlock(&namespace_rwlock);
    248248}
    … …  
    250250void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
    251251{
     252        devmap_handle_t devmap_handle;
     253
    252254        /*
    253255         * We expect the library to do the device-name to device-handle
    … …  
    255257         * in the request.
    256258         */
    257         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     259        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    258260       
    259261        /*
    … …  
    272274            0, NULL);
    273275        if (rc != EOK) {
    274                 ipc_answer_0(rid, rc);
     276                async_answer_0(rid, rc);
    275277                return;
    276278        }
    … …  
    282284        if (rc != EOK) {
    283285                free(mp);
    284                 ipc_answer_0(rid, rc);
     286                async_answer_0(rid, rc);
    285287                return;
    286288        }
    … …  
    291293         */
    292294        char *fs_name;
    293         rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN,
    294             0, NULL);
     295        rc = async_data_write_accept((void **) &fs_name, true, 0,
     296            FS_NAME_MAXLEN, 0, NULL);
    295297        if (rc != EOK) {
    296298                free(mp);
    297299                free(opts);
    298                 ipc_answer_0(rid, rc);
     300                async_answer_0(rid, rc);
    299301                return;
    300302        }
    … …  
    306308        ipc_call_t data;
    307309        ipc_callid_t callid = async_get_call(&data);
    308         if (IPC_GET_METHOD(data) != IPC_M_PING) {
    309                 ipc_answer_0(callid, ENOTSUP);
    310                 ipc_answer_0(rid, ENOTSUP);
     310        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
     311                async_answer_0(callid, ENOTSUP);
     312                async_answer_0(rid, ENOTSUP);
    311313                free(mp);
    312314                free(opts);
    … …  
    330332               
    331333                fibril_mutex_unlock(&fs_head_lock);
    332                 ipc_answer_0(callid, ENOENT);
    333                 ipc_answer_0(rid, ENOENT);
     334                async_answer_0(callid, ENOENT);
     335                async_answer_0(rid, ENOENT);
    334336                free(mp);
    335337                free(fs_name);
    … …  
    340342       
    341343        /* Acknowledge that we know fs_name. */
    342         ipc_answer_0(callid, EOK);
     344        async_answer_0(callid, EOK);
    343345       
    344346        /* Do the mount */
    345         vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
     347        vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
    346348        free(mp);
    347349        free(fs_name);
    … …  
    364366            0, NULL);
    365367        if (rc != EOK)
    366                 ipc_answer_0(rid, rc);
     368                async_answer_0(rid, rc);
    367369
    368370        /*
    … …  
    383385                fibril_rwlock_write_unlock(&namespace_rwlock);
    384386                free(mp);
    385                 ipc_answer_0(rid, rc);
     387                async_answer_0(rid, rc);
    386388                return;
    387389        }
    … …  
    390392                fibril_rwlock_write_unlock(&namespace_rwlock);
    391393                free(mp);
    392                 ipc_answer_0(rid, ENOMEM);
     394                async_answer_0(rid, ENOMEM);
    393395                return;
    394396        }
    … …  
    402404         */
    403405        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    404             mr_node->dev_handle) != 2) {
     406            mr_node->devmap_handle) != 2) {
    405407                fibril_rwlock_write_unlock(&namespace_rwlock);
    406408                vfs_node_put(mr_node);
    407409                free(mp);
    408                 ipc_answer_0(rid, EBUSY);
     410                async_answer_0(rid, EBUSY);
    409411                return;
    410412        }
    … …  
    422424                phone = vfs_grab_phone(mr_node->fs_handle);
    423425                rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
    424                     mr_node->dev_handle);
    425                 vfs_release_phone(phone);
     426                    mr_node->devmap_handle);
     427                vfs_release_phone(mr_node->fs_handle, phone);
    426428                if (rc != EOK) {
    427429                        fibril_rwlock_write_unlock(&namespace_rwlock);
    428430                        vfs_node_put(mr_node);
    429                         ipc_answer_0(rid, rc);
     431                        async_answer_0(rid, rc);
    430432                        return;
    431433                }
    432434                rootfs.fs_handle = 0;
    433                 rootfs.dev_handle = 0;
     435                rootfs.devmap_handle = 0;
    434436        } else {
    435437
    … …  
    446448                        fibril_rwlock_write_unlock(&namespace_rwlock);
    447449                        vfs_node_put(mr_node);
    448                         ipc_answer_0(rid, rc);
     450                        async_answer_0(rid, rc);
    449451                        return;
    450452                }
    … …  
    453455                        fibril_rwlock_write_unlock(&namespace_rwlock);
    454456                        vfs_node_put(mr_node);
    455                         ipc_answer_0(rid, ENOMEM);
     457                        async_answer_0(rid, ENOMEM);
    456458                        return;
    457459                }
    458460
    459461                phone = vfs_grab_phone(mp_node->fs_handle);
    460                 rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle,
    461                     mp_node->index);
    462                 vfs_release_phone(phone);
     462                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT,
     463                    mp_node->devmap_handle, mp_node->index);
     464                vfs_release_phone(mp_node->fs_handle, phone);
    463465                if (rc != EOK) {
    464466                        fibril_rwlock_write_unlock(&namespace_rwlock);
    465467                        vfs_node_put(mp_node);
    466468                        vfs_node_put(mr_node);
    467                         ipc_answer_0(rid, rc);
     469                        async_answer_0(rid, rc);
    468470                        return;
    469471                }
    … …  
    483485
    484486        fibril_rwlock_write_unlock(&namespace_rwlock);
    485         ipc_answer_0(rid, EOK);
     487        async_answer_0(rid, EOK);
    486488}
    487489
    488490void vfs_open(ipc_callid_t rid, ipc_call_t *request)
    489491{
    490         if (!vfs_files_init()) {
    491                 ipc_answer_0(rid, ENOMEM);
    492                 return;
    493         }
    494        
    495492        /*
    496493         * The POSIX interface is open(path, oflag, mode).
    … …  
    516513            ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
    517514            (lflag & (L_OPEN | L_ROOT | L_MP))) {
    518                 ipc_answer_0(rid, EINVAL);
     515                async_answer_0(rid, EINVAL);
    519516                return;
    520517        }
    … …  
    528525        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    529526        if (rc != EOK) {
    530                 ipc_answer_0(rid, rc);
     527                async_answer_0(rid, rc);
    531528                return;
    532529        }
    … …  
    550547                else
    551548                        fibril_rwlock_read_unlock(&namespace_rwlock);
    552                 ipc_answer_0(rid, rc);
     549                async_answer_0(rid, rc);
    553550                free(path);
    554551                return;
    … …  
    569566                if (node->size) {
    570567                        rc = vfs_truncate_internal(node->fs_handle,
    571                             node->dev_handle, node->index, 0);
     568                            node->devmap_handle, node->index, 0);
    572569                        if (rc) {
    573570                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    574571                                vfs_node_put(node);
    575                                 ipc_answer_0(rid, rc);
     572                                async_answer_0(rid, rc);
    576573                                return;
    577574                        }
    … …  
    588585        if (fd < 0) {
    589586                vfs_node_put(node);
    590                 ipc_answer_0(rid, fd);
     587                async_answer_0(rid, fd);
    591588                return;
    592589        }
    … …  
    606603        vfs_node_addref(node);
    607604        vfs_node_put(node);
     605        vfs_file_put(file);
    608606       
    609607        /* Success! Return the new file descriptor to the client. */
    610         ipc_answer_1(rid, EOK, fd);
     608        async_answer_1(rid, EOK, fd);
    611609}
    612610
    … …  
    615613        // FIXME: check for sanity of the supplied fs, dev and index
    616614       
    617         if (!vfs_files_init()) {
    618                 ipc_answer_0(rid, ENOMEM);
    619                 return;
    620         }
    621        
    622615        /*
    623616         * The interface is open_node(fs, dev, index, oflag).
    … …  
    626619       
    627620        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
    628         lr.triplet.dev_handle = IPC_GET_ARG2(*request);
     621        lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
    629622        lr.triplet.index = IPC_GET_ARG3(*request);
    630623        int oflag = IPC_GET_ARG4(*request);
    … …  
    635628        if (rc != EOK) {
    636629                fibril_rwlock_read_unlock(&namespace_rwlock);
    637                 ipc_answer_0(rid, rc);
     630                async_answer_0(rid, rc);
    638631                return;
    639632        }
    … …  
    647640                if (node->size) {
    648641                        rc = vfs_truncate_internal(node->fs_handle,
    649                             node->dev_handle, node->index, 0);
     642                            node->devmap_handle, node->index, 0);
    650643                        if (rc) {
    651644                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    652645                                vfs_node_put(node);
    653                                 ipc_answer_0(rid, rc);
     646                                async_answer_0(rid, rc);
    654647                                return;
    655648                        }
    … …  
    666659        if (fd < 0) {
    667660                vfs_node_put(node);
    668                 ipc_answer_0(rid, fd);
     661                async_answer_0(rid, fd);
    669662                return;
    670663        }
    … …  
    683676        vfs_node_addref(node);
    684677        vfs_node_put(node);
     678        vfs_file_put(file);
    685679       
    686680        /* Success! Return the new file descriptor to the client. */
    687         ipc_answer_1(rid, EOK, fd);
     681        async_answer_1(rid, EOK, fd);
    688682}
    689683
    … …  
    695689        vfs_file_t *file = vfs_file_get(fd);
    696690        if (!file) {
    697                 ipc_answer_0(rid, ENOENT);
     691                async_answer_0(rid, ENOENT);
    698692                return;
    699693        }
    … …  
    709703        aid_t msg;
    710704        ipc_call_t answer;
    711         msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
     705        msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
    712706            file->node->index, &answer);
    713707
    714708        /* Wait for reply from the FS server. */
    715         ipcarg_t rc;
     709        sysarg_t rc;
    716710        async_wait_for(msg, &rc);
    717711       
    718         vfs_release_phone(fs_phone);
     712        vfs_release_phone(file->node->fs_handle, fs_phone);
    719713        fibril_mutex_unlock(&file->lock);
    720        
    721         ipc_answer_0(rid, rc);
     714
     715        vfs_file_put(file);
     716        async_answer_0(rid, rc);
    722717}
    723718
    … …  
    740735                aid_t msg;
    741736                ipc_call_t answer;
    742                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
    743                     file->node->index, &answer);
     737                msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
     738                    file->node->devmap_handle, file->node->index, &answer);
    744739               
    745740                /* Wait for reply from the FS server. */
    746                 ipcarg_t rc;
     741                sysarg_t rc;
    747742                async_wait_for(msg, &rc);
    748743               
    749                 vfs_release_phone(fs_phone);
     744                vfs_release_phone(file->node->fs_handle, fs_phone);
    750745                fibril_mutex_unlock(&file->lock);
    751746               
    … …  
    764759        vfs_file_t *file = vfs_file_get(fd);
    765760        if (!file) {
    766                 ipc_answer_0(rid, ENOENT);
     761                async_answer_0(rid, ENOENT);
    767762                return;
    768763        }
    … …  
    770765        int ret = vfs_close_internal(file);
    771766        if (ret != EOK)
    772                 ipc_answer_0(rid, ret);
    773        
     767                async_answer_0(rid, ret);
     768       
     769        vfs_file_put(file);
    774770        ret = vfs_fd_free(fd);
    775         ipc_answer_0(rid, ret);
     771        async_answer_0(rid, ret);
    776772}
    777773
    778774static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
    779775{
     776        vfs_info_t *vi;
    780777
    781778        /*
    … …  
    794791        vfs_file_t *file = vfs_file_get(fd);
    795792        if (!file) {
    796                 ipc_answer_0(rid, ENOENT);
     793                async_answer_0(rid, ENOENT);
    797794                return;
    798795        }
    … …  
    804801        fibril_mutex_lock(&file->lock);
    805802
     803        vi = fs_handle_to_info(file->node->fs_handle);
     804        assert(vi);
     805
    806806        /*
    807807         * Lock the file's node so that no other client can read/write to it at
    808          * the same time.
    809          */
    810         if (read)
     808         * the same time unless the FS supports concurrent reads/writes and its
     809         * write implementation does not modify the file size.
     810         */
     811        if (read || (vi->concurrent_read_write && vi->write_retains_size))
    811812                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    812813        else
    … …  
    831832         * don't have to bother.
    832833         */
    833         ipcarg_t rc;
     834        sysarg_t rc;
    834835        ipc_call_t answer;
    835836        if (read) {
     837                rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
     838                    file->node->devmap_handle, file->node->index, file->pos,
     839                    &answer);
     840        } else {
    836841                if (file->append)
    837842                        file->pos = file->node->size;
    838843               
    839                 rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
    840                     file->node->dev_handle, file->node->index, file->pos,
     844                rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
     845                    file->node->devmap_handle, file->node->index, file->pos,
    841846                    &answer);
    842         } else {
    843                 rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
    844                     file->node->dev_handle, file->node->index, file->pos,
    845                     &answer);
    846         }
    847        
    848         vfs_release_phone(fs_phone);
     847        }
     848       
     849        vfs_release_phone(file->node->fs_handle, fs_phone);
    849850       
    850851        size_t bytes = IPC_GET_ARG1(answer);
    … …  
    854855       
    855856        /* Unlock the VFS node. */
    856         if (read)
     857        if (read || (vi->concurrent_read_write && vi->write_retains_size))
    857858                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    858859        else {
    … …  
    867868                file->pos += bytes;
    868869        fibril_mutex_unlock(&file->lock);
    869        
     870        vfs_file_put(file);     
     871
    870872        /*
    871873         * FS server's reply is the final result of the whole operation we
    872874         * return to the client.
    873875         */
    874         ipc_answer_1(rid, rc, bytes);
     876        async_answer_1(rid, rc, bytes);
    875877}
    876878
    … …  
    888890{
    889891        int fd = (int) IPC_GET_ARG1(*request);
    890         off64_t off =
    891             (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
     892        off64_t off = (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
     893            IPC_GET_ARG3(*request));
    892894        int whence = (int) IPC_GET_ARG4(*request);
    893895       
    … …  
    895897        vfs_file_t *file = vfs_file_get(fd);
    896898        if (!file) {
    897                 ipc_answer_0(rid, ENOENT);
     899                async_answer_0(rid, ENOENT);
    898900                return;
    899901        }
    … …  
    903905        off64_t newoff;
    904906        switch (whence) {
    905                 case SEEK_SET:
    906                         if (off >= 0) {
    907                                 file->pos = (aoff64_t) off;
    908                                 fibril_mutex_unlock(&file->lock);
    909                                 ipc_answer_1(rid, EOK, off);
    910                                 return;
    911                         }
    912                         break;
    913                 case SEEK_CUR:
    914                         if ((off >= 0) && (file->pos + off < file->pos)) {
    915                                 fibril_mutex_unlock(&file->lock);
    916                                 ipc_answer_0(rid, EOVERFLOW);
    917                                 return;
    918                         }
    919                        
    920                         if ((off < 0) && (file->pos < (aoff64_t) -off)) {
    921                                 fibril_mutex_unlock(&file->lock);
    922                                 ipc_answer_0(rid, EOVERFLOW);
    923                                 return;
    924                         }
    925                        
    926                         file->pos += off;
    927                         newoff = (file->pos > OFF64_MAX) ? OFF64_MAX : file->pos;
    928                        
     907        case SEEK_SET:
     908                if (off >= 0) {
     909                        file->pos = (aoff64_t) off;
    929910                        fibril_mutex_unlock(&file->lock);
    930                         ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    931                         return;
    932                 case SEEK_END:
    933                         fibril_rwlock_read_lock(&file->node->contents_rwlock);
    934                         aoff64_t size = file->node->size;
    935                        
    936                         if ((off >= 0) && (size + off < size)) {
    937                                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    938                                 fibril_mutex_unlock(&file->lock);
    939                                 ipc_answer_0(rid, EOVERFLOW);
    940                                 return;
    941                         }
    942                        
    943                         if ((off < 0) && (size < (aoff64_t) -off)) {
    944                                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    945                                 fibril_mutex_unlock(&file->lock);
    946                                 ipc_answer_0(rid, EOVERFLOW);
    947                                 return;
    948                         }
    949                        
    950                         file->pos = size + off;
    951                         newoff = (file->pos > OFF64_MAX) ? OFF64_MAX : file->pos;
    952                        
     911                        vfs_file_put(file);
     912                        async_answer_1(rid, EOK, off);
     913                        return;
     914                }
     915                break;
     916        case SEEK_CUR:
     917                if ((off >= 0) && (file->pos + off < file->pos)) {
     918                        fibril_mutex_unlock(&file->lock);
     919                        vfs_file_put(file);
     920                        async_answer_0(rid, EOVERFLOW);
     921                        return;
     922                }
     923               
     924                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
     925                        fibril_mutex_unlock(&file->lock);
     926                        vfs_file_put(file);
     927                        async_answer_0(rid, EOVERFLOW);
     928                        return;
     929                }
     930               
     931                file->pos += off;
     932                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
     933               
     934                fibril_mutex_unlock(&file->lock);
     935                vfs_file_put(file);
     936                async_answer_2(rid, EOK, LOWER32(newoff),
     937                    UPPER32(newoff));
     938                return;
     939        case SEEK_END:
     940                fibril_rwlock_read_lock(&file->node->contents_rwlock);
     941                aoff64_t size = file->node->size;
     942               
     943                if ((off >= 0) && (size + off < size)) {
    953944                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    954945                        fibril_mutex_unlock(&file->lock);
    955                         ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    956                         return;
     946                        vfs_file_put(file);
     947                        async_answer_0(rid, EOVERFLOW);
     948                        return;
     949                }
     950               
     951                if ((off < 0) && (size < (aoff64_t) -off)) {
     952                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     953                        fibril_mutex_unlock(&file->lock);
     954                        vfs_file_put(file);
     955                        async_answer_0(rid, EOVERFLOW);
     956                        return;
     957                }
     958               
     959                file->pos = size + off;
     960                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
     961               
     962                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     963                fibril_mutex_unlock(&file->lock);
     964                vfs_file_put(file);
     965                async_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
     966                return;
    957967        }
    958968       
    959969        fibril_mutex_unlock(&file->lock);
    960         ipc_answer_0(rid, EINVAL);
    961 }
    962 
    963 int vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
     970        vfs_file_put(file);
     971        async_answer_0(rid, EINVAL);
     972}
     973
     974int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
    964975    fs_index_t index, aoff64_t size)
    965976{
    966         ipcarg_t rc;
     977        sysarg_t rc;
    967978        int fs_phone;
    968979       
    969980        fs_phone = vfs_grab_phone(fs_handle);
    970         rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) dev_handle,
    971             (ipcarg_t) index, LOWER32(size), UPPER32(size));
    972         vfs_release_phone(fs_phone);
     981        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (sysarg_t) devmap_handle,
     982            (sysarg_t) index, LOWER32(size), UPPER32(size));
     983        vfs_release_phone(fs_handle, fs_phone);
    973984        return (int)rc;
    974985}
    … …  
    977988{
    978989        int fd = IPC_GET_ARG1(*request);
    979         aoff64_t size =
    980             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
     990        aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
     991            IPC_GET_ARG3(*request));
    981992        int rc;
    982993
    983994        vfs_file_t *file = vfs_file_get(fd);
    984995        if (!file) {
    985                 ipc_answer_0(rid, ENOENT);
     996                async_answer_0(rid, ENOENT);
    986997                return;
    987998        }
    … …  
    9901001        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    9911002        rc = vfs_truncate_internal(file->node->fs_handle,
    992             file->node->dev_handle, file->node->index, size);
     1003            file->node->devmap_handle, file->node->index, size);
    9931004        if (rc == EOK)
    9941005                file->node->size = size;
    … …  
    9961007
    9971008        fibril_mutex_unlock(&file->lock);
    998         ipc_answer_0(rid, (ipcarg_t)rc);
     1009        vfs_file_put(file);
     1010        async_answer_0(rid, (sysarg_t)rc);
    9991011}
    10001012
    … …  
    10021014{
    10031015        int fd = IPC_GET_ARG1(*request);
    1004         ipcarg_t rc;
     1016        sysarg_t rc;
    10051017
    10061018        vfs_file_t *file = vfs_file_get(fd);
    10071019        if (!file) {
    1008                 ipc_answer_0(rid, ENOENT);
     1020                async_answer_0(rid, ENOENT);
    10091021                return;
    10101022        }
    … …  
    10121024        ipc_callid_t callid;
    10131025        if (!async_data_read_receive(&callid, NULL)) {
    1014                 ipc_answer_0(callid, EINVAL);
    1015                 ipc_answer_0(rid, EINVAL);
     1026                vfs_file_put(file);
     1027                async_answer_0(callid, EINVAL);
     1028                async_answer_0(rid, EINVAL);
    10161029                return;
    10171030        }
    … …  
    10221035       
    10231036        aid_t msg;
    1024         msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
     1037        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
    10251038            file->node->index, true, NULL);
    1026         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1039        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10271040        async_wait_for(msg, &rc);
    1028         vfs_release_phone(fs_phone);
     1041        vfs_release_phone(file->node->fs_handle, fs_phone);
    10291042
    10301043        fibril_mutex_unlock(&file->lock);
    1031         ipc_answer_0(rid, rc);
     1044        vfs_file_put(file);
     1045        async_answer_0(rid, rc);
    10321046}
    10331047
    … …  
    10371051        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10381052        if (rc != EOK) {
    1039                 ipc_answer_0(rid, rc);
     1053                async_answer_0(rid, rc);
    10401054                return;
    10411055        }
    … …  
    10441058        if (!async_data_read_receive(&callid, NULL)) {
    10451059                free(path);
    1046                 ipc_answer_0(callid, EINVAL);
    1047                 ipc_answer_0(rid, EINVAL);
     1060                async_answer_0(callid, EINVAL);
     1061                async_answer_0(rid, EINVAL);
    10481062                return;
    10491063        }
    … …  
    10551069        if (rc != EOK) {
    10561070                fibril_rwlock_read_unlock(&namespace_rwlock);
    1057                 ipc_answer_0(callid, rc);
    1058                 ipc_answer_0(rid, rc);
     1071                async_answer_0(callid, rc);
     1072                async_answer_0(rid, rc);
    10591073                return;
    10601074        }
    … …  
    10621076        if (!node) {
    10631077                fibril_rwlock_read_unlock(&namespace_rwlock);
    1064                 ipc_answer_0(callid, ENOMEM);
    1065                 ipc_answer_0(rid, ENOMEM);
     1078                async_answer_0(callid, ENOMEM);
     1079                async_answer_0(rid, ENOMEM);
    10661080                return;
    10671081        }
    … …  
    10711085        int fs_phone = vfs_grab_phone(node->fs_handle);
    10721086        aid_t msg;
    1073         msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
     1087        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
    10741088            node->index, false, NULL);
    1075         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    1076        
    1077         ipcarg_t rv;
     1089        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1090       
     1091        sysarg_t rv;
    10781092        async_wait_for(msg, &rv);
    1079         vfs_release_phone(fs_phone);
    1080 
    1081         ipc_answer_0(rid, rv);
     1093        vfs_release_phone(node->fs_handle, fs_phone);
     1094
     1095        async_answer_0(rid, rv);
    10821096
    10831097        vfs_node_put(node);
    … …  
    10911105        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10921106        if (rc != EOK) {
    1093                 ipc_answer_0(rid, rc);
     1107                async_answer_0(rid, rc);
    10941108                return;
    10951109        }
    … …  
    11031117        fibril_rwlock_write_unlock(&namespace_rwlock);
    11041118        free(path);
    1105         ipc_answer_0(rid, rc);
     1119        async_answer_0(rid, rc);
    11061120}
    11071121
    … …  
    11131127        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11141128        if (rc != EOK) {
    1115                 ipc_answer_0(rid, rc);
     1129                async_answer_0(rid, rc);
    11161130                return;
    11171131        }
    … …  
    11241138        if (rc != EOK) {
    11251139                fibril_rwlock_write_unlock(&namespace_rwlock);
    1126                 ipc_answer_0(rid, rc);
     1140                async_answer_0(rid, rc);
    11271141                return;
    11281142        }
    … …  
    11391153        fibril_rwlock_write_unlock(&namespace_rwlock);
    11401154        vfs_node_put(node);
    1141         ipc_answer_0(rid, EOK);
     1155        async_answer_0(rid, EOK);
    11421156}
    11431157
    … …  
    11481162        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    11491163        if (rc != EOK) {
    1150                 ipc_answer_0(rid, rc);
     1164                async_answer_0(rid, rc);
    11511165                return;
    11521166        }
    … …  
    11571171        if (rc != EOK) {
    11581172                free(old);
    1159                 ipc_answer_0(rid, rc);
     1173                async_answer_0(rid, rc);
    11601174                return;
    11611175        }
    … …  
    11671181       
    11681182        if ((!oldc) || (!newc)) {
    1169                 ipc_answer_0(rid, EINVAL);
     1183                async_answer_0(rid, EINVAL);
    11701184                free(old);
    11711185                free(new);
    … …  
    11861200                 * - oldc and newc are equal.
    11871201                 */
    1188                 ipc_answer_0(rid, EINVAL);
     1202                async_answer_0(rid, EINVAL);
    11891203                free(old);
    11901204                free(new);
    … …  
    12011215        if (rc != EOK) {
    12021216                fibril_rwlock_write_unlock(&namespace_rwlock);
    1203                 ipc_answer_0(rid, rc);
     1217                async_answer_0(rid, rc);
    12041218                free(old);
    12051219                free(new);
    … …  
    12101224        if (!old_node) {
    12111225                fibril_rwlock_write_unlock(&namespace_rwlock);
    1212                 ipc_answer_0(rid, ENOMEM);
     1226                async_answer_0(rid, ENOMEM);
    12131227                free(old);
    12141228                free(new);
    … …  
    12201234        if (!parentc) {
    12211235                fibril_rwlock_write_unlock(&namespace_rwlock);
    1222                 ipc_answer_0(rid, rc);
     1236                vfs_node_put(old_node);
     1237                async_answer_0(rid, rc);
    12231238                free(old);
    12241239                free(new);
    … …  
    12371252        if (rc != EOK) {
    12381253                fibril_rwlock_write_unlock(&namespace_rwlock);
    1239                 ipc_answer_0(rid, rc);
     1254                vfs_node_put(old_node);
     1255                async_answer_0(rid, rc);
    12401256                free(old);
    12411257                free(new);
    … …  
    12451261        /* Check whether linking to the same file system instance. */
    12461262        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1247             (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
     1263            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12481264                fibril_rwlock_write_unlock(&namespace_rwlock);
    1249                 ipc_answer_0(rid, EXDEV);       /* different file systems */
     1265                vfs_node_put(old_node);
     1266                async_answer_0(rid, EXDEV);     /* different file systems */
    12501267                free(old);
    12511268                free(new);
    … …  
    12651282                if (!new_node) {
    12661283                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1267                         ipc_answer_0(rid, ENOMEM);
     1284                        vfs_node_put(old_node);
     1285                        async_answer_0(rid, ENOMEM);
    12681286                        free(old);
    12691287                        free(new);
    … …  
    12761294        default:
    12771295                fibril_rwlock_write_unlock(&namespace_rwlock);
    1278                 ipc_answer_0(rid, ENOTEMPTY);
     1296                vfs_node_put(old_node);
     1297                async_answer_0(rid, ENOTEMPTY);
    12791298                free(old);
    12801299                free(new);
    … …  
    12841303        /* Create the new link for the new name. */
    12851304        rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
    1286         if (rc != EOK) {
    1287                 fibril_rwlock_write_unlock(&namespace_rwlock);
    1288                 if (new_node)
    1289                         vfs_node_put(new_node);
    1290                 ipc_answer_0(rid, rc);
    1291                 free(old);
    1292                 free(new);
    1293                 return;
    1294         }
    1295        
    1296         fibril_mutex_lock(&nodes_mutex);
    1297         old_node->lnkcnt++;
    1298         fibril_mutex_unlock(&nodes_mutex);
    1299        
    1300         /* Destroy the link for the old name. */
    1301         rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
    13021305        if (rc != EOK) {
    13031306                fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    13051308                if (new_node)
    13061309                        vfs_node_put(new_node);
    1307                 ipc_answer_0(rid, rc);
     1310                async_answer_0(rid, rc);
     1311                free(old);
     1312                free(new);
     1313                return;
     1314        }
     1315       
     1316        fibril_mutex_lock(&nodes_mutex);
     1317        old_node->lnkcnt++;
     1318        fibril_mutex_unlock(&nodes_mutex);
     1319       
     1320        /* Destroy the link for the old name. */
     1321        rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
     1322        if (rc != EOK) {
     1323                fibril_rwlock_write_unlock(&namespace_rwlock);
     1324                vfs_node_put(old_node);
     1325                if (new_node)
     1326                        vfs_node_put(new_node);
     1327                async_answer_0(rid, rc);
    13081328                free(old);
    13091329                free(new);
    … …  
    13221342        free(old);
    13231343        free(new);
    1324         ipc_answer_0(rid, EOK);
     1344        async_answer_0(rid, EOK);
    13251345}
    13261346
    … …  
    13291349        int oldfd = IPC_GET_ARG1(*request);
    13301350        int newfd = IPC_GET_ARG2(*request);
     1351       
     1352        /* If the file descriptors are the same, do nothing. */
     1353        if (oldfd == newfd) {
     1354                async_answer_1(rid, EOK, newfd);
     1355                return;
     1356        }
    13311357       
    13321358        /* Lookup the file structure corresponding to oldfd. */
    13331359        vfs_file_t *oldfile = vfs_file_get(oldfd);
    13341360        if (!oldfile) {
    1335                 ipc_answer_0(rid, EBADF);
    1336                 return;
    1337         }
    1338        
    1339         /* If the file descriptors are the same, do nothing. */
    1340         if (oldfd == newfd) {
    1341                 ipc_answer_1(rid, EOK, newfd);
     1361                async_answer_0(rid, EBADF);
    13421362                return;
    13431363        }
    … …  
    13561376                if (ret != EOK) {
    13571377                        fibril_mutex_unlock(&oldfile->lock);
    1358                         ipc_answer_0(rid, ret);
     1378                        vfs_file_put(oldfile);
     1379                        vfs_file_put(newfile);
     1380                        async_answer_0(rid, ret);
    13591381                        return;
    13601382                }
    … …  
    13631385                if (ret != EOK) {
    13641386                        fibril_mutex_unlock(&oldfile->lock);
    1365                         ipc_answer_0(rid, ret);
    1366                         return;
    1367                 }
     1387                        vfs_file_put(oldfile);
     1388                        vfs_file_put(newfile);
     1389                        async_answer_0(rid, ret);
     1390                        return;
     1391                }
     1392                vfs_file_put(newfile);
    13681393        }
    13691394       
    … …  
    13711396        int ret = vfs_fd_assign(oldfile, newfd);
    13721397        fibril_mutex_unlock(&oldfile->lock);
     1398        vfs_file_put(oldfile);
    13731399       
    13741400        if (ret != EOK)
    1375                 ipc_answer_0(rid, ret);
     1401                async_answer_0(rid, ret);
    13761402        else
    1377                 ipc_answer_1(rid, EOK, newfd);
     1403                async_answer_1(rid, EOK, newfd);
    13781404}
    13791405
Note: See TracChangeset for help on using the changeset viewer.