Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset db6e419 in mainline for uspace/lib/fs/libfs.c


Ignore:
Timestamp:
2011-08-16T18:53:00Z (10 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master
Children:
49160c4
Parents:
e0e922d (diff), 45058baa (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/lib/fs/libfs.c

    re0e922d rdb6e419  
    7777static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
    7878{
    79         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     79        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    8080        char *opts;
    8181        int rc;
     
    9191        aoff64_t size;
    9292        unsigned lnkcnt;
    93         rc = vfs_out_ops->mounted(devmap_handle, opts, &index, &size, &lnkcnt);
     93        rc = vfs_out_ops->mounted(service_id, opts, &index, &size, &lnkcnt);
    9494
    9595        if (rc == EOK)
     
    109109static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)
    110110{
    111         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     111        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    112112        int rc;
    113113
    114         rc = vfs_out_ops->unmounted(devmap_handle);
     114        rc = vfs_out_ops->unmounted(service_id);
    115115
    116116        async_answer_0(rid, rc);
     
    130130static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req)
    131131{
    132         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     132        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    133133        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    134134        aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
     
    137137        int rc;
    138138
    139         rc = vfs_out_ops->read(devmap_handle, index, pos, &rbytes);
     139        rc = vfs_out_ops->read(service_id, index, pos, &rbytes);
    140140
    141141        if (rc == EOK)
     
    147147static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req)
    148148{
    149         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     149        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    150150        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    151151        aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
     
    155155        int rc;
    156156
    157         rc = vfs_out_ops->write(devmap_handle, index, pos, &wbytes, &nsize);
     157        rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);
    158158
    159159        if (rc == EOK)
     
    165165static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req)
    166166{
    167         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     167        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    168168        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    169169        aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),
     
    171171        int rc;
    172172
    173         rc = vfs_out_ops->truncate(devmap_handle, index, size);
     173        rc = vfs_out_ops->truncate(service_id, index, size);
    174174
    175175        async_answer_0(rid, rc);
     
    178178static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req)
    179179{
    180         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     180        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    181181        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    182182        int rc;
    183183
    184         rc = vfs_out_ops->close(devmap_handle, index);
     184        rc = vfs_out_ops->close(service_id, index);
    185185
    186186        async_answer_0(rid, rc);
     
    189189static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req)
    190190{
    191         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     191        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    192192        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    193193        int rc;
    194194
    195         rc = vfs_out_ops->destroy(devmap_handle, index);
     195        rc = vfs_out_ops->destroy(service_id, index);
    196196
    197197        async_answer_0(rid, rc);
     
    210210static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req)
    211211{
    212         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     212        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    213213        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    214214        int rc;
    215215
    216         rc = vfs_out_ops->sync(devmap_handle, index);
     216        rc = vfs_out_ops->sync(service_id, index);
    217217
    218218        async_answer_0(rid, rc);
     
    380380    ipc_call_t *req)
    381381{
    382         devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     382        service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
    383383        fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
    384384        fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req);
    385         devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*req);
     385        service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req);
    386386       
    387387        async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL);
     
    392392       
    393393        fs_node_t *fn;
    394         int res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
     394        int res = ops->node_get(&fn, mp_service_id, mp_fs_index);
    395395        if ((res != EOK) || (!fn)) {
    396396                async_hangup(mountee_sess);
     
    422422        ipc_call_t answer;
    423423        int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED,
    424             mr_devmap_handle, &answer);
     424            mr_service_id, &answer);
    425425        async_exchange_end(exch);
    426426       
     
    428428                fn->mp_data.mp_active = true;
    429429                fn->mp_data.fs_handle = mr_fs_handle;
    430                 fn->mp_data.devmap_handle = mr_devmap_handle;
     430                fn->mp_data.service_id = mr_service_id;
    431431                fn->mp_data.sess = mountee_sess;
    432432        }
     
    441441void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req)
    442442{
    443         devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req);
     443        service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);
    444444        fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req);
    445445        fs_node_t *fn;
    446446        int res;
    447447
    448         res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
     448        res = ops->node_get(&fn, mp_service_id, mp_fs_index);
    449449        if ((res != EOK) || (!fn)) {
    450450                async_answer_0(rid, combine_rc(res, ENOENT));
     
    465465         */
    466466        async_exch_t *exch = async_exchange_begin(fn->mp_data.sess);
    467         res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.devmap_handle);
     467        res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id);
    468468        async_exchange_end(exch);
    469469
     
    475475                fn->mp_data.mp_active = false;
    476476                fn->mp_data.fs_handle = 0;
    477                 fn->mp_data.devmap_handle = 0;
     477                fn->mp_data.service_id = 0;
    478478                fn->mp_data.sess = NULL;
    479479               
     
    510510        unsigned int last = IPC_GET_ARG2(*req);
    511511        unsigned int next = first;
    512         devmap_handle_t devmap_handle = IPC_GET_ARG3(*req);
     512        service_id_t service_id = IPC_GET_ARG3(*req);
    513513        int lflag = IPC_GET_ARG4(*req);
    514514        fs_index_t index = IPC_GET_ARG5(*req);
     
    524524        fs_node_t *tmp = NULL;
    525525       
    526         rc = ops->root_get(&cur, devmap_handle);
     526        rc = ops->root_get(&cur, service_id);
    527527        on_error(rc, goto out_with_answer);
    528528       
     
    530530                async_exch_t *exch = async_exchange_begin(cur->mp_data.sess);
    531531                async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last,
    532                     cur->mp_data.devmap_handle, lflag, index,
     532                    cur->mp_data.service_id, lflag, index,
    533533                    IPC_FF_ROUTE_FROM_ME);
    534534                async_exchange_end(exch);
     
    591591                        async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess);
    592592                        async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next,
    593                             last, tmp->mp_data.devmap_handle, lflag, index,
     593                            last, tmp->mp_data.service_id, lflag, index,
    594594                            IPC_FF_ROUTE_FROM_ME);
    595595                        async_exchange_end(exch);
     
    620620                                fs_node_t *fn;
    621621                                if (lflag & L_CREATE)
    622                                         rc = ops->create(&fn, devmap_handle,
     622                                        rc = ops->create(&fn, service_id,
    623623                                            lflag);
    624624                                else
    625                                         rc = ops->node_get(&fn, devmap_handle,
     625                                        rc = ops->node_get(&fn, service_id,
    626626                                            index);
    627627                                on_error(rc, goto out_with_answer);
     
    638638                                                aoff64_t size = ops->size_get(fn);
    639639                                                async_answer_5(rid, fs_handle,
    640                                                     devmap_handle,
     640                                                    service_id,
    641641                                                    ops->index_get(fn),
    642642                                                    LOWER32(size),
     
    706706                        fs_node_t *fn;
    707707                        if (lflag & L_CREATE)
    708                                 rc = ops->create(&fn, devmap_handle, lflag);
     708                                rc = ops->create(&fn, service_id, lflag);
    709709                        else
    710                                 rc = ops->node_get(&fn, devmap_handle, index);
     710                                rc = ops->node_get(&fn, service_id, index);
    711711                        on_error(rc, goto out_with_answer);
    712712                       
     
    722722                                        aoff64_t size = ops->size_get(fn);
    723723                                        async_answer_5(rid, fs_handle,
    724                                             devmap_handle,
     724                                            service_id,
    725725                                            ops->index_get(fn),
    726726                                            LOWER32(size),
     
    748748                if (rc == EOK) {
    749749                        aoff64_t size = ops->size_get(cur);
    750                         async_answer_5(rid, fs_handle, devmap_handle,
     750                        async_answer_5(rid, fs_handle, service_id,
    751751                            ops->index_get(cur), LOWER32(size), UPPER32(size),
    752752                            old_lnkcnt);
     
    786786                if (rc == EOK) {
    787787                        aoff64_t size = ops->size_get(cur);
    788                         async_answer_5(rid, fs_handle, devmap_handle,
     788                        async_answer_5(rid, fs_handle, service_id,
    789789                            ops->index_get(cur), LOWER32(size), UPPER32(size),
    790790                            ops->lnkcnt_get(cur));
     
    810810    ipc_call_t *request)
    811811{
    812         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     812        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    813813        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    814814       
    815815        fs_node_t *fn;
    816         int rc = ops->node_get(&fn, devmap_handle, index);
     816        int rc = ops->node_get(&fn, service_id, index);
    817817        on_error(rc, answer_and_return(rid, rc));
    818818       
     
    831831       
    832832        stat.fs_handle = fs_handle;
    833         stat.devmap_handle = devmap_handle;
     833        stat.service_id = service_id;
    834834        stat.index = index;
    835835        stat.lnkcnt = ops->lnkcnt_get(fn);
     
    837837        stat.is_directory = ops->is_directory(fn);
    838838        stat.size = ops->size_get(fn);
    839         stat.device = ops->device_get(fn);
     839        stat.service = ops->device_get(fn);
    840840       
    841841        ops->node_put(fn);
     
    856856    ipc_call_t *request)
    857857{
    858         devmap_handle_t devmap_handle = IPC_GET_ARG1(*request);
     858        service_id_t service_id = IPC_GET_ARG1(*request);
    859859        fs_index_t index = IPC_GET_ARG2(*request);
    860860       
    861861        fs_node_t *fn;
    862         int rc = ops->node_get(&fn, devmap_handle, index);
     862        int rc = ops->node_get(&fn, service_id, index);
    863863        on_error(rc, answer_and_return(rid, rc));
    864864       
Note: See TracChangeset for help on using the changeset viewer.