Changeset 8b655705 in mainline for uspace/srv/vfs/vfs_ops.c


Ignore:
Timestamp:
2011-04-15T19:38:07Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9dd730d1
Parents:
6b9e85b (diff), b2fb47f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r6b9e85b r8b655705  
    3737
    3838#include "vfs.h"
    39 #include <ipc/ipc.h>
    4039#include <macros.h>
    4140#include <stdint.h>
    … …  
    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                }
    … …  
    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                }
    … …  
    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        }
    … …  
    310309        ipc_callid_t callid = async_get_call(&data);
    311310        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
    312                 ipc_answer_0(callid, ENOTSUP);
    313                 ipc_answer_0(rid, ENOTSUP);
     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        }
    … …  
    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
    … …  
    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
    … …  
    798791        vfs_file_t *file = vfs_file_get(fd);
    799792        if (!file) {
    800                 ipc_answer_0(rid, ENOENT);
     793                async_answer_0(rid, ENOENT);
    801794                return;
    802795        }
    … …  
    875868                file->pos += bytes;
    876869        fibril_mutex_unlock(&file->lock);
    877        
     870        vfs_file_put(file);     
     871
    878872        /*
    879873         * FS server's reply is the final result of the whole operation we
    880874         * return to the client.
    881875         */
    882         ipc_answer_1(rid, rc, bytes);
     876        async_answer_1(rid, rc, bytes);
    883877}
    884878
    … …  
    903897        vfs_file_t *file = vfs_file_get(fd);
    904898        if (!file) {
    905                 ipc_answer_0(rid, ENOENT);
     899                async_answer_0(rid, ENOENT);
    906900                return;
    907901        }
    … …  
    915909                        file->pos = (aoff64_t) off;
    916910                        fibril_mutex_unlock(&file->lock);
    917                         ipc_answer_1(rid, EOK, off);
     911                        vfs_file_put(file);
     912                        async_answer_1(rid, EOK, off);
    918913                        return;
    919914                }
    … …  
    922917                if ((off >= 0) && (file->pos + off < file->pos)) {
    923918                        fibril_mutex_unlock(&file->lock);
    924                         ipc_answer_0(rid, EOVERFLOW);
     919                        vfs_file_put(file);
     920                        async_answer_0(rid, EOVERFLOW);
    925921                        return;
    926922                }
    … …  
    928924                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
    929925                        fibril_mutex_unlock(&file->lock);
    930                         ipc_answer_0(rid, EOVERFLOW);
     926                        vfs_file_put(file);
     927                        async_answer_0(rid, EOVERFLOW);
    931928                        return;
    932929                }
    … …  
    936933               
    937934                fibril_mutex_unlock(&file->lock);
    938                 ipc_answer_2(rid, EOK, LOWER32(newoff),
     935                vfs_file_put(file);
     936                async_answer_2(rid, EOK, LOWER32(newoff),
    939937                    UPPER32(newoff));
    940938                return;
    … …  
    946944                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    947945                        fibril_mutex_unlock(&file->lock);
    948                         ipc_answer_0(rid, EOVERFLOW);
     946                        vfs_file_put(file);
     947                        async_answer_0(rid, EOVERFLOW);
    949948                        return;
    950949                }
    … …  
    953952                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    954953                        fibril_mutex_unlock(&file->lock);
    955                         ipc_answer_0(rid, EOVERFLOW);
     954                        vfs_file_put(file);
     955                        async_answer_0(rid, EOVERFLOW);
    956956                        return;
    957957                }
    … …  
    962962                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    963963                fibril_mutex_unlock(&file->lock);
    964                 ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
     964                vfs_file_put(file);
     965                async_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
    965966                return;
    966967        }
    967968       
    968969        fibril_mutex_unlock(&file->lock);
    969         ipc_answer_0(rid, EINVAL);
     970        vfs_file_put(file);
     971        async_answer_0(rid, EINVAL);
    970972}
    971973
    … …  
    992994        vfs_file_t *file = vfs_file_get(fd);
    993995        if (!file) {
    994                 ipc_answer_0(rid, ENOENT);
     996                async_answer_0(rid, ENOENT);
    995997                return;
    996998        }
    … …  
    10051007
    10061008        fibril_mutex_unlock(&file->lock);
    1007         ipc_answer_0(rid, (sysarg_t)rc);
     1009        vfs_file_put(file);
     1010        async_answer_0(rid, (sysarg_t)rc);
    10081011}
    10091012
    … …  
    10151018        vfs_file_t *file = vfs_file_get(fd);
    10161019        if (!file) {
    1017                 ipc_answer_0(rid, ENOENT);
     1020                async_answer_0(rid, ENOENT);
    10181021                return;
    10191022        }
    … …  
    10211024        ipc_callid_t callid;
    10221025        if (!async_data_read_receive(&callid, NULL)) {
    1023                 ipc_answer_0(callid, EINVAL);
    1024                 ipc_answer_0(rid, EINVAL);
     1026                vfs_file_put(file);
     1027                async_answer_0(callid, EINVAL);
     1028                async_answer_0(rid, EINVAL);
    10251029                return;
    10261030        }
    … …  
    10331037        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
    10341038            file->node->index, true, NULL);
    1035         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);
    10361040        async_wait_for(msg, &rc);
    10371041        vfs_release_phone(file->node->fs_handle, fs_phone);
    10381042
    10391043        fibril_mutex_unlock(&file->lock);
    1040         ipc_answer_0(rid, rc);
     1044        vfs_file_put(file);
     1045        async_answer_0(rid, rc);
    10411046}
    10421047
    … …  
    10461051        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    10471052        if (rc != EOK) {
    1048                 ipc_answer_0(rid, rc);
     1053                async_answer_0(rid, rc);
    10491054                return;
    10501055        }
    … …  
    10531058        if (!async_data_read_receive(&callid, NULL)) {
    10541059                free(path);
    1055                 ipc_answer_0(callid, EINVAL);
    1056                 ipc_answer_0(rid, EINVAL);
     1060                async_answer_0(callid, EINVAL);
     1061                async_answer_0(rid, EINVAL);
    10571062                return;
    10581063        }
    … …  
    10641069        if (rc != EOK) {
    10651070                fibril_rwlock_read_unlock(&namespace_rwlock);
    1066                 ipc_answer_0(callid, rc);
    1067                 ipc_answer_0(rid, rc);
     1071                async_answer_0(callid, rc);
     1072                async_answer_0(rid, rc);
    10681073                return;
    10691074        }
    … …  
    10711076        if (!node) {
    10721077                fibril_rwlock_read_unlock(&namespace_rwlock);
    1073                 ipc_answer_0(callid, ENOMEM);
    1074                 ipc_answer_0(rid, ENOMEM);
     1078                async_answer_0(callid, ENOMEM);
     1079                async_answer_0(rid, ENOMEM);
    10751080                return;
    10761081        }
    … …  
    10821087        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
    10831088            node->index, false, NULL);
    1084         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     1089        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10851090       
    10861091        sysarg_t rv;
    … …  
    10881093        vfs_release_phone(node->fs_handle, fs_phone);
    10891094
    1090         ipc_answer_0(rid, rv);
     1095        async_answer_0(rid, rv);
    10911096
    10921097        vfs_node_put(node);
    … …  
    11001105        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11011106        if (rc != EOK) {
    1102                 ipc_answer_0(rid, rc);
     1107                async_answer_0(rid, rc);
    11031108                return;
    11041109        }
    … …  
    11121117        fibril_rwlock_write_unlock(&namespace_rwlock);
    11131118        free(path);
    1114         ipc_answer_0(rid, rc);
     1119        async_answer_0(rid, rc);
    11151120}
    11161121
    … …  
    11221127        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    11231128        if (rc != EOK) {
    1124                 ipc_answer_0(rid, rc);
     1129                async_answer_0(rid, rc);
    11251130                return;
    11261131        }
    … …  
    11331138        if (rc != EOK) {
    11341139                fibril_rwlock_write_unlock(&namespace_rwlock);
    1135                 ipc_answer_0(rid, rc);
     1140                async_answer_0(rid, rc);
    11361141                return;
    11371142        }
    … …  
    11481153        fibril_rwlock_write_unlock(&namespace_rwlock);
    11491154        vfs_node_put(node);
    1150         ipc_answer_0(rid, EOK);
     1155        async_answer_0(rid, EOK);
    11511156}
    11521157
    … …  
    11571162        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    11581163        if (rc != EOK) {
    1159                 ipc_answer_0(rid, rc);
     1164                async_answer_0(rid, rc);
    11601165                return;
    11611166        }
    … …  
    11661171        if (rc != EOK) {
    11671172                free(old);
    1168                 ipc_answer_0(rid, rc);
     1173                async_answer_0(rid, rc);
    11691174                return;
    11701175        }
    … …  
    11761181       
    11771182        if ((!oldc) || (!newc)) {
    1178                 ipc_answer_0(rid, EINVAL);
     1183                async_answer_0(rid, EINVAL);
    11791184                free(old);
    11801185                free(new);
    … …  
    11951200                 * - oldc and newc are equal.
    11961201                 */
    1197                 ipc_answer_0(rid, EINVAL);
     1202                async_answer_0(rid, EINVAL);
    11981203                free(old);
    11991204                free(new);
    … …  
    12101215        if (rc != EOK) {
    12111216                fibril_rwlock_write_unlock(&namespace_rwlock);
    1212                 ipc_answer_0(rid, rc);
     1217                async_answer_0(rid, rc);
    12131218                free(old);
    12141219                free(new);
    … …  
    12191224        if (!old_node) {
    12201225                fibril_rwlock_write_unlock(&namespace_rwlock);
    1221                 ipc_answer_0(rid, ENOMEM);
     1226                async_answer_0(rid, ENOMEM);
    12221227                free(old);
    12231228                free(new);
    … …  
    12291234        if (!parentc) {
    12301235                fibril_rwlock_write_unlock(&namespace_rwlock);
    1231                 ipc_answer_0(rid, rc);
     1236                vfs_node_put(old_node);
     1237                async_answer_0(rid, rc);
    12321238                free(old);
    12331239                free(new);
    … …  
    12461252        if (rc != EOK) {
    12471253                fibril_rwlock_write_unlock(&namespace_rwlock);
    1248                 ipc_answer_0(rid, rc);
     1254                vfs_node_put(old_node);
     1255                async_answer_0(rid, rc);
    12491256                free(old);
    12501257                free(new);
    … …  
    12561263            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12571264                fibril_rwlock_write_unlock(&namespace_rwlock);
    1258                 ipc_answer_0(rid, EXDEV);       /* different file systems */
     1265                vfs_node_put(old_node);
     1266                async_answer_0(rid, EXDEV);     /* different file systems */
    12591267                free(old);
    12601268                free(new);
    … …  
    12741282                if (!new_node) {
    12751283                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1276                         ipc_answer_0(rid, ENOMEM);
     1284                        vfs_node_put(old_node);
     1285                        async_answer_0(rid, ENOMEM);
    12771286                        free(old);
    12781287                        free(new);
    … …  
    12851294        default:
    12861295                fibril_rwlock_write_unlock(&namespace_rwlock);
    1287                 ipc_answer_0(rid, ENOTEMPTY);
     1296                vfs_node_put(old_node);
     1297                async_answer_0(rid, ENOTEMPTY);
    12881298                free(old);
    12891299                free(new);
    … …  
    12931303        /* Create the new link for the new name. */
    12941304        rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
    1295         if (rc != EOK) {
    1296                 fibril_rwlock_write_unlock(&namespace_rwlock);
    1297                 if (new_node)
    1298                         vfs_node_put(new_node);
    1299                 ipc_answer_0(rid, rc);
    1300                 free(old);
    1301                 free(new);
    1302                 return;
    1303         }
    1304        
    1305         fibril_mutex_lock(&nodes_mutex);
    1306         old_node->lnkcnt++;
    1307         fibril_mutex_unlock(&nodes_mutex);
    1308        
    1309         /* Destroy the link for the old name. */
    1310         rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
    13111305        if (rc != EOK) {
    13121306                fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    13141308                if (new_node)
    13151309                        vfs_node_put(new_node);
    1316                 ipc_answer_0(rid, rc);
     1310                async_answer_0(rid, rc);
     1311                free(old);
     1312                free(new);
     1313                return;
     1314        }
     1315       
     1316        fibril_mutex_lock(&nodes_mutex);
     1317        old_node->lnkcnt++;
     1318        fibril_mutex_unlock(&nodes_mutex);
     1319       
     1320        /* Destroy the link for the old name. */
     1321        rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
     1322        if (rc != EOK) {
     1323                fibril_rwlock_write_unlock(&namespace_rwlock);
     1324                vfs_node_put(old_node);
     1325                if (new_node)
     1326                        vfs_node_put(new_node);
     1327                async_answer_0(rid, rc);
    13171328                free(old);
    13181329                free(new);
    … …  
    13311342        free(old);
    13321343        free(new);
    1333         ipc_answer_0(rid, EOK);
     1344        async_answer_0(rid, EOK);
    13341345}
    13351346
    … …  
    13381349        int oldfd = IPC_GET_ARG1(*request);
    13391350        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        }
    13401357       
    13411358        /* Lookup the file structure corresponding to oldfd. */
    13421359        vfs_file_t *oldfile = vfs_file_get(oldfd);
    13431360        if (!oldfile) {
    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);
     1361                async_answer_0(rid, EBADF);
    13511362                return;
    13521363        }
    … …  
    13651376                if (ret != EOK) {
    13661377                        fibril_mutex_unlock(&oldfile->lock);
    1367                         ipc_answer_0(rid, ret);
     1378                        vfs_file_put(oldfile);
     1379                        vfs_file_put(newfile);
     1380                        async_answer_0(rid, ret);
    13681381                        return;
    13691382                }
    … …  
    13721385                if (ret != EOK) {
    13731386                        fibril_mutex_unlock(&oldfile->lock);
    1374                         ipc_answer_0(rid, ret);
    1375                         return;
    1376                 }
     1387                        vfs_file_put(oldfile);
     1388                        vfs_file_put(newfile);
     1389                        async_answer_0(rid, ret);
     1390                        return;
     1391                }
     1392                vfs_file_put(newfile);
    13771393        }
    13781394       
    … …  
    13801396        int ret = vfs_fd_assign(oldfile, newfd);
    13811397        fibril_mutex_unlock(&oldfile->lock);
     1398        vfs_file_put(oldfile);
    13821399       
    13831400        if (ret != EOK)
    1384                 ipc_answer_0(rid, ret);
     1401                async_answer_0(rid, ret);
    13851402        else
    1386                 ipc_answer_1(rid, EOK, newfd);
     1403                async_answer_1(rid, EOK, newfd);
    13871404}
    13881405
Note: See TracChangeset for help on using the changeset viewer.