Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    rffa2c8ef r228e490  
    3737
    3838#include "vfs.h"
     39#include <ipc/ipc.h>
    3940#include <macros.h>
    4041#include <stdint.h>
    … …  
    9091                        /* Trying to mount root FS over root FS */
    9192                        fibril_rwlock_write_unlock(&namespace_rwlock);
    92                         async_answer_0(rid, EBUSY);
     93                        ipc_answer_0(rid, EBUSY);
    9394                        return;
    9495                }
    … …  
    9899                        /* The lookup failed for some reason. */
    99100                        fibril_rwlock_write_unlock(&namespace_rwlock);
    100                         async_answer_0(rid, rc);
     101                        ipc_answer_0(rid, rc);
    101102                        return;
    102103                }
    … …  
    105106                if (!mp_node) {
    106107                        fibril_rwlock_write_unlock(&namespace_rwlock);
    107                         async_answer_0(rid, ENOMEM);
     108                        ipc_answer_0(rid, ENOMEM);
    108109                        return;
    109110                }
    … …  
    133134                                vfs_release_phone(fs_handle, phone);
    134135                                fibril_rwlock_write_unlock(&namespace_rwlock);
    135                                 async_answer_0(rid, rc);
     136                                ipc_answer_0(rid, rc);
    136137                                return;
    137138                        }
    … …  
    141142                        if (rc != EOK) {
    142143                                fibril_rwlock_write_unlock(&namespace_rwlock);
    143                                 async_answer_0(rid, rc);
     144                                ipc_answer_0(rid, rc);
    144145                                return;
    145146                        }
    … …  
    164165                       
    165166                        fibril_rwlock_write_unlock(&namespace_rwlock);
    166                         async_answer_0(rid, rc);
     167                        ipc_answer_0(rid, rc);
    167168                        return;
    168169                } else {
    … …  
    172173                         */
    173174                        fibril_rwlock_write_unlock(&namespace_rwlock);
    174                         async_answer_0(rid, ENOENT);
     175                        ipc_answer_0(rid, ENOENT);
    175176                        return;
    176177                }
    … …  
    201202                if (mp_node)
    202203                        vfs_node_put(mp_node);
    203                 async_answer_0(rid, rc);
     204                ipc_answer_0(rid, rc);
    204205                fibril_rwlock_write_unlock(&namespace_rwlock);
    205206                return;
    … …  
    217218                        vfs_node_put(mp_node);
    218219                fibril_rwlock_write_unlock(&namespace_rwlock);
    219                 async_answer_0(rid, rc);
     220                ipc_answer_0(rid, rc);
    220221                return;
    221222        }
    … …  
    244245        }
    245246
    246         async_answer_0(rid, rc);
     247        ipc_answer_0(rid, rc);
    247248        fibril_rwlock_write_unlock(&namespace_rwlock);
    248249}
    … …  
    274275            0, NULL);
    275276        if (rc != EOK) {
    276                 async_answer_0(rid, rc);
     277                ipc_answer_0(rid, rc);
    277278                return;
    278279        }
    … …  
    284285        if (rc != EOK) {
    285286                free(mp);
    286                 async_answer_0(rid, rc);
     287                ipc_answer_0(rid, rc);
    287288                return;
    288289        }
    … …  
    298299                free(mp);
    299300                free(opts);
    300                 async_answer_0(rid, rc);
     301                ipc_answer_0(rid, rc);
    301302                return;
    302303        }
    … …  
    309310        ipc_callid_t callid = async_get_call(&data);
    310311        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
    311                 async_answer_0(callid, ENOTSUP);
    312                 async_answer_0(rid, ENOTSUP);
     312                ipc_answer_0(callid, ENOTSUP);
     313                ipc_answer_0(rid, ENOTSUP);
    313314                free(mp);
    314315                free(opts);
    … …  
    332333               
    333334                fibril_mutex_unlock(&fs_head_lock);
    334                 async_answer_0(callid, ENOENT);
    335                 async_answer_0(rid, ENOENT);
     335                ipc_answer_0(callid, ENOENT);
     336                ipc_answer_0(rid, ENOENT);
    336337                free(mp);
    337338                free(fs_name);
    … …  
    342343       
    343344        /* Acknowledge that we know fs_name. */
    344         async_answer_0(callid, EOK);
     345        ipc_answer_0(callid, EOK);
    345346       
    346347        /* Do the mount */
    … …  
    366367            0, NULL);
    367368        if (rc != EOK)
    368                 async_answer_0(rid, rc);
     369                ipc_answer_0(rid, rc);
    369370
    370371        /*
    … …  
    385386                fibril_rwlock_write_unlock(&namespace_rwlock);
    386387                free(mp);
    387                 async_answer_0(rid, rc);
     388                ipc_answer_0(rid, rc);
    388389                return;
    389390        }
    … …  
    392393                fibril_rwlock_write_unlock(&namespace_rwlock);
    393394                free(mp);
    394                 async_answer_0(rid, ENOMEM);
     395                ipc_answer_0(rid, ENOMEM);
    395396                return;
    396397        }
    … …  
    408409                vfs_node_put(mr_node);
    409410                free(mp);
    410                 async_answer_0(rid, EBUSY);
     411                ipc_answer_0(rid, EBUSY);
    411412                return;
    412413        }
    … …  
    429430                        fibril_rwlock_write_unlock(&namespace_rwlock);
    430431                        vfs_node_put(mr_node);
    431                         async_answer_0(rid, rc);
     432                        ipc_answer_0(rid, rc);
    432433                        return;
    433434                }
    … …  
    448449                        fibril_rwlock_write_unlock(&namespace_rwlock);
    449450                        vfs_node_put(mr_node);
    450                         async_answer_0(rid, rc);
     451                        ipc_answer_0(rid, rc);
    451452                        return;
    452453                }
    … …  
    455456                        fibril_rwlock_write_unlock(&namespace_rwlock);
    456457                        vfs_node_put(mr_node);
    457                         async_answer_0(rid, ENOMEM);
     458                        ipc_answer_0(rid, ENOMEM);
    458459                        return;
    459460                }
    … …  
    467468                        vfs_node_put(mp_node);
    468469                        vfs_node_put(mr_node);
    469                         async_answer_0(rid, rc);
     470                        ipc_answer_0(rid, rc);
    470471                        return;
    471472                }
    … …  
    485486
    486487        fibril_rwlock_write_unlock(&namespace_rwlock);
    487         async_answer_0(rid, EOK);
     488        ipc_answer_0(rid, EOK);
    488489}
    489490
    490491void vfs_open(ipc_callid_t rid, ipc_call_t *request)
    491492{
     493        if (!vfs_files_init()) {
     494                ipc_answer_0(rid, ENOMEM);
     495                return;
     496        }
     497       
    492498        /*
    493499         * The POSIX interface is open(path, oflag, mode).
    … …  
    513519            ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
    514520            (lflag & (L_OPEN | L_ROOT | L_MP))) {
    515                 async_answer_0(rid, EINVAL);
     521                ipc_answer_0(rid, EINVAL);
    516522                return;
    517523        }
    … …  
    525531        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    526532        if (rc != EOK) {
    527                 async_answer_0(rid, rc);
     533                ipc_answer_0(rid, rc);
    528534                return;
    529535        }
    … …  
    547553                else
    548554                        fibril_rwlock_read_unlock(&namespace_rwlock);
    549                 async_answer_0(rid, rc);
     555                ipc_answer_0(rid, rc);
    550556                free(path);
    551557                return;
    … …  
    570576                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    571577                                vfs_node_put(node);
    572                                 async_answer_0(rid, rc);
     578                                ipc_answer_0(rid, rc);
    573579                                return;
    574580                        }
    … …  
    585591        if (fd < 0) {
    586592                vfs_node_put(node);
    587                 async_answer_0(rid, fd);
     593                ipc_answer_0(rid, fd);
    588594                return;
    589595        }
    … …  
    603609        vfs_node_addref(node);
    604610        vfs_node_put(node);
    605         vfs_file_put(file);
    606611       
    607612        /* Success! Return the new file descriptor to the client. */
    608         async_answer_1(rid, EOK, fd);
     613        ipc_answer_1(rid, EOK, fd);
    609614}
    610615
    … …  
    612617{
    613618        // 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        }
    614624       
    615625        /*
    … …  
    628638        if (rc != EOK) {
    629639                fibril_rwlock_read_unlock(&namespace_rwlock);
    630                 async_answer_0(rid, rc);
     640                ipc_answer_0(rid, rc);
    631641                return;
    632642        }
    … …  
    644654                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    645655                                vfs_node_put(node);
    646                                 async_answer_0(rid, rc);
     656                                ipc_answer_0(rid, rc);
    647657                                return;
    648658                        }
    … …  
    659669        if (fd < 0) {
    660670                vfs_node_put(node);
    661                 async_answer_0(rid, fd);
     671                ipc_answer_0(rid, fd);
    662672                return;
    663673        }
    … …  
    676686        vfs_node_addref(node);
    677687        vfs_node_put(node);
    678         vfs_file_put(file);
    679688       
    680689        /* Success! Return the new file descriptor to the client. */
    681         async_answer_1(rid, EOK, fd);
     690        ipc_answer_1(rid, EOK, fd);
    682691}
    683692
    … …  
    689698        vfs_file_t *file = vfs_file_get(fd);
    690699        if (!file) {
    691                 async_answer_0(rid, ENOENT);
     700                ipc_answer_0(rid, ENOENT);
    692701                return;
    693702        }
    … …  
    712721        vfs_release_phone(file->node->fs_handle, fs_phone);
    713722        fibril_mutex_unlock(&file->lock);
    714 
    715         vfs_file_put(file);
    716         async_answer_0(rid, rc);
     723       
     724        ipc_answer_0(rid, rc);
    717725}
    718726
    … …  
    759767        vfs_file_t *file = vfs_file_get(fd);
    760768        if (!file) {
    761                 async_answer_0(rid, ENOENT);
     769                ipc_answer_0(rid, ENOENT);
    762770                return;
    763771        }
    … …  
    765773        int ret = vfs_close_internal(file);
    766774        if (ret != EOK)
    767                 async_answer_0(rid, ret);
    768        
    769         vfs_file_put(file);
     775                ipc_answer_0(rid, ret);
     776       
    770777        ret = vfs_fd_free(fd);
    771         async_answer_0(rid, ret);
     778        ipc_answer_0(rid, ret);
    772779}
    773780
    … …  
    791798        vfs_file_t *file = vfs_file_get(fd);
    792799        if (!file) {
    793                 async_answer_0(rid, ENOENT);
     800                ipc_answer_0(rid, ENOENT);
    794801                return;
    795802        }
    … …  
    868875                file->pos += bytes;
    869876        fibril_mutex_unlock(&file->lock);
    870         vfs_file_put(file);     
    871 
     877       
    872878        /*
    873879         * FS server's reply is the final result of the whole operation we
    874880         * return to the client.
    875881         */
    876         async_answer_1(rid, rc, bytes);
     882        ipc_answer_1(rid, rc, bytes);
    877883}
    878884
    … …  
    897903        vfs_file_t *file = vfs_file_get(fd);
    898904        if (!file) {
    899                 async_answer_0(rid, ENOENT);
     905                ipc_answer_0(rid, ENOENT);
    900906                return;
    901907        }
    … …  
    909915                        file->pos = (aoff64_t) off;
    910916                        fibril_mutex_unlock(&file->lock);
    911                         vfs_file_put(file);
    912                         async_answer_1(rid, EOK, off);
     917                        ipc_answer_1(rid, EOK, off);
    913918                        return;
    914919                }
    … …  
    917922                if ((off >= 0) && (file->pos + off < file->pos)) {
    918923                        fibril_mutex_unlock(&file->lock);
    919                         vfs_file_put(file);
    920                         async_answer_0(rid, EOVERFLOW);
     924                        ipc_answer_0(rid, EOVERFLOW);
    921925                        return;
    922926                }
    … …  
    924928                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
    925929                        fibril_mutex_unlock(&file->lock);
    926                         vfs_file_put(file);
    927                         async_answer_0(rid, EOVERFLOW);
     930                        ipc_answer_0(rid, EOVERFLOW);
    928931                        return;
    929932                }
    … …  
    933936               
    934937                fibril_mutex_unlock(&file->lock);
    935                 vfs_file_put(file);
    936                 async_answer_2(rid, EOK, LOWER32(newoff),
     938                ipc_answer_2(rid, EOK, LOWER32(newoff),
    937939                    UPPER32(newoff));
    938940                return;
    … …  
    944946                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    945947                        fibril_mutex_unlock(&file->lock);
    946                         vfs_file_put(file);
    947                         async_answer_0(rid, EOVERFLOW);
     948                        ipc_answer_0(rid, EOVERFLOW);
    948949                        return;
    949950                }
    … …  
    952953                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    953954                        fibril_mutex_unlock(&file->lock);
    954                         vfs_file_put(file);
    955                         async_answer_0(rid, EOVERFLOW);
     955                        ipc_answer_0(rid, EOVERFLOW);
    956956                        return;
    957957                }
    … …  
    962962                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    963963                fibril_mutex_unlock(&file->lock);
    964                 vfs_file_put(file);
    965                 async_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
     964                ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    966965                return;
    967966        }
    968967       
    969968        fibril_mutex_unlock(&file->lock);
    970         vfs_file_put(file);
    971         async_answer_0(rid, EINVAL);
     969        ipc_answer_0(rid, EINVAL);
    972970}
    973971
    … …  
    994992        vfs_file_t *file = vfs_file_get(fd);
    995993        if (!file) {
    996                 async_answer_0(rid, ENOENT);
     994                ipc_answer_0(rid, ENOENT);
    997995                return;
    998996        }
    … …  
    10071005
    10081006        fibril_mutex_unlock(&file->lock);
    1009         vfs_file_put(file);
    1010         async_answer_0(rid, (sysarg_t)rc);
     1007        ipc_answer_0(rid, (sysarg_t)rc);
    10111008}
    10121009
    … …  
    10181015        vfs_file_t *file = vfs_file_get(fd);
    10191016        if (!file) {
    1020                 async_answer_0(rid, ENOENT);
     1017                ipc_answer_0(rid, ENOENT);
    10211018                return;
    10221019        }
    … …  
    10241021        ipc_callid_t callid;
    10251022        if (!async_data_read_receive(&callid, NULL)) {
    1026                 vfs_file_put(file);
    1027                 async_answer_0(callid, EINVAL);
    1028                 async_answer_0(rid, EINVAL);
     1023                ipc_answer_0(callid, EINVAL);
     1024                ipc_answer_0(rid, EINVAL);
    10291025                return;
    10301026        }
    … …  
    10371033        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
    10381034            file->node->index, true, NULL);
    1039         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1035        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10401036        async_wait_for(msg, &rc);
    10411037        vfs_release_phone(file->node->fs_handle, fs_phone);
    10421038
    10431039        fibril_mutex_unlock(&file->lock);
    1044         vfs_file_put(file);
    1045         async_answer_0(rid, rc);
     1040        ipc_answer_0(rid, rc);
    10461041}
    10471042
    … …  
    10511046        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10521047        if (rc != EOK) {
    1053                 async_answer_0(rid, rc);
     1048                ipc_answer_0(rid, rc);
    10541049                return;
    10551050        }
    … …  
    10581053        if (!async_data_read_receive(&callid, NULL)) {
    10591054                free(path);
    1060                 async_answer_0(callid, EINVAL);
    1061                 async_answer_0(rid, EINVAL);
     1055                ipc_answer_0(callid, EINVAL);
     1056                ipc_answer_0(rid, EINVAL);
    10621057                return;
    10631058        }
    … …  
    10691064        if (rc != EOK) {
    10701065                fibril_rwlock_read_unlock(&namespace_rwlock);
    1071                 async_answer_0(callid, rc);
    1072                 async_answer_0(rid, rc);
     1066                ipc_answer_0(callid, rc);
     1067                ipc_answer_0(rid, rc);
    10731068                return;
    10741069        }
    … …  
    10761071        if (!node) {
    10771072                fibril_rwlock_read_unlock(&namespace_rwlock);
    1078                 async_answer_0(callid, ENOMEM);
    1079                 async_answer_0(rid, ENOMEM);
     1073                ipc_answer_0(callid, ENOMEM);
     1074                ipc_answer_0(rid, ENOMEM);
    10801075                return;
    10811076        }
    … …  
    10871082        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
    10881083            node->index, false, NULL);
    1089         async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1084        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10901085       
    10911086        sysarg_t rv;
    … …  
    10931088        vfs_release_phone(node->fs_handle, fs_phone);
    10941089
    1095         async_answer_0(rid, rv);
     1090        ipc_answer_0(rid, rv);
    10961091
    10971092        vfs_node_put(node);
    … …  
    11051100        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11061101        if (rc != EOK) {
    1107                 async_answer_0(rid, rc);
     1102                ipc_answer_0(rid, rc);
    11081103                return;
    11091104        }
    … …  
    11171112        fibril_rwlock_write_unlock(&namespace_rwlock);
    11181113        free(path);
    1119         async_answer_0(rid, rc);
     1114        ipc_answer_0(rid, rc);
    11201115}
    11211116
    … …  
    11271122        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11281123        if (rc != EOK) {
    1129                 async_answer_0(rid, rc);
     1124                ipc_answer_0(rid, rc);
    11301125                return;
    11311126        }
    … …  
    11381133        if (rc != EOK) {
    11391134                fibril_rwlock_write_unlock(&namespace_rwlock);
    1140                 async_answer_0(rid, rc);
     1135                ipc_answer_0(rid, rc);
    11411136                return;
    11421137        }
    … …  
    11531148        fibril_rwlock_write_unlock(&namespace_rwlock);
    11541149        vfs_node_put(node);
    1155         async_answer_0(rid, EOK);
     1150        ipc_answer_0(rid, EOK);
    11561151}
    11571152
    … …  
    11621157        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    11631158        if (rc != EOK) {
    1164                 async_answer_0(rid, rc);
     1159                ipc_answer_0(rid, rc);
    11651160                return;
    11661161        }
    … …  
    11711166        if (rc != EOK) {
    11721167                free(old);
    1173                 async_answer_0(rid, rc);
     1168                ipc_answer_0(rid, rc);
    11741169                return;
    11751170        }
    … …  
    11811176       
    11821177        if ((!oldc) || (!newc)) {
    1183                 async_answer_0(rid, EINVAL);
     1178                ipc_answer_0(rid, EINVAL);
    11841179                free(old);
    11851180                free(new);
    … …  
    12001195                 * - oldc and newc are equal.
    12011196                 */
    1202                 async_answer_0(rid, EINVAL);
     1197                ipc_answer_0(rid, EINVAL);
    12031198                free(old);
    12041199                free(new);
    … …  
    12151210        if (rc != EOK) {
    12161211                fibril_rwlock_write_unlock(&namespace_rwlock);
    1217                 async_answer_0(rid, rc);
     1212                ipc_answer_0(rid, rc);
    12181213                free(old);
    12191214                free(new);
    … …  
    12241219        if (!old_node) {
    12251220                fibril_rwlock_write_unlock(&namespace_rwlock);
    1226                 async_answer_0(rid, ENOMEM);
     1221                ipc_answer_0(rid, ENOMEM);
    12271222                free(old);
    12281223                free(new);
    … …  
    12341229        if (!parentc) {
    12351230                fibril_rwlock_write_unlock(&namespace_rwlock);
    1236                 async_answer_0(rid, rc);
     1231                ipc_answer_0(rid, rc);
    12371232                free(old);
    12381233                free(new);
    … …  
    12511246        if (rc != EOK) {
    12521247                fibril_rwlock_write_unlock(&namespace_rwlock);
    1253                 async_answer_0(rid, rc);
     1248                ipc_answer_0(rid, rc);
    12541249                free(old);
    12551250                free(new);
    … …  
    12611256            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12621257                fibril_rwlock_write_unlock(&namespace_rwlock);
    1263                 async_answer_0(rid, EXDEV);     /* different file systems */
     1258                ipc_answer_0(rid, EXDEV);       /* different file systems */
    12641259                free(old);
    12651260                free(new);
    … …  
    12791274                if (!new_node) {
    12801275                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1281                         async_answer_0(rid, ENOMEM);
     1276                        ipc_answer_0(rid, ENOMEM);
    12821277                        free(old);
    12831278                        free(new);
    … …  
    12901285        default:
    12911286                fibril_rwlock_write_unlock(&namespace_rwlock);
    1292                 async_answer_0(rid, ENOTEMPTY);
     1287                ipc_answer_0(rid, ENOTEMPTY);
    12931288                free(old);
    12941289                free(new);
    … …  
    13021297                if (new_node)
    13031298                        vfs_node_put(new_node);
    1304                 async_answer_0(rid, rc);
     1299                ipc_answer_0(rid, rc);
    13051300                free(old);
    13061301                free(new);
    … …  
    13191314                if (new_node)
    13201315                        vfs_node_put(new_node);
    1321                 async_answer_0(rid, rc);
     1316                ipc_answer_0(rid, rc);
    13221317                free(old);
    13231318                free(new);
    … …  
    13361331        free(old);
    13371332        free(new);
    1338         async_answer_0(rid, EOK);
     1333        ipc_answer_0(rid, EOK);
    13391334}
    13401335
    … …  
    13431338        int oldfd = IPC_GET_ARG1(*request);
    13441339        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         }
    13511340       
    13521341        /* Lookup the file structure corresponding to oldfd. */
    13531342        vfs_file_t *oldfile = vfs_file_get(oldfd);
    13541343        if (!oldfile) {
    1355                 async_answer_0(rid, EBADF);
     1344                ipc_answer_0(rid, EBADF);
     1345                return;
     1346        }
     1347       
     1348        /* If the file descriptors are the same, do nothing. */
     1349        if (oldfd == newfd) {
     1350                ipc_answer_1(rid, EOK, newfd);
    13561351                return;
    13571352        }
    … …  
    13701365                if (ret != EOK) {
    13711366                        fibril_mutex_unlock(&oldfile->lock);
    1372                         vfs_file_put(oldfile);
    1373                         vfs_file_put(newfile);
    1374                         async_answer_0(rid, ret);
     1367                        ipc_answer_0(rid, ret);
    13751368                        return;
    13761369                }
    … …  
    13791372                if (ret != EOK) {
    13801373                        fibril_mutex_unlock(&oldfile->lock);
    1381                         vfs_file_put(oldfile);
    1382                         vfs_file_put(newfile);
    1383                         async_answer_0(rid, ret);
    1384                         return;
    1385                 }
    1386                 vfs_file_put(newfile);
     1374                        ipc_answer_0(rid, ret);
     1375                        return;
     1376                }
    13871377        }
    13881378       
    … …  
    13901380        int ret = vfs_fd_assign(oldfile, newfd);
    13911381        fibril_mutex_unlock(&oldfile->lock);
    1392         vfs_file_put(oldfile);
    13931382       
    13941383        if (ret != EOK)
    1395                 async_answer_0(rid, ret);
     1384                ipc_answer_0(rid, ret);
    13961385        else
    1397                 async_answer_1(rid, EOK, newfd);
     1386                ipc_answer_1(rid, EOK, newfd);
    13981387}
    13991388
Note: See TracChangeset for help on using the changeset viewer.