Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    rccca251 r1882525  
    3737
    3838#include "vfs.h"
     39#include <ipc/ipc.h>
    3940#include <macros.h>
    4041#include <stdint.h>
    … …  
    5455
    5556/* Forward declarations of static functions. */
    56 static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
    57     aoff64_t);
     57static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, aoff64_t);
    5858
    5959/**
    … …  
    6565vfs_pair_t rootfs = {
    6666        .fs_handle = 0,
    67         .devmap_handle = 0
     67        .dev_handle = 0
    6868};
    6969
    70 static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
     70static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
    7171    fs_handle_t fs_handle, char *mp, char *opts)
    7272{
    … …  
    7878        size_t rsize;
    7979        unsigned rlnkcnt;
    80         sysarg_t rc;
     80        ipcarg_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                         async_answer_0(rid, EBUSY);
     92                        ipc_answer_0(rid, EBUSY);
    9393                        return;
    9494                }
    … …  
    9898                        /* The lookup failed for some reason. */
    9999                        fibril_rwlock_write_unlock(&namespace_rwlock);
    100                         async_answer_0(rid, rc);
     100                        ipc_answer_0(rid, rc);
    101101                        return;
    102102                }
    … …  
    105105                if (!mp_node) {
    106106                        fibril_rwlock_write_unlock(&namespace_rwlock);
    107                         async_answer_0(rid, ENOMEM);
     107                        ipc_answer_0(rid, ENOMEM);
    108108                        return;
    109109                }
    … …  
    125125                        phone = vfs_grab_phone(fs_handle);
    126126                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
    127                             (sysarg_t) devmap_handle, &answer);
     127                            (ipcarg_t) dev_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(fs_handle, phone);
     133                                vfs_release_phone(phone);
    134134                                fibril_rwlock_write_unlock(&namespace_rwlock);
    135                                 async_answer_0(rid, rc);
     135                                ipc_answer_0(rid, rc);
    136136                                return;
    137137                        }
    138138                        async_wait_for(msg, &rc);
    139                         vfs_release_phone(fs_handle, phone);
     139                        vfs_release_phone(phone);
    140140                       
    141141                        if (rc != EOK) {
    142142                                fibril_rwlock_write_unlock(&namespace_rwlock);
    143                                 async_answer_0(rid, rc);
     143                                ipc_answer_0(rid, rc);
    144144                                return;
    145145                        }
    … …  
    150150                       
    151151                        mr_res.triplet.fs_handle = fs_handle;
    152                         mr_res.triplet.devmap_handle = devmap_handle;
     152                        mr_res.triplet.dev_handle = dev_handle;
    153153                        mr_res.triplet.index = rindex;
    154154                        mr_res.size = rsize;
    … …  
    157157                       
    158158                        rootfs.fs_handle = fs_handle;
    159                         rootfs.devmap_handle = devmap_handle;
     159                        rootfs.dev_handle = dev_handle;
    160160                       
    161161                        /* Add reference to the mounted root. */
    … …  
    164164                       
    165165                        fibril_rwlock_write_unlock(&namespace_rwlock);
    166                         async_answer_0(rid, rc);
     166                        ipc_answer_0(rid, rc);
    167167                        return;
    168168                } else {
    … …  
    172172                         */
    173173                        fibril_rwlock_write_unlock(&namespace_rwlock);
    174                         async_answer_0(rid, ENOENT);
     174                        ipc_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             (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);
     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);
    193193       
    194194        /* send connection */
    … …  
    196196        if (rc != EOK) {
    197197                async_wait_for(msg, NULL);
    198                 vfs_release_phone(fs_handle, mountee_phone);
    199                 vfs_release_phone(mp_res.triplet.fs_handle, phone);
     198                vfs_release_phone(mountee_phone);
     199                vfs_release_phone(phone);
    200200                /* Mount failed, drop reference to mp_node. */
    201201                if (mp_node)
    202202                        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);
     203                ipc_answer_0(rid, rc);
     204                fibril_rwlock_write_unlock(&namespace_rwlock);
     205                return;
     206        }
     207
     208        vfs_release_phone(mountee_phone);
    209209       
    210210        /* send the mount options */
    … …  
    212212        if (rc != EOK) {
    213213                async_wait_for(msg, NULL);
    214                 vfs_release_phone(mp_res.triplet.fs_handle, phone);
     214                vfs_release_phone(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                 async_answer_0(rid, rc);
     219                ipc_answer_0(rid, rc);
    220220                return;
    221221        }
    222222        async_wait_for(msg, &rc);
    223         vfs_release_phone(mp_res.triplet.fs_handle, phone);
     223        vfs_release_phone(phone);
    224224       
    225225        if (rc == EOK) {
    … …  
    229229       
    230230                mr_res.triplet.fs_handle = fs_handle;
    231                 mr_res.triplet.devmap_handle = devmap_handle;
     231                mr_res.triplet.dev_handle = dev_handle;
    232232                mr_res.triplet.index = rindex;
    233233                mr_res.size = rsize;
    … …  
    244244        }
    245245
    246         async_answer_0(rid, rc);
     246        ipc_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 
    254252        /*
    255253         * We expect the library to do the device-name to device-handle
    … …  
    257255         * in the request.
    258256         */
    259         devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     257        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    260258       
    261259        /*
    … …  
    274272            0, NULL);
    275273        if (rc != EOK) {
    276                 async_answer_0(rid, rc);
     274                ipc_answer_0(rid, rc);
    277275                return;
    278276        }
    … …  
    284282        if (rc != EOK) {
    285283                free(mp);
    286                 async_answer_0(rid, rc);
     284                ipc_answer_0(rid, rc);
    287285                return;
    288286        }
    … …  
    293291         */
    294292        char *fs_name;
    295         rc = async_data_write_accept((void **) &fs_name, true, 0,
    296             FS_NAME_MAXLEN, 0, NULL);
     293        rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN,
     294            0, NULL);
    297295        if (rc != EOK) {
    298296                free(mp);
    299297                free(opts);
    300                 async_answer_0(rid, rc);
     298                ipc_answer_0(rid, rc);
    301299                return;
    302300        }
    … …  
    308306        ipc_call_t data;
    309307        ipc_callid_t callid = async_get_call(&data);
    310         if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
    311                 async_answer_0(callid, ENOTSUP);
    312                 async_answer_0(rid, ENOTSUP);
     308        if (IPC_GET_METHOD(data) != IPC_M_PING) {
     309                ipc_answer_0(callid, ENOTSUP);
     310                ipc_answer_0(rid, ENOTSUP);
    313311                free(mp);
    314312                free(opts);
    … …  
    332330               
    333331                fibril_mutex_unlock(&fs_head_lock);
    334                 async_answer_0(callid, ENOENT);
    335                 async_answer_0(rid, ENOENT);
     332                ipc_answer_0(callid, ENOENT);
     333                ipc_answer_0(rid, ENOENT);
    336334                free(mp);
    337335                free(fs_name);
    … …  
    342340       
    343341        /* Acknowledge that we know fs_name. */
    344         async_answer_0(callid, EOK);
     342        ipc_answer_0(callid, EOK);
    345343       
    346344        /* Do the mount */
    347         vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
     345        vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
    348346        free(mp);
    349347        free(fs_name);
    … …  
    366364            0, NULL);
    367365        if (rc != EOK)
    368                 async_answer_0(rid, rc);
     366                ipc_answer_0(rid, rc);
    369367
    370368        /*
    … …  
    385383                fibril_rwlock_write_unlock(&namespace_rwlock);
    386384                free(mp);
    387                 async_answer_0(rid, rc);
     385                ipc_answer_0(rid, rc);
    388386                return;
    389387        }
    … …  
    392390                fibril_rwlock_write_unlock(&namespace_rwlock);
    393391                free(mp);
    394                 async_answer_0(rid, ENOMEM);
     392                ipc_answer_0(rid, ENOMEM);
    395393                return;
    396394        }
    … …  
    404402         */
    405403        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    406             mr_node->devmap_handle) != 2) {
     404            mr_node->dev_handle) != 2) {
    407405                fibril_rwlock_write_unlock(&namespace_rwlock);
    408406                vfs_node_put(mr_node);
    409407                free(mp);
    410                 async_answer_0(rid, EBUSY);
     408                ipc_answer_0(rid, EBUSY);
    411409                return;
    412410        }
    … …  
    424422                phone = vfs_grab_phone(mr_node->fs_handle);
    425423                rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
    426                     mr_node->devmap_handle);
    427                 vfs_release_phone(mr_node->fs_handle, phone);
     424                    mr_node->dev_handle);
     425                vfs_release_phone(phone);
    428426                if (rc != EOK) {
    429427                        fibril_rwlock_write_unlock(&namespace_rwlock);
    430428                        vfs_node_put(mr_node);
    431                         async_answer_0(rid, rc);
     429                        ipc_answer_0(rid, rc);
    432430                        return;
    433431                }
    434432                rootfs.fs_handle = 0;
    435                 rootfs.devmap_handle = 0;
     433                rootfs.dev_handle = 0;
    436434        } else {
    437435
    … …  
    448446                        fibril_rwlock_write_unlock(&namespace_rwlock);
    449447                        vfs_node_put(mr_node);
    450                         async_answer_0(rid, rc);
     448                        ipc_answer_0(rid, rc);
    451449                        return;
    452450                }
    … …  
    455453                        fibril_rwlock_write_unlock(&namespace_rwlock);
    456454                        vfs_node_put(mr_node);
    457                         async_answer_0(rid, ENOMEM);
     455                        ipc_answer_0(rid, ENOMEM);
    458456                        return;
    459457                }
    460458
    461459                phone = vfs_grab_phone(mp_node->fs_handle);
    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);
     460                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle,
     461                    mp_node->index);
     462                vfs_release_phone(phone);
    465463                if (rc != EOK) {
    466464                        fibril_rwlock_write_unlock(&namespace_rwlock);
    467465                        vfs_node_put(mp_node);
    468466                        vfs_node_put(mr_node);
    469                         async_answer_0(rid, rc);
     467                        ipc_answer_0(rid, rc);
    470468                        return;
    471469                }
    … …  
    485483
    486484        fibril_rwlock_write_unlock(&namespace_rwlock);
    487         async_answer_0(rid, EOK);
     485        ipc_answer_0(rid, EOK);
    488486}
    489487
    490488void vfs_open(ipc_callid_t rid, ipc_call_t *request)
    491489{
     490        if (!vfs_files_init()) {
     491                ipc_answer_0(rid, ENOMEM);
     492                return;
     493        }
     494       
    492495        /*
    493496         * The POSIX interface is open(path, oflag, mode).
    … …  
    513516            ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
    514517            (lflag & (L_OPEN | L_ROOT | L_MP))) {
    515                 async_answer_0(rid, EINVAL);
     518                ipc_answer_0(rid, EINVAL);
    516519                return;
    517520        }
    … …  
    525528        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    526529        if (rc != EOK) {
    527                 async_answer_0(rid, rc);
     530                ipc_answer_0(rid, rc);
    528531                return;
    529532        }
    … …  
    547550                else
    548551                        fibril_rwlock_read_unlock(&namespace_rwlock);
    549                 async_answer_0(rid, rc);
     552                ipc_answer_0(rid, rc);
    550553                free(path);
    551554                return;
    … …  
    566569                if (node->size) {
    567570                        rc = vfs_truncate_internal(node->fs_handle,
    568                             node->devmap_handle, node->index, 0);
     571                            node->dev_handle, node->index, 0);
    569572                        if (rc) {
    570573                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    571574                                vfs_node_put(node);
    572                                 async_answer_0(rid, rc);
     575                                ipc_answer_0(rid, rc);
    573576                                return;
    574577                        }
    … …  
    585588        if (fd < 0) {
    586589                vfs_node_put(node);
    587                 async_answer_0(rid, fd);
     590                ipc_answer_0(rid, fd);
    588591                return;
    589592        }
    … …  
    603606        vfs_node_addref(node);
    604607        vfs_node_put(node);
    605         vfs_file_put(file);
    606608       
    607609        /* Success! Return the new file descriptor to the client. */
    608         async_answer_1(rid, EOK, fd);
     610        ipc_answer_1(rid, EOK, fd);
    609611}
    610612
    … …  
    613615        // FIXME: check for sanity of the supplied fs, dev and index
    614616       
     617        if (!vfs_files_init()) {
     618                ipc_answer_0(rid, ENOMEM);
     619                return;
     620        }
     621       
    615622        /*
    616623         * The interface is open_node(fs, dev, index, oflag).
    … …  
    619626       
    620627        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
    621         lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
     628        lr.triplet.dev_handle = IPC_GET_ARG2(*request);
    622629        lr.triplet.index = IPC_GET_ARG3(*request);
    623630        int oflag = IPC_GET_ARG4(*request);
    … …  
    628635        if (rc != EOK) {
    629636                fibril_rwlock_read_unlock(&namespace_rwlock);
    630                 async_answer_0(rid, rc);
     637                ipc_answer_0(rid, rc);
    631638                return;
    632639        }
    … …  
    640647                if (node->size) {
    641648                        rc = vfs_truncate_internal(node->fs_handle,
    642                             node->devmap_handle, node->index, 0);
     649                            node->dev_handle, node->index, 0);
    643650                        if (rc) {
    644651                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    645652                                vfs_node_put(node);
    646                                 async_answer_0(rid, rc);
     653                                ipc_answer_0(rid, rc);
    647654                                return;
    648655                        }
    … …  
    659666        if (fd < 0) {
    660667                vfs_node_put(node);
    661                 async_answer_0(rid, fd);
     668                ipc_answer_0(rid, fd);
    662669                return;
    663670        }
    … …  
    676683        vfs_node_addref(node);
    677684        vfs_node_put(node);
    678         vfs_file_put(file);
    679685       
    680686        /* Success! Return the new file descriptor to the client. */
    681         async_answer_1(rid, EOK, fd);
     687        ipc_answer_1(rid, EOK, fd);
    682688}
    683689
    … …  
    689695        vfs_file_t *file = vfs_file_get(fd);
    690696        if (!file) {
    691                 async_answer_0(rid, ENOENT);
     697                ipc_answer_0(rid, ENOENT);
    692698                return;
    693699        }
    … …  
    703709        aid_t msg;
    704710        ipc_call_t answer;
    705         msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
     711        msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
    706712            file->node->index, &answer);
    707713
    708714        /* Wait for reply from the FS server. */
    709         sysarg_t rc;
     715        ipcarg_t rc;
    710716        async_wait_for(msg, &rc);
    711717       
    712         vfs_release_phone(file->node->fs_handle, fs_phone);
     718        vfs_release_phone(fs_phone);
    713719        fibril_mutex_unlock(&file->lock);
    714 
    715         vfs_file_put(file);
    716         async_answer_0(rid, rc);
     720       
     721        ipc_answer_0(rid, rc);
    717722}
    718723
    … …  
    735740                aid_t msg;
    736741                ipc_call_t answer;
    737                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
    738                     file->node->devmap_handle, file->node->index, &answer);
     742                msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
     743                    file->node->index, &answer);
    739744               
    740745                /* Wait for reply from the FS server. */
    741                 sysarg_t rc;
     746                ipcarg_t rc;
    742747                async_wait_for(msg, &rc);
    743748               
    744                 vfs_release_phone(file->node->fs_handle, fs_phone);
     749                vfs_release_phone(fs_phone);
    745750                fibril_mutex_unlock(&file->lock);
    746751               
    … …  
    759764        vfs_file_t *file = vfs_file_get(fd);
    760765        if (!file) {
    761                 async_answer_0(rid, ENOENT);
     766                ipc_answer_0(rid, ENOENT);
    762767                return;
    763768        }
    … …  
    765770        int ret = vfs_close_internal(file);
    766771        if (ret != EOK)
    767                 async_answer_0(rid, ret);
    768        
    769         vfs_file_put(file);
     772                ipc_answer_0(rid, ret);
     773       
    770774        ret = vfs_fd_free(fd);
    771         async_answer_0(rid, ret);
     775        ipc_answer_0(rid, ret);
    772776}
    773777
    774778static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
    775779{
    776         vfs_info_t *vi;
    777780
    778781        /*
    … …  
    791794        vfs_file_t *file = vfs_file_get(fd);
    792795        if (!file) {
    793                 async_answer_0(rid, ENOENT);
     796                ipc_answer_0(rid, ENOENT);
    794797                return;
    795798        }
    … …  
    801804        fibril_mutex_lock(&file->lock);
    802805
    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 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))
     808         * the same time.
     809         */
     810        if (read)
    812811                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    813812        else
    … …  
    832831         * don't have to bother.
    833832         */
    834         sysarg_t rc;
     833        ipcarg_t rc;
    835834        ipc_call_t answer;
    836835        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 {
    841836                if (file->append)
    842837                        file->pos = file->node->size;
    843838               
     839                rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
     840                    file->node->dev_handle, file->node->index, file->pos,
     841                    &answer);
     842        } else {
    844843                rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
    845                     file->node->devmap_handle, file->node->index, file->pos,
     844                    file->node->dev_handle, file->node->index, file->pos,
    846845                    &answer);
    847846        }
    848847       
    849         vfs_release_phone(file->node->fs_handle, fs_phone);
     848        vfs_release_phone(fs_phone);
    850849       
    851850        size_t bytes = IPC_GET_ARG1(answer);
    … …  
    855854       
    856855        /* Unlock the VFS node. */
    857         if (read || (vi->concurrent_read_write && vi->write_retains_size))
     856        if (read)
    858857                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    859858        else {
    … …  
    868867                file->pos += bytes;
    869868        fibril_mutex_unlock(&file->lock);
    870         vfs_file_put(file);     
    871 
     869       
    872870        /*
    873871         * FS server's reply is the final result of the whole operation we
    874872         * return to the client.
    875873         */
    876         async_answer_1(rid, rc, bytes);
     874        ipc_answer_1(rid, rc, bytes);
    877875}
    878876
    … …  
    890888{
    891889        int fd = (int) IPC_GET_ARG1(*request);
    892         off64_t off = (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
    893             IPC_GET_ARG3(*request));
     890        off64_t off =
     891            (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
    894892        int whence = (int) IPC_GET_ARG4(*request);
    895893       
    … …  
    897895        vfs_file_t *file = vfs_file_get(fd);
    898896        if (!file) {
    899                 async_answer_0(rid, ENOENT);
     897                ipc_answer_0(rid, ENOENT);
    900898                return;
    901899        }
    … …  
    905903        off64_t newoff;
    906904        switch (whence) {
    907         case SEEK_SET:
    908                 if (off >= 0) {
    909                         file->pos = (aoff64_t) off;
     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                       
    910929                        fibril_mutex_unlock(&file->lock);
    911                         vfs_file_put(file);
    912                         async_answer_1(rid, EOK, off);
     930                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    913931                        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)) {
     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                       
    944953                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    945954                        fibril_mutex_unlock(&file->lock);
    946                         vfs_file_put(file);
    947                         async_answer_0(rid, EOVERFLOW);
     955                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    948956                        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;
    967957        }
    968958       
    969959        fibril_mutex_unlock(&file->lock);
    970         vfs_file_put(file);
    971         async_answer_0(rid, EINVAL);
    972 }
    973 
    974 int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     960        ipc_answer_0(rid, EINVAL);
     961}
     962
     963int vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
    975964    fs_index_t index, aoff64_t size)
    976965{
    977         sysarg_t rc;
     966        ipcarg_t rc;
    978967        int fs_phone;
    979968       
    980969        fs_phone = vfs_grab_phone(fs_handle);
    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);
     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);
    984973        return (int)rc;
    985974}
    … …  
    988977{
    989978        int fd = IPC_GET_ARG1(*request);
    990         aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
    991             IPC_GET_ARG3(*request));
     979        aoff64_t size =
     980            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
    992981        int rc;
    993982
    994983        vfs_file_t *file = vfs_file_get(fd);
    995984        if (!file) {
    996                 async_answer_0(rid, ENOENT);
     985                ipc_answer_0(rid, ENOENT);
    997986                return;
    998987        }
    … …  
    1001990        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    1002991        rc = vfs_truncate_internal(file->node->fs_handle,
    1003             file->node->devmap_handle, file->node->index, size);
     992            file->node->dev_handle, file->node->index, size);
    1004993        if (rc == EOK)
    1005994                file->node->size = size;
    … …  
    1007996
    1008997        fibril_mutex_unlock(&file->lock);
    1009         vfs_file_put(file);
    1010         async_answer_0(rid, (sysarg_t)rc);
     998        ipc_answer_0(rid, (ipcarg_t)rc);
    1011999}
    10121000
    … …  
    10141002{
    10151003        int fd = IPC_GET_ARG1(*request);
    1016         sysarg_t rc;
     1004        ipcarg_t rc;
    10171005
    10181006        vfs_file_t *file = vfs_file_get(fd);
    10191007        if (!file) {
    1020                 async_answer_0(rid, ENOENT);
     1008                ipc_answer_0(rid, ENOENT);
    10211009                return;
    10221010        }
    … …  
    10241012        ipc_callid_t callid;
    10251013        if (!async_data_read_receive(&callid, NULL)) {
    1026                 vfs_file_put(file);
    1027                 async_answer_0(callid, EINVAL);
    1028                 async_answer_0(rid, EINVAL);
     1014                ipc_answer_0(callid, EINVAL);
     1015                ipc_answer_0(rid, EINVAL);
    10291016                return;
    10301017        }
    … …  
    10351022       
    10361023        aid_t msg;
    1037         msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
     1024        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
    10381025            file->node->index, true, NULL);
    1039         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1026        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10401027        async_wait_for(msg, &rc);
    1041         vfs_release_phone(file->node->fs_handle, fs_phone);
     1028        vfs_release_phone(fs_phone);
    10421029
    10431030        fibril_mutex_unlock(&file->lock);
    1044         vfs_file_put(file);
    1045         async_answer_0(rid, rc);
     1031        ipc_answer_0(rid, rc);
    10461032}
    10471033
    … …  
    10511037        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10521038        if (rc != EOK) {
    1053                 async_answer_0(rid, rc);
     1039                ipc_answer_0(rid, rc);
    10541040                return;
    10551041        }
    … …  
    10581044        if (!async_data_read_receive(&callid, NULL)) {
    10591045                free(path);
    1060                 async_answer_0(callid, EINVAL);
    1061                 async_answer_0(rid, EINVAL);
     1046                ipc_answer_0(callid, EINVAL);
     1047                ipc_answer_0(rid, EINVAL);
    10621048                return;
    10631049        }
    … …  
    10691055        if (rc != EOK) {
    10701056                fibril_rwlock_read_unlock(&namespace_rwlock);
    1071                 async_answer_0(callid, rc);
    1072                 async_answer_0(rid, rc);
     1057                ipc_answer_0(callid, rc);
     1058                ipc_answer_0(rid, rc);
    10731059                return;
    10741060        }
    … …  
    10761062        if (!node) {
    10771063                fibril_rwlock_read_unlock(&namespace_rwlock);
    1078                 async_answer_0(callid, ENOMEM);
    1079                 async_answer_0(rid, ENOMEM);
     1064                ipc_answer_0(callid, ENOMEM);
     1065                ipc_answer_0(rid, ENOMEM);
    10801066                return;
    10811067        }
    … …  
    10851071        int fs_phone = vfs_grab_phone(node->fs_handle);
    10861072        aid_t msg;
    1087         msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
     1073        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
    10881074            node->index, false, NULL);
    1089         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    1090        
    1091         sysarg_t rv;
     1075        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1076       
     1077        ipcarg_t rv;
    10921078        async_wait_for(msg, &rv);
    1093         vfs_release_phone(node->fs_handle, fs_phone);
    1094 
    1095         async_answer_0(rid, rv);
     1079        vfs_release_phone(fs_phone);
     1080
     1081        ipc_answer_0(rid, rv);
    10961082
    10971083        vfs_node_put(node);
    … …  
    11051091        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11061092        if (rc != EOK) {
    1107                 async_answer_0(rid, rc);
     1093                ipc_answer_0(rid, rc);
    11081094                return;
    11091095        }
    … …  
    11171103        fibril_rwlock_write_unlock(&namespace_rwlock);
    11181104        free(path);
    1119         async_answer_0(rid, rc);
     1105        ipc_answer_0(rid, rc);
    11201106}
    11211107
    … …  
    11271113        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11281114        if (rc != EOK) {
    1129                 async_answer_0(rid, rc);
     1115                ipc_answer_0(rid, rc);
    11301116                return;
    11311117        }
    … …  
    11381124        if (rc != EOK) {
    11391125                fibril_rwlock_write_unlock(&namespace_rwlock);
    1140                 async_answer_0(rid, rc);
     1126                ipc_answer_0(rid, rc);
    11411127                return;
    11421128        }
    … …  
    11531139        fibril_rwlock_write_unlock(&namespace_rwlock);
    11541140        vfs_node_put(node);
    1155         async_answer_0(rid, EOK);
     1141        ipc_answer_0(rid, EOK);
    11561142}
    11571143
    … …  
    11621148        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    11631149        if (rc != EOK) {
    1164                 async_answer_0(rid, rc);
     1150                ipc_answer_0(rid, rc);
    11651151                return;
    11661152        }
    … …  
    11711157        if (rc != EOK) {
    11721158                free(old);
    1173                 async_answer_0(rid, rc);
     1159                ipc_answer_0(rid, rc);
    11741160                return;
    11751161        }
    … …  
    11811167       
    11821168        if ((!oldc) || (!newc)) {
    1183                 async_answer_0(rid, EINVAL);
     1169                ipc_answer_0(rid, EINVAL);
    11841170                free(old);
    11851171                free(new);
    … …  
    12001186                 * - oldc and newc are equal.
    12011187                 */
    1202                 async_answer_0(rid, EINVAL);
     1188                ipc_answer_0(rid, EINVAL);
    12031189                free(old);
    12041190                free(new);
    … …  
    12151201        if (rc != EOK) {
    12161202                fibril_rwlock_write_unlock(&namespace_rwlock);
    1217                 async_answer_0(rid, rc);
     1203                ipc_answer_0(rid, rc);
    12181204                free(old);
    12191205                free(new);
    … …  
    12241210        if (!old_node) {
    12251211                fibril_rwlock_write_unlock(&namespace_rwlock);
    1226                 async_answer_0(rid, ENOMEM);
     1212                ipc_answer_0(rid, ENOMEM);
    12271213                free(old);
    12281214                free(new);
    … …  
    12341220        if (!parentc) {
    12351221                fibril_rwlock_write_unlock(&namespace_rwlock);
    1236                 vfs_node_put(old_node);
    1237                 async_answer_0(rid, rc);
     1222                ipc_answer_0(rid, rc);
    12381223                free(old);
    12391224                free(new);
    … …  
    12521237        if (rc != EOK) {
    12531238                fibril_rwlock_write_unlock(&namespace_rwlock);
    1254                 vfs_node_put(old_node);
    1255                 async_answer_0(rid, rc);
     1239                ipc_answer_0(rid, rc);
    12561240                free(old);
    12571241                free(new);
    … …  
    12611245        /* Check whether linking to the same file system instance. */
    12621246        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1263             (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    1264                 fibril_rwlock_write_unlock(&namespace_rwlock);
    1265                 vfs_node_put(old_node);
    1266                 async_answer_0(rid, EXDEV);     /* different file systems */
     1247            (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
     1248                fibril_rwlock_write_unlock(&namespace_rwlock);
     1249                ipc_answer_0(rid, EXDEV);       /* different file systems */
    12671250                free(old);
    12681251                free(new);
    … …  
    12821265                if (!new_node) {
    12831266                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1284                         vfs_node_put(old_node);
    1285                         async_answer_0(rid, ENOMEM);
     1267                        ipc_answer_0(rid, ENOMEM);
    12861268                        free(old);
    12871269                        free(new);
    … …  
    12941276        default:
    12951277                fibril_rwlock_write_unlock(&namespace_rwlock);
    1296                 vfs_node_put(old_node);
    1297                 async_answer_0(rid, ENOTEMPTY);
     1278                ipc_answer_0(rid, ENOTEMPTY);
    12981279                free(old);
    12991280                free(new);
    … …  
    13031284        /* Create the new link for the new name. */
    13041285        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);
    13051302        if (rc != EOK) {
    13061303                fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    13081305                if (new_node)
    13091306                        vfs_node_put(new_node);
    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);
     1307                ipc_answer_0(rid, rc);
    13281308                free(old);
    13291309                free(new);
    … …  
    13421322        free(old);
    13431323        free(new);
    1344         async_answer_0(rid, EOK);
     1324        ipc_answer_0(rid, EOK);
    13451325}
    13461326
    … …  
    13491329        int oldfd = IPC_GET_ARG1(*request);
    13501330        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         }
    13571331       
    13581332        /* Lookup the file structure corresponding to oldfd. */
    13591333        vfs_file_t *oldfile = vfs_file_get(oldfd);
    13601334        if (!oldfile) {
    1361                 async_answer_0(rid, EBADF);
     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);
    13621342                return;
    13631343        }
    … …  
    13761356                if (ret != EOK) {
    13771357                        fibril_mutex_unlock(&oldfile->lock);
    1378                         vfs_file_put(oldfile);
    1379                         vfs_file_put(newfile);
    1380                         async_answer_0(rid, ret);
     1358                        ipc_answer_0(rid, ret);
    13811359                        return;
    13821360                }
    … …  
    13851363                if (ret != EOK) {
    13861364                        fibril_mutex_unlock(&oldfile->lock);
    1387                         vfs_file_put(oldfile);
    1388                         vfs_file_put(newfile);
    1389                         async_answer_0(rid, ret);
     1365                        ipc_answer_0(rid, ret);
    13901366                        return;
    13911367                }
    1392                 vfs_file_put(newfile);
    13931368        }
    13941369       
    … …  
    13961371        int ret = vfs_fd_assign(oldfile, newfd);
    13971372        fibril_mutex_unlock(&oldfile->lock);
    1398         vfs_file_put(oldfile);
    13991373       
    14001374        if (ret != EOK)
    1401                 async_answer_0(rid, ret);
     1375                ipc_answer_0(rid, ret);
    14021376        else
    1403                 async_answer_1(rid, EOK, newfd);
     1377                ipc_answer_1(rid, EOK, newfd);
    14041378}
    14051379
Note: See TracChangeset for help on using the changeset viewer.