Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r3a4b3ba rffa2c8ef  
    3737
    3838#include "vfs.h"
    39 #include <ipc/ipc.h>
    4039#include <macros.h>
    4140#include <stdint.h>
    … …  
    7978        size_t rsize;
    8079        unsigned rlnkcnt;
    81         ipcarg_t rc;
     80        sysarg_t rc;
    8281        int phone;
    8382        aid_t msg;
    … …  
    9190                        /* Trying to mount root FS over root FS */
    9291                        fibril_rwlock_write_unlock(&namespace_rwlock);
    93                         ipc_answer_0(rid, EBUSY);
     92                        async_answer_0(rid, EBUSY);
    9493                        return;
    9594                }
    … …  
    9998                        /* The lookup failed for some reason. */
    10099                        fibril_rwlock_write_unlock(&namespace_rwlock);
    101                         ipc_answer_0(rid, rc);
     100                        async_answer_0(rid, rc);
    102101                        return;
    103102                }
    … …  
    106105                if (!mp_node) {
    107106                        fibril_rwlock_write_unlock(&namespace_rwlock);
    108                         ipc_answer_0(rid, ENOMEM);
     107                        async_answer_0(rid, ENOMEM);
    109108                        return;
    110109                }
    … …  
    126125                        phone = vfs_grab_phone(fs_handle);
    127126                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
    128                             (ipcarg_t) devmap_handle, &answer);
     127                            (sysarg_t) devmap_handle, &answer);
    129128                        /* send the mount options */
    130129                        rc = async_data_write_start(phone, (void *)opts,
    … …  
    134133                                vfs_release_phone(fs_handle, phone);
    135134                                fibril_rwlock_write_unlock(&namespace_rwlock);
    136                                 ipc_answer_0(rid, rc);
     135                                async_answer_0(rid, rc);
    137136                                return;
    138137                        }
    … …  
    142141                        if (rc != EOK) {
    143142                                fibril_rwlock_write_unlock(&namespace_rwlock);
    144                                 ipc_answer_0(rid, rc);
     143                                async_answer_0(rid, rc);
    145144                                return;
    146145                        }
    … …  
    165164                       
    166165                        fibril_rwlock_write_unlock(&namespace_rwlock);
    167                         ipc_answer_0(rid, rc);
     166                        async_answer_0(rid, rc);
    168167                        return;
    169168                } else {
    … …  
    173172                         */
    174173                        fibril_rwlock_write_unlock(&namespace_rwlock);
    175                         ipc_answer_0(rid, ENOENT);
     174                        async_answer_0(rid, ENOENT);
    176175                        return;
    177176                }
    … …  
    188187        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    189188        msg = async_send_4(phone, VFS_OUT_MOUNT,
    190             (ipcarg_t) mp_res.triplet.devmap_handle,
    191             (ipcarg_t) mp_res.triplet.index,
    192             (ipcarg_t) fs_handle,
    193             (ipcarg_t) devmap_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);
    194193       
    195194        /* send connection */
    … …  
    202201                if (mp_node)
    203202                        vfs_node_put(mp_node);
    204                 ipc_answer_0(rid, rc);
     203                async_answer_0(rid, rc);
    205204                fibril_rwlock_write_unlock(&namespace_rwlock);
    206205                return;
    … …  
    218217                        vfs_node_put(mp_node);
    219218                fibril_rwlock_write_unlock(&namespace_rwlock);
    220                 ipc_answer_0(rid, rc);
     219                async_answer_0(rid, rc);
    221220                return;
    222221        }
    … …  
    245244        }
    246245
    247         ipc_answer_0(rid, rc);
     246        async_answer_0(rid, rc);
    248247        fibril_rwlock_write_unlock(&namespace_rwlock);
    249248}
    … …  
    275274            0, NULL);
    276275        if (rc != EOK) {
    277                 ipc_answer_0(rid, rc);
     276                async_answer_0(rid, rc);
    278277                return;
    279278        }
    … …  
    285284        if (rc != EOK) {
    286285                free(mp);
    287                 ipc_answer_0(rid, rc);
     286                async_answer_0(rid, rc);
    288287                return;
    289288        }
    … …  
    299298                free(mp);
    300299                free(opts);
    301                 ipc_answer_0(rid, rc);
     300                async_answer_0(rid, rc);
    302301                return;
    303302        }
    … …  
    309308        ipc_call_t data;
    310309        ipc_callid_t callid = async_get_call(&data);
    311         if (IPC_GET_METHOD(data) != IPC_M_PING) {
    312                 ipc_answer_0(callid, ENOTSUP);
    313                 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);
    314313                free(mp);
    315314                free(opts);
    … …  
    333332               
    334333                fibril_mutex_unlock(&fs_head_lock);
    335                 ipc_answer_0(callid, ENOENT);
    336                 ipc_answer_0(rid, ENOENT);
     334                async_answer_0(callid, ENOENT);
     335                async_answer_0(rid, ENOENT);
    337336                free(mp);
    338337                free(fs_name);
    … …  
    343342       
    344343        /* Acknowledge that we know fs_name. */
    345         ipc_answer_0(callid, EOK);
     344        async_answer_0(callid, EOK);
    346345       
    347346        /* Do the mount */
    … …  
    367366            0, NULL);
    368367        if (rc != EOK)
    369                 ipc_answer_0(rid, rc);
     368                async_answer_0(rid, rc);
    370369
    371370        /*
    … …  
    386385                fibril_rwlock_write_unlock(&namespace_rwlock);
    387386                free(mp);
    388                 ipc_answer_0(rid, rc);
     387                async_answer_0(rid, rc);
    389388                return;
    390389        }
    … …  
    393392                fibril_rwlock_write_unlock(&namespace_rwlock);
    394393                free(mp);
    395                 ipc_answer_0(rid, ENOMEM);
     394                async_answer_0(rid, ENOMEM);
    396395                return;
    397396        }
    … …  
    409408                vfs_node_put(mr_node);
    410409                free(mp);
    411                 ipc_answer_0(rid, EBUSY);
     410                async_answer_0(rid, EBUSY);
    412411                return;
    413412        }
    … …  
    430429                        fibril_rwlock_write_unlock(&namespace_rwlock);
    431430                        vfs_node_put(mr_node);
    432                         ipc_answer_0(rid, rc);
     431                        async_answer_0(rid, rc);
    433432                        return;
    434433                }
    … …  
    449448                        fibril_rwlock_write_unlock(&namespace_rwlock);
    450449                        vfs_node_put(mr_node);
    451                         ipc_answer_0(rid, rc);
     450                        async_answer_0(rid, rc);
    452451                        return;
    453452                }
    … …  
    456455                        fibril_rwlock_write_unlock(&namespace_rwlock);
    457456                        vfs_node_put(mr_node);
    458                         ipc_answer_0(rid, ENOMEM);
     457                        async_answer_0(rid, ENOMEM);
    459458                        return;
    460459                }
    … …  
    468467                        vfs_node_put(mp_node);
    469468                        vfs_node_put(mr_node);
    470                         ipc_answer_0(rid, rc);
     469                        async_answer_0(rid, rc);
    471470                        return;
    472471                }
    … …  
    486485
    487486        fibril_rwlock_write_unlock(&namespace_rwlock);
    488         ipc_answer_0(rid, EOK);
     487        async_answer_0(rid, EOK);
    489488}
    490489
    491490void vfs_open(ipc_callid_t rid, ipc_call_t *request)
    492491{
    493         if (!vfs_files_init()) {
    494                 ipc_answer_0(rid, ENOMEM);
    495                 return;
    496         }
    497        
    498492        /*
    499493         * The POSIX interface is open(path, oflag, mode).
    … …  
    519513            ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
    520514            (lflag & (L_OPEN | L_ROOT | L_MP))) {
    521                 ipc_answer_0(rid, EINVAL);
     515                async_answer_0(rid, EINVAL);
    522516                return;
    523517        }
    … …  
    531525        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    532526        if (rc != EOK) {
    533                 ipc_answer_0(rid, rc);
     527                async_answer_0(rid, rc);
    534528                return;
    535529        }
    … …  
    553547                else
    554548                        fibril_rwlock_read_unlock(&namespace_rwlock);
    555                 ipc_answer_0(rid, rc);
     549                async_answer_0(rid, rc);
    556550                free(path);
    557551                return;
    … …  
    576570                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    577571                                vfs_node_put(node);
    578                                 ipc_answer_0(rid, rc);
     572                                async_answer_0(rid, rc);
    579573                                return;
    580574                        }
    … …  
    591585        if (fd < 0) {
    592586                vfs_node_put(node);
    593                 ipc_answer_0(rid, fd);
     587                async_answer_0(rid, fd);
    594588                return;
    595589        }
    … …  
    609603        vfs_node_addref(node);
    610604        vfs_node_put(node);
     605        vfs_file_put(file);
    611606       
    612607        /* Success! Return the new file descriptor to the client. */
    613         ipc_answer_1(rid, EOK, fd);
     608        async_answer_1(rid, EOK, fd);
    614609}
    615610
    … …  
    617612{
    618613        // FIXME: check for sanity of the supplied fs, dev and index
    619        
    620         if (!vfs_files_init()) {
    621                 ipc_answer_0(rid, ENOMEM);
    622                 return;
    623         }
    624614       
    625615        /*
    … …  
    638628        if (rc != EOK) {
    639629                fibril_rwlock_read_unlock(&namespace_rwlock);
    640                 ipc_answer_0(rid, rc);
     630                async_answer_0(rid, rc);
    641631                return;
    642632        }
    … …  
    654644                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    655645                                vfs_node_put(node);
    656                                 ipc_answer_0(rid, rc);
     646                                async_answer_0(rid, rc);
    657647                                return;
    658648                        }
    … …  
    669659        if (fd < 0) {
    670660                vfs_node_put(node);
    671                 ipc_answer_0(rid, fd);
     661                async_answer_0(rid, fd);
    672662                return;
    673663        }
    … …  
    686676        vfs_node_addref(node);
    687677        vfs_node_put(node);
     678        vfs_file_put(file);
    688679       
    689680        /* Success! Return the new file descriptor to the client. */
    690         ipc_answer_1(rid, EOK, fd);
     681        async_answer_1(rid, EOK, fd);
    691682}
    692683
    … …  
    698689        vfs_file_t *file = vfs_file_get(fd);
    699690        if (!file) {
    700                 ipc_answer_0(rid, ENOENT);
     691                async_answer_0(rid, ENOENT);
    701692                return;
    702693        }
    … …  
    716707
    717708        /* Wait for reply from the FS server. */
    718         ipcarg_t rc;
     709        sysarg_t rc;
    719710        async_wait_for(msg, &rc);
    720711       
    721712        vfs_release_phone(file->node->fs_handle, fs_phone);
    722713        fibril_mutex_unlock(&file->lock);
    723        
    724         ipc_answer_0(rid, rc);
     714
     715        vfs_file_put(file);
     716        async_answer_0(rid, rc);
    725717}
    726718
    … …  
    747739               
    748740                /* Wait for reply from the FS server. */
    749                 ipcarg_t rc;
     741                sysarg_t rc;
    750742                async_wait_for(msg, &rc);
    751743               
    … …  
    767759        vfs_file_t *file = vfs_file_get(fd);
    768760        if (!file) {
    769                 ipc_answer_0(rid, ENOENT);
     761                async_answer_0(rid, ENOENT);
    770762                return;
    771763        }
    … …  
    773765        int ret = vfs_close_internal(file);
    774766        if (ret != EOK)
    775                 ipc_answer_0(rid, ret);
    776        
     767                async_answer_0(rid, ret);
     768       
     769        vfs_file_put(file);
    777770        ret = vfs_fd_free(fd);
    778         ipc_answer_0(rid, ret);
     771        async_answer_0(rid, ret);
    779772}
    780773
    781774static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
    782775{
     776        vfs_info_t *vi;
    783777
    784778        /*
    … …  
    797791        vfs_file_t *file = vfs_file_get(fd);
    798792        if (!file) {
    799                 ipc_answer_0(rid, ENOENT);
     793                async_answer_0(rid, ENOENT);
    800794                return;
    801795        }
    … …  
    807801        fibril_mutex_lock(&file->lock);
    808802
     803        vi = fs_handle_to_info(file->node->fs_handle);
     804        assert(vi);
     805
    809806        /*
    810807         * Lock the file's node so that no other client can read/write to it at
    811          * the same time.
    812          */
    813         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))
    814812                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    815813        else
    … …  
    834832         * don't have to bother.
    835833         */
    836         ipcarg_t rc;
     834        sysarg_t rc;
    837835        ipc_call_t answer;
    838836        if (read) {
    … …  
    857855       
    858856        /* Unlock the VFS node. */
    859         if (read)
     857        if (read || (vi->concurrent_read_write && vi->write_retains_size))
    860858                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    861859        else {
    … …  
    870868                file->pos += bytes;
    871869        fibril_mutex_unlock(&file->lock);
    872        
     870        vfs_file_put(file);     
     871
    873872        /*
    874873         * FS server's reply is the final result of the whole operation we
    875874         * return to the client.
    876875         */
    877         ipc_answer_1(rid, rc, bytes);
     876        async_answer_1(rid, rc, bytes);
    878877}
    879878
    … …  
    898897        vfs_file_t *file = vfs_file_get(fd);
    899898        if (!file) {
    900                 ipc_answer_0(rid, ENOENT);
     899                async_answer_0(rid, ENOENT);
    901900                return;
    902901        }
    … …  
    910909                        file->pos = (aoff64_t) off;
    911910                        fibril_mutex_unlock(&file->lock);
    912                         ipc_answer_1(rid, EOK, off);
     911                        vfs_file_put(file);
     912                        async_answer_1(rid, EOK, off);
    913913                        return;
    914914                }
    … …  
    917917                if ((off >= 0) && (file->pos + off < file->pos)) {
    918918                        fibril_mutex_unlock(&file->lock);
    919                         ipc_answer_0(rid, EOVERFLOW);
     919                        vfs_file_put(file);
     920                        async_answer_0(rid, EOVERFLOW);
    920921                        return;
    921922                }
    … …  
    923924                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
    924925                        fibril_mutex_unlock(&file->lock);
    925                         ipc_answer_0(rid, EOVERFLOW);
     926                        vfs_file_put(file);
     927                        async_answer_0(rid, EOVERFLOW);
    926928                        return;
    927929                }
    … …  
    931933               
    932934                fibril_mutex_unlock(&file->lock);
    933                 ipc_answer_2(rid, EOK, LOWER32(newoff),
     935                vfs_file_put(file);
     936                async_answer_2(rid, EOK, LOWER32(newoff),
    934937                    UPPER32(newoff));
    935938                return;
    … …  
    941944                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    942945                        fibril_mutex_unlock(&file->lock);
    943                         ipc_answer_0(rid, EOVERFLOW);
     946                        vfs_file_put(file);
     947                        async_answer_0(rid, EOVERFLOW);
    944948                        return;
    945949                }
    … …  
    948952                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    949953                        fibril_mutex_unlock(&file->lock);
    950                         ipc_answer_0(rid, EOVERFLOW);
     954                        vfs_file_put(file);
     955                        async_answer_0(rid, EOVERFLOW);
    951956                        return;
    952957                }
    … …  
    957962                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    958963                fibril_mutex_unlock(&file->lock);
    959                 ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
     964                vfs_file_put(file);
     965                async_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    960966                return;
    961967        }
    962968       
    963969        fibril_mutex_unlock(&file->lock);
    964         ipc_answer_0(rid, EINVAL);
     970        vfs_file_put(file);
     971        async_answer_0(rid, EINVAL);
    965972}
    966973
    … …  
    968975    fs_index_t index, aoff64_t size)
    969976{
    970         ipcarg_t rc;
     977        sysarg_t rc;
    971978        int fs_phone;
    972979       
    973980        fs_phone = vfs_grab_phone(fs_handle);
    974         rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle,
    975             (ipcarg_t) index, LOWER32(size), UPPER32(size));
     981        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (sysarg_t) devmap_handle,
     982            (sysarg_t) index, LOWER32(size), UPPER32(size));
    976983        vfs_release_phone(fs_handle, fs_phone);
    977984        return (int)rc;
    … …  
    987994        vfs_file_t *file = vfs_file_get(fd);
    988995        if (!file) {
    989                 ipc_answer_0(rid, ENOENT);
     996                async_answer_0(rid, ENOENT);
    990997                return;
    991998        }
    … …  
    10001007
    10011008        fibril_mutex_unlock(&file->lock);
    1002         ipc_answer_0(rid, (ipcarg_t)rc);
     1009        vfs_file_put(file);
     1010        async_answer_0(rid, (sysarg_t)rc);
    10031011}
    10041012
    … …  
    10061014{
    10071015        int fd = IPC_GET_ARG1(*request);
    1008         ipcarg_t rc;
     1016        sysarg_t rc;
    10091017
    10101018        vfs_file_t *file = vfs_file_get(fd);
    10111019        if (!file) {
    1012                 ipc_answer_0(rid, ENOENT);
     1020                async_answer_0(rid, ENOENT);
    10131021                return;
    10141022        }
    … …  
    10161024        ipc_callid_t callid;
    10171025        if (!async_data_read_receive(&callid, NULL)) {
    1018                 ipc_answer_0(callid, EINVAL);
    1019                 ipc_answer_0(rid, EINVAL);
     1026                vfs_file_put(file);
     1027                async_answer_0(callid, EINVAL);
     1028                async_answer_0(rid, EINVAL);
    10201029                return;
    10211030        }
    … …  
    10281037        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
    10291038            file->node->index, true, NULL);
    1030         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);
    10311040        async_wait_for(msg, &rc);
    10321041        vfs_release_phone(file->node->fs_handle, fs_phone);
    10331042
    10341043        fibril_mutex_unlock(&file->lock);
    1035         ipc_answer_0(rid, rc);
     1044        vfs_file_put(file);
     1045        async_answer_0(rid, rc);
    10361046}
    10371047
    … …  
    10411051        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10421052        if (rc != EOK) {
    1043                 ipc_answer_0(rid, rc);
     1053                async_answer_0(rid, rc);
    10441054                return;
    10451055        }
    … …  
    10481058        if (!async_data_read_receive(&callid, NULL)) {
    10491059                free(path);
    1050                 ipc_answer_0(callid, EINVAL);
    1051                 ipc_answer_0(rid, EINVAL);
     1060                async_answer_0(callid, EINVAL);
     1061                async_answer_0(rid, EINVAL);
    10521062                return;
    10531063        }
    … …  
    10591069        if (rc != EOK) {
    10601070                fibril_rwlock_read_unlock(&namespace_rwlock);
    1061                 ipc_answer_0(callid, rc);
    1062                 ipc_answer_0(rid, rc);
     1071                async_answer_0(callid, rc);
     1072                async_answer_0(rid, rc);
    10631073                return;
    10641074        }
    … …  
    10661076        if (!node) {
    10671077                fibril_rwlock_read_unlock(&namespace_rwlock);
    1068                 ipc_answer_0(callid, ENOMEM);
    1069                 ipc_answer_0(rid, ENOMEM);
     1078                async_answer_0(callid, ENOMEM);
     1079                async_answer_0(rid, ENOMEM);
    10701080                return;
    10711081        }
    … …  
    10771087        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
    10781088            node->index, false, NULL);
    1079         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    1080        
    1081         ipcarg_t rv;
     1089        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1090       
     1091        sysarg_t rv;
    10821092        async_wait_for(msg, &rv);
    10831093        vfs_release_phone(node->fs_handle, fs_phone);
    10841094
    1085         ipc_answer_0(rid, rv);
     1095        async_answer_0(rid, rv);
    10861096
    10871097        vfs_node_put(node);
    … …  
    10951105        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10961106        if (rc != EOK) {
    1097                 ipc_answer_0(rid, rc);
     1107                async_answer_0(rid, rc);
    10981108                return;
    10991109        }
    … …  
    11071117        fibril_rwlock_write_unlock(&namespace_rwlock);
    11081118        free(path);
    1109         ipc_answer_0(rid, rc);
     1119        async_answer_0(rid, rc);
    11101120}
    11111121
    … …  
    11171127        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11181128        if (rc != EOK) {
    1119                 ipc_answer_0(rid, rc);
     1129                async_answer_0(rid, rc);
    11201130                return;
    11211131        }
    … …  
    11281138        if (rc != EOK) {
    11291139                fibril_rwlock_write_unlock(&namespace_rwlock);
    1130                 ipc_answer_0(rid, rc);
     1140                async_answer_0(rid, rc);
    11311141                return;
    11321142        }
    … …  
    11431153        fibril_rwlock_write_unlock(&namespace_rwlock);
    11441154        vfs_node_put(node);
    1145         ipc_answer_0(rid, EOK);
     1155        async_answer_0(rid, EOK);
    11461156}
    11471157
    … …  
    11521162        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    11531163        if (rc != EOK) {
    1154                 ipc_answer_0(rid, rc);
     1164                async_answer_0(rid, rc);
    11551165                return;
    11561166        }
    … …  
    11611171        if (rc != EOK) {
    11621172                free(old);
    1163                 ipc_answer_0(rid, rc);
     1173                async_answer_0(rid, rc);
    11641174                return;
    11651175        }
    … …  
    11711181       
    11721182        if ((!oldc) || (!newc)) {
    1173                 ipc_answer_0(rid, EINVAL);
     1183                async_answer_0(rid, EINVAL);
    11741184                free(old);
    11751185                free(new);
    … …  
    11901200                 * - oldc and newc are equal.
    11911201                 */
    1192                 ipc_answer_0(rid, EINVAL);
     1202                async_answer_0(rid, EINVAL);
    11931203                free(old);
    11941204                free(new);
    … …  
    12051215        if (rc != EOK) {
    12061216                fibril_rwlock_write_unlock(&namespace_rwlock);
    1207                 ipc_answer_0(rid, rc);
     1217                async_answer_0(rid, rc);
    12081218                free(old);
    12091219                free(new);
    … …  
    12141224        if (!old_node) {
    12151225                fibril_rwlock_write_unlock(&namespace_rwlock);
    1216                 ipc_answer_0(rid, ENOMEM);
     1226                async_answer_0(rid, ENOMEM);
    12171227                free(old);
    12181228                free(new);
    … …  
    12241234        if (!parentc) {
    12251235                fibril_rwlock_write_unlock(&namespace_rwlock);
    1226                 ipc_answer_0(rid, rc);
     1236                async_answer_0(rid, rc);
    12271237                free(old);
    12281238                free(new);
    … …  
    12411251        if (rc != EOK) {
    12421252                fibril_rwlock_write_unlock(&namespace_rwlock);
    1243                 ipc_answer_0(rid, rc);
     1253                async_answer_0(rid, rc);
    12441254                free(old);
    12451255                free(new);
    … …  
    12511261            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12521262                fibril_rwlock_write_unlock(&namespace_rwlock);
    1253                 ipc_answer_0(rid, EXDEV);       /* different file systems */
     1263                async_answer_0(rid, EXDEV);     /* different file systems */
    12541264                free(old);
    12551265                free(new);
    … …  
    12691279                if (!new_node) {
    12701280                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1271                         ipc_answer_0(rid, ENOMEM);
     1281                        async_answer_0(rid, ENOMEM);
    12721282                        free(old);
    12731283                        free(new);
    … …  
    12801290        default:
    12811291                fibril_rwlock_write_unlock(&namespace_rwlock);
    1282                 ipc_answer_0(rid, ENOTEMPTY);
     1292                async_answer_0(rid, ENOTEMPTY);
    12831293                free(old);
    12841294                free(new);
    … …  
    12921302                if (new_node)
    12931303                        vfs_node_put(new_node);
    1294                 ipc_answer_0(rid, rc);
     1304                async_answer_0(rid, rc);
    12951305                free(old);
    12961306                free(new);
    … …  
    13091319                if (new_node)
    13101320                        vfs_node_put(new_node);
    1311                 ipc_answer_0(rid, rc);
     1321                async_answer_0(rid, rc);
    13121322                free(old);
    13131323                free(new);
    … …  
    13261336        free(old);
    13271337        free(new);
    1328         ipc_answer_0(rid, EOK);
     1338        async_answer_0(rid, EOK);
    13291339}
    13301340
    … …  
    13331343        int oldfd = IPC_GET_ARG1(*request);
    13341344        int newfd = IPC_GET_ARG2(*request);
     1345       
     1346        /* If the file descriptors are the same, do nothing. */
     1347        if (oldfd == newfd) {
     1348                async_answer_1(rid, EOK, newfd);
     1349                return;
     1350        }
    13351351       
    13361352        /* Lookup the file structure corresponding to oldfd. */
    13371353        vfs_file_t *oldfile = vfs_file_get(oldfd);
    13381354        if (!oldfile) {
    1339                 ipc_answer_0(rid, EBADF);
    1340                 return;
    1341         }
    1342        
    1343         /* If the file descriptors are the same, do nothing. */
    1344         if (oldfd == newfd) {
    1345                 ipc_answer_1(rid, EOK, newfd);
     1355                async_answer_0(rid, EBADF);
    13461356                return;
    13471357        }
    … …  
    13601370                if (ret != EOK) {
    13611371                        fibril_mutex_unlock(&oldfile->lock);
    1362                         ipc_answer_0(rid, ret);
     1372                        vfs_file_put(oldfile);
     1373                        vfs_file_put(newfile);
     1374                        async_answer_0(rid, ret);
    13631375                        return;
    13641376                }
    … …  
    13671379                if (ret != EOK) {
    13681380                        fibril_mutex_unlock(&oldfile->lock);
    1369                         ipc_answer_0(rid, ret);
    1370                         return;
    1371                 }
     1381                        vfs_file_put(oldfile);
     1382                        vfs_file_put(newfile);
     1383                        async_answer_0(rid, ret);
     1384                        return;
     1385                }
     1386                vfs_file_put(newfile);
    13721387        }
    13731388       
    … …  
    13751390        int ret = vfs_fd_assign(oldfile, newfd);
    13761391        fibril_mutex_unlock(&oldfile->lock);
     1392        vfs_file_put(oldfile);
    13771393       
    13781394        if (ret != EOK)
    1379                 ipc_answer_0(rid, ret);
     1395                async_answer_0(rid, ret);
    13801396        else
    1381                 ipc_answer_1(rid, EOK, newfd);
     1397                async_answer_1(rid, EOK, newfd);
    13821398}
    13831399
Note: See TracChangeset for help on using the changeset viewer.