Changeset 15f3c3f in mainline for uspace/srv/fs


Ignore:
Timestamp:
2011-06-22T22:00:52Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
86ffa27f
Parents:
ef09a7a
Message:

Rename devmap to loc, devfs to locfs.

Location:
uspace/srv/fs
Files:
9 edited
5 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/ext2fs/ext2fs_ops.c

    ref09a7a r15f3c3f  
    4343#include <libext2.h>
    4444#include <ipc/services.h>
    45 #include <ipc/devmap.h>
     45#include <ipc/loc.h>
    4646#include <macros.h>
    4747#include <async.h>
    … …  
    7070typedef struct ext2fs_instance {
    7171        link_t link;
    72         devmap_handle_t devmap_handle;
     72        service_id_t service_id;
    7373        ext2_filesystem_t *filesystem;
    7474        unsigned int open_nodes_count;
    … …  
    8686 * Forward declarations of auxiliary functions
    8787 */
    88 static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_t **);
     88static int ext2fs_instance_get(service_id_t, ext2fs_instance_t **);
    8989static void ext2fs_read_directory(ipc_callid_t, ipc_callid_t, aoff64_t,
    9090        size_t, ext2fs_instance_t *, ext2_inode_ref_t *);
    … …  
    9898 * Forward declarations of EXT2 libfs operations.
    9999 */
    100 static int ext2fs_root_get(fs_node_t **, devmap_handle_t);
     100static int ext2fs_root_get(fs_node_t **, service_id_t);
    101101static int ext2fs_match(fs_node_t **, fs_node_t *, const char *);
    102 static int ext2fs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     102static int ext2fs_node_get(fs_node_t **, service_id_t, fs_index_t);
    103103static int ext2fs_node_open(fs_node_t *);
    104104static int ext2fs_node_put(fs_node_t *);
    105 static int ext2fs_create_node(fs_node_t **, devmap_handle_t, int);
     105static int ext2fs_create_node(fs_node_t **, service_id_t, int);
    106106static int ext2fs_destroy_node(fs_node_t *);
    107107static int ext2fs_link(fs_node_t *, fs_node_t *, const char *);
    … …  
    114114static bool ext2fs_is_directory(fs_node_t *);
    115115static bool ext2fs_is_file(fs_node_t *node);
    116 static devmap_handle_t ext2fs_device_get(fs_node_t *node);
     116static service_id_t ext2fs_device_get(fs_node_t *node);
    117117
    118118/*
    … …  
    136136        ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
    137137        assert(keys > 0);
    138         if (enode->instance->devmap_handle !=
    139             ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
     138        if (enode->instance->service_id !=
     139            ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
    140140                return false;
    141141        }
    … …  
    182182
    183183/**
    184  * Find an instance of filesystem for the given devmap_handle
     184 * Find an instance of filesystem for the given service_id
    185185 */
    186 int ext2fs_instance_get(devmap_handle_t devmap_handle, ext2fs_instance_t **inst)
    187 {
    188         EXT2FS_DBG("(%" PRIun ", -)", devmap_handle);
     186int ext2fs_instance_get(service_id_t service_id, ext2fs_instance_t **inst)
     187{
     188        EXT2FS_DBG("(%" PRIun ", -)", service_id);
    189189        ext2fs_instance_t *tmp;
    190190       
    … …  
    200200                tmp = list_get_instance(link, ext2fs_instance_t, link);
    201201               
    202                 if (tmp->devmap_handle == devmap_handle) {
     202                if (tmp->service_id == service_id) {
    203203                        *inst = tmp;
    204204                        fibril_mutex_unlock(&instance_list_mutex);
    … …  
    215215
    216216
    217 int ext2fs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    218 {
    219         EXT2FS_DBG("(-, %" PRIun ")", devmap_handle);
    220         return ext2fs_node_get(rfn, devmap_handle, EXT2_INODE_ROOT_INDEX);
     217int ext2fs_root_get(fs_node_t **rfn, service_id_t service_id)
     218{
     219        EXT2FS_DBG("(-, %" PRIun ")", service_id);
     220        return ext2fs_node_get(rfn, service_id, EXT2_INODE_ROOT_INDEX);
    221221}
    222222
    … …  
    291291
    292292/** Instantiate a EXT2 in-core node. */
    293 int ext2fs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    294 {
    295         EXT2FS_DBG("(-,%" PRIun ",%u)", devmap_handle, index);
     293int ext2fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     294{
     295        EXT2FS_DBG("(-,%" PRIun ",%u)", service_id, index);
    296296       
    297297        ext2fs_instance_t *inst = NULL;
    298298        int rc;
    299299       
    300         rc = ext2fs_instance_get(devmap_handle, &inst);
     300        rc = ext2fs_instance_get(service_id, &inst);
    301301        if (rc != EOK) {
    302302                return rc;
    … …  
    319319        /* Check if the node is not already open */
    320320        unsigned long key[] = {
    321                 [OPEN_NODES_DEV_HANDLE_KEY] = inst->devmap_handle,
     321                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
    322322                [OPEN_NODES_INODE_KEY] = index,
    323323        };
    … …  
    413413
    414414        unsigned long key[] = {
    415                 [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->devmap_handle,
     415                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
    416416                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
    417417        };
    … …  
    431431}
    432432
    433 int ext2fs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     433int ext2fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    434434{
    435435        EXT2FS_DBG("");
    … …  
    564564}
    565565
    566 devmap_handle_t ext2fs_device_get(fs_node_t *fn)
     566service_id_t ext2fs_device_get(fs_node_t *fn)
    567567{
    568568        EXT2FS_DBG("");
    569569        ext2fs_node_t *enode = EXT2FS_NODE(fn);
    570         return enode->instance->devmap_handle;
     570        return enode->instance->service_id;
    571571}
    572572
    … …  
    600600        EXT2FS_DBG("");
    601601        int rc;
    602         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     602        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    603603        ext2_filesystem_t *fs;
    604604        ext2fs_instance_t *inst;
    … …  
    632632       
    633633        /* Initialize the filesystem  */
    634         rc = ext2_filesystem_init(fs, devmap_handle);
     634        rc = ext2_filesystem_init(fs, service_id);
    635635        if (rc != EOK) {
    636636                free(fs);
    … …  
    662662        /* Initialize instance */
    663663        link_initialize(&inst->link);
    664         inst->devmap_handle = devmap_handle;
     664        inst->service_id = service_id;
    665665        inst->filesystem = fs;
    666666        inst->open_nodes_count = 0;
    … …  
    700700{
    701701        EXT2FS_DBG("");
    702         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     702        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    703703        ext2fs_instance_t *inst;
    704704        int rc;
    705705       
    706         rc = ext2fs_instance_get(devmap_handle, &inst);
     706        rc = ext2fs_instance_get(service_id, &inst);
    707707       
    708708        if (rc != EOK) {
    … …  
    747747{
    748748        EXT2FS_DBG("");
    749         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     749        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    750750        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    751751        aoff64_t pos =
    … …  
    767767        }
    768768       
    769         rc = ext2fs_instance_get(devmap_handle, &inst);
     769        rc = ext2fs_instance_get(service_id, &inst);
    770770        if (rc != EOK) {
    771771                async_answer_0(callid, rc);
    … …  
    965965       
    966966        /* Usual case - we need to read a block from device */
    967         rc = block_get(&block, inst->devmap_handle, fs_block, BLOCK_FLAGS_NONE);
     967        rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
    968968        if (rc != EOK) {
    969969                async_answer_0(callid, rc);
    … …  
    987987{
    988988        EXT2FS_DBG("");
    989 //      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     989//      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    990990//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    991991//      aoff64_t pos =
    … …  
    999999{
    10001000        EXT2FS_DBG("");
    1001 //      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1001//      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    10021002//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    10031003//      aoff64_t size =
    … …  
    10171017{
    10181018        EXT2FS_DBG("");
    1019 //      devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     1019//      service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    10201020//      fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    10211021       
    … …  
    10391039{
    10401040        EXT2FS_DBG("");
    1041 //      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1041//      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    10421042//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    10431043       

  • uspace/srv/fs/fat/fat.h

    ref09a7a r15f3c3f  
    175175
    176176        fibril_mutex_t  lock;
    177         devmap_handle_t devmap_handle;
     177        service_id_t    service_id;
    178178        fs_index_t      index;
    179179        /**
    … …  
    241241extern void fat_sync(ipc_callid_t, ipc_call_t *);
    242242
    243 extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t);
    244 extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned);
    245 extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t);
     243extern int fat_idx_get_new(fat_idx_t **, service_id_t);
     244extern fat_idx_t *fat_idx_get_by_pos(service_id_t, fat_cluster_t, unsigned);
     245extern fat_idx_t *fat_idx_get_by_index(service_id_t, fs_index_t);
    246246extern void fat_idx_destroy(fat_idx_t *);
    247247extern void fat_idx_hashin(fat_idx_t *);
    … …  
    250250extern int fat_idx_init(void);
    251251extern void fat_idx_fini(void);
    252 extern int fat_idx_init_by_devmap_handle(devmap_handle_t);
    253 extern void fat_idx_fini_by_devmap_handle(devmap_handle_t);
     252extern int fat_idx_init_by_service_id(service_id_t);
     253extern void fat_idx_fini_by_service_id(service_id_t);
    254254
    255255#endif

  • uspace/srv/fs/fat/fat_fat.c

    ref09a7a r15f3c3f  
    7171 *
    7272 * @param bs            Buffer holding the boot sector for the file.
    73  * @param devmap_handle Device handle of the device with the file.
     73 * @param service_id    Service ID of the device with the file.
    7474 * @param firstc        First cluster to start the walk with.
    7575 * @param lastc         If non-NULL, output argument hodling the last cluster
    … …  
    8282 */
    8383int
    84 fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc,
     84fat_cluster_walk(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc,
    8585    fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
    8686{
    … …  
    109109                fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
    110110                /* read FAT1 */
    111                 rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec,
     111                rc = block_get(&b, service_id, RSCNT(bs) + fsec,
    112112                    BLOCK_FLAGS_NONE);
    113113                if (rc != EOK)
    … …  
    160160                 * when fortunately we have the last cluster number cached.
    161161                 */
    162                 return block_get(block, nodep->idx->devmap_handle,
     162                return block_get(block, nodep->idx->service_id,
    163163                    CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
    164164        }
    … …  
    174174
    175175fall_through:
    176         rc = _fat_block_get(block, bs, nodep->idx->devmap_handle, firstc,
     176        rc = _fat_block_get(block, bs, nodep->idx->service_id, firstc,
    177177            &currc, relbn, flags);
    178178        if (rc != EOK)
    … …  
    193193 * @param block         Pointer to a block pointer for storing result.
    194194 * @param bs            Buffer holding the boot sector of the file system.
    195  * @param devmap_handle Device handle of the file system.
     195 * @param service_id    Service ID handle of the file system.
    196196 * @param fcl           First cluster used by the file. Can be zero if the file
    197197 *                      is empty.
    … …  
    205205 */
    206206int
    207 _fat_block_get(block_t **block, fat_bs_t *bs, devmap_handle_t devmap_handle,
     207_fat_block_get(block_t **block, fat_bs_t *bs, service_id_t service_id,
    208208    fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
    209209{
    … …  
    222222                /* root directory special case */
    223223                assert(bn < RDS(bs));
    224                 rc = block_get(block, devmap_handle,
     224                rc = block_get(block, service_id,
    225225                    RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
    226226                return rc;
    … …  
    228228
    229229        max_clusters = bn / SPC(bs);
    230         rc = fat_cluster_walk(bs, devmap_handle, fcl, &c, &clusters, max_clusters);
     230        rc = fat_cluster_walk(bs, service_id, fcl, &c, &clusters, max_clusters);
    231231        if (rc != EOK)
    232232                return rc;
    233233        assert(clusters == max_clusters);
    234234
    235         rc = block_get(block, devmap_handle, CLBN2PBN(bs, c, bn), flags);
     235        rc = block_get(block, service_id, CLBN2PBN(bs, c, bn), flags);
    236236
    237237        if (clp)
    … …  
    281281        /* zero out the initial part of the new cluster chain */
    282282        for (o = boundary; o < pos; o += BPS(bs)) {
    283                 rc = _fat_block_get(&b, bs, nodep->idx->devmap_handle, mcl,
     283                rc = _fat_block_get(&b, bs, nodep->idx->service_id, mcl,
    284284                    NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
    285285                if (rc != EOK)
    … …  
    298298 *
    299299 * @param bs            Buffer holding the boot sector for the file system.
    300  * @param devmap_handle Device handle for the file system.
     300 * @param service_id    Service ID for the file system.
    301301 * @param clst          Cluster which to get.
    302302 * @param value         Output argument holding the value of the cluster.
    … …  
    305305 */
    306306int
    307 fat_get_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
     307fat_get_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    308308    fat_cluster_t clst, fat_cluster_t *value)
    309309{
    … …  
    312312        int rc;
    313313
    314         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
     314        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
    315315            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    316316        if (rc != EOK)
    … …  
    327327 *
    328328 * @param bs            Buffer holding the boot sector for the file system.
    329  * @param devmap_handle Device handle for the file system.
     329 * @param service_id    Device service ID for the file system.
    330330 * @param fatno         Number of the FAT instance where to make the change.
    331331 * @param clst          Cluster which is to be set.
    … …  
    335335 */
    336336int
    337 fat_set_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
     337fat_set_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    338338    fat_cluster_t clst, fat_cluster_t value)
    339339{
    … …  
    343343
    344344        assert(fatno < FATCNT(bs));
    345         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
     345        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
    346346            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    347347        if (rc != EOK)
    … …  
    358358 *
    359359 * @param bs            Buffer holding the boot sector of the file system.
    360  * @param devmap_handle Device handle of the file system.
     360 * @param service_id    Service ID of the file system.
    361361 * @param lifo          Chain of allocated clusters.
    362362 * @param nclsts        Number of clusters in the lifo chain.
    … …  
    364364 * @return              EOK on success or a negative error code.
    365365 */
    366 int fat_alloc_shadow_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle,
     366int fat_alloc_shadow_clusters(fat_bs_t *bs, service_id_t service_id,
    367367    fat_cluster_t *lifo, unsigned nclsts)
    368368{
    … …  
    373373        for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
    374374                for (c = 0; c < nclsts; c++) {
    375                         rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c],
     375                        rc = fat_set_cluster(bs, service_id, fatno, lifo[c],
    376376                            c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
    377377                        if (rc != EOK)
    … …  
    391391 *
    392392 * @param bs            Buffer holding the boot sector of the file system.
    393  * @param devmap_handle Device handle of the file system.
     393 * @param service_id    Device service ID of the file system.
    394394 * @param nclsts        Number of clusters to allocate.
    395395 * @param mcl           Output parameter where the first cluster in the chain
    … …  
    401401 */
    402402int
    403 fat_alloc_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned nclsts,
     403fat_alloc_clusters(fat_bs_t *bs, service_id_t service_id, unsigned nclsts,
    404404    fat_cluster_t *mcl, fat_cluster_t *lcl)
    405405{
    … …  
    419419        fibril_mutex_lock(&fat_alloc_lock);
    420420        for (b = 0, cl = 0; b < SF(bs); b++) {
    421                 rc = block_get(&blk, devmap_handle, RSCNT(bs) + b,
     421                rc = block_get(&blk, service_id, RSCNT(bs) + b,
    422422                    BLOCK_FLAGS_NONE);
    423423                if (rc != EOK)
    … …  
    458458                                        /* update the shadow copies of FAT */
    459459                                        rc = fat_alloc_shadow_clusters(bs,
    460                                             devmap_handle, lifo, nclsts);
     460                                            service_id, lifo, nclsts);
    461461                                        if (rc != EOK)
    462462                                                goto error;
    … …  
    485485         */
    486486        while (found--) {
    487                 rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found],
     487                rc = fat_set_cluster(bs, service_id, FAT1, lifo[found],
    488488                    FAT_CLST_RES0);
    489489                if (rc != EOK) {
    … …  
    500500 *
    501501 * @param bs            Buffer hodling the boot sector of the file system.
    502  * @param devmap_handle Device handle of the file system.
     502 * @param service_id    Device service ID of the file system.
    503503 * @param firstc        First cluster in the chain which is to be freed.
    504504 *
    … …  
    506506 */
    507507int
    508 fat_free_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc)
     508fat_free_clusters(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc)
    509509{
    510510        unsigned fatno;
    … …  
    515515        while (firstc < FAT_CLST_LAST1) {
    516516                assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
    517                 rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc);
     517                rc = fat_get_cluster(bs, service_id, FAT1, firstc, &nextc);
    518518                if (rc != EOK)
    519519                        return rc;
    520520                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
    521                         rc = fat_set_cluster(bs, devmap_handle, fatno, firstc,
     521                        rc = fat_set_cluster(bs, service_id, fatno, firstc,
    522522                            FAT_CLST_RES0);
    523523                        if (rc != EOK)
    … …  
    544544    fat_cluster_t lcl)
    545545{
    546         devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
     546        service_id_t service_id = nodep->idx->service_id;
    547547        fat_cluster_t lastc;
    548548        uint8_t fatno;
    … …  
    558558                        nodep->lastc_cached_valid = false;
    559559                } else {
    560                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     560                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    561561                            &lastc, NULL, (uint16_t) -1);
    562562                        if (rc != EOK)
    … …  
    565565
    566566                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
    567                         rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno,
     567                        rc = fat_set_cluster(bs, nodep->idx->service_id, fatno,
    568568                            lastc, mcl);
    569569                        if (rc != EOK)
    … …  
    591591{
    592592        int rc;
    593         devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
     593        service_id_t service_id = nodep->idx->service_id;
    594594
    595595        /*
    … …  
    602602        if (lcl == FAT_CLST_RES0) {
    603603                /* The node will have zero size and no clusters allocated. */
    604                 rc = fat_free_clusters(bs, devmap_handle, nodep->firstc);
     604                rc = fat_free_clusters(bs, service_id, nodep->firstc);
    605605                if (rc != EOK)
    606606                        return rc;
    … …  
    611611                unsigned fatno;
    612612
    613                 rc = fat_get_cluster(bs, devmap_handle, FAT1, lcl, &nextc);
     613                rc = fat_get_cluster(bs, service_id, FAT1, lcl, &nextc);
    614614                if (rc != EOK)
    615615                        return rc;
    … …  
    617617                /* Terminate the cluster chain in all copies of FAT. */
    618618                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
    619                         rc = fat_set_cluster(bs, devmap_handle, fatno, lcl,
     619                        rc = fat_set_cluster(bs, service_id, fatno, lcl,
    620620                            FAT_CLST_LAST1);
    621621                        if (rc != EOK)
    … …  
    624624
    625625                /* Free all following clusters. */
    626                 rc = fat_free_clusters(bs, devmap_handle, nextc);
     626                rc = fat_free_clusters(bs, service_id, nextc);
    627627                if (rc != EOK)
    628628                        return rc;
    … …  
    639639
    640640int
    641 fat_zero_cluster(struct fat_bs *bs, devmap_handle_t devmap_handle, fat_cluster_t c)
     641fat_zero_cluster(struct fat_bs *bs, service_id_t service_id, fat_cluster_t c)
    642642{
    643643        int i;
    … …  
    646646
    647647        for (i = 0; i < SPC(bs); i++) {
    648                 rc = _fat_block_get(&b, bs, devmap_handle, c, NULL, i,
     648                rc = _fat_block_get(&b, bs, service_id, c, NULL, i,
    649649                    BLOCK_FLAGS_NOREAD);
    650650                if (rc != EOK)
    … …  
    666666 * does not contain a fat file system.
    667667 */
    668 int fat_sanity_check(fat_bs_t *bs, devmap_handle_t devmap_handle)
     668int fat_sanity_check(fat_bs_t *bs, service_id_t service_id)
    669669{
    670670        fat_cluster_t e0, e1;
    … …  
    707707
    708708        for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) {
    709                 rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0);
     709                rc = fat_get_cluster(bs, service_id, fat_no, 0, &e0);
    710710                if (rc != EOK)
    711711                        return EIO;
    712712
    713                 rc = fat_get_cluster(bs, devmap_handle, fat_no, 1, &e1);
     713                rc = fat_get_cluster(bs, service_id, fat_no, 1, &e1);
    714714                if (rc != EOK)
    715715                        return EIO;

  • uspace/srv/fs/fat/fat_fat.h

    ref09a7a r15f3c3f  
    6161#define fat_clusters_get(numc, bs, dh, fc) \
    6262    fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1)
    63 extern int fat_cluster_walk(struct fat_bs *, devmap_handle_t, fat_cluster_t,
     63extern int fat_cluster_walk(struct fat_bs *, service_id_t, fat_cluster_t,
    6464    fat_cluster_t *, uint16_t *, uint16_t);
    6565
    6666extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
    6767    aoff64_t, int);
    68 extern int _fat_block_get(block_t **, struct fat_bs *, devmap_handle_t,
     68extern int _fat_block_get(block_t **, struct fat_bs *, service_id_t,
    6969    fat_cluster_t, fat_cluster_t *, aoff64_t, int);
    7070
    … …  
    7373extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
    7474    fat_cluster_t);
    75 extern int fat_alloc_clusters(struct fat_bs *, devmap_handle_t, unsigned,
     75extern int fat_alloc_clusters(struct fat_bs *, service_id_t, unsigned,
    7676    fat_cluster_t *, fat_cluster_t *);
    77 extern int fat_free_clusters(struct fat_bs *, devmap_handle_t, fat_cluster_t);
    78 extern int fat_alloc_shadow_clusters(struct fat_bs *, devmap_handle_t,
     77extern int fat_free_clusters(struct fat_bs *, service_id_t, fat_cluster_t);
     78extern int fat_alloc_shadow_clusters(struct fat_bs *, service_id_t,
    7979    fat_cluster_t *, unsigned);
    80 extern int fat_get_cluster(struct fat_bs *, devmap_handle_t, unsigned,
     80extern int fat_get_cluster(struct fat_bs *, service_id_t, unsigned,
    8181    fat_cluster_t, fat_cluster_t *);
    82 extern int fat_set_cluster(struct fat_bs *, devmap_handle_t, unsigned,
     82extern int fat_set_cluster(struct fat_bs *, service_id_t, unsigned,
    8383    fat_cluster_t, fat_cluster_t);
    8484extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
    8585    aoff64_t);
    86 extern int fat_zero_cluster(struct fat_bs *, devmap_handle_t, fat_cluster_t);
    87 extern int fat_sanity_check(struct fat_bs *, devmap_handle_t);
     86extern int fat_zero_cluster(struct fat_bs *, service_id_t, fat_cluster_t);
     87extern int fat_sanity_check(struct fat_bs *, service_id_t);
    8888
    8989#endif

  • uspace/srv/fs/fat/fat_idx.c

    ref09a7a r15f3c3f  
    5959typedef struct {
    6060        link_t          link;
    61         devmap_handle_t devmap_handle;
     61        service_id_t    service_id;
    6262
    6363        /** Next unassigned index. */
    … …  
    7676static LIST_INITIALIZE(unused_list);
    7777
    78 static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
     78static void unused_initialize(unused_t *u, service_id_t service_id)
    7979{
    8080        link_initialize(&u->link);
    81         u->devmap_handle = devmap_handle;
     81        u->service_id = service_id;
    8282        u->next = 0;
    8383        u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
    … …  
    8585}
    8686
    87 static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock)
     87static unused_t *unused_find(service_id_t service_id, bool lock)
    8888{
    8989        unused_t *u;
    … …  
    9494        list_foreach(unused_list, l) {
    9595                u = list_get_instance(l, unused_t, link);
    96                 if (u->devmap_handle == devmap_handle)
     96                if (u->service_id == service_id)
    9797                        return u;
    9898        }
    … …  
    108108/**
    109109 * Global hash table of all used fat_idx_t structures.
    110  * The index structures are hashed by the devmap_handle, parent node's first
     110 * The index structures are hashed by the service_id, parent node's first
    111111 * cluster and index within the parent directory.
    112112 */
    … …  
    122122static hash_index_t pos_hash(unsigned long key[])
    123123{
    124         devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
     124        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
    125125        fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
    126126        unsigned pdi = (unsigned)key[UPH_PDI_KEY];
    … …  
    142142        h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
    143143            (UPH_BUCKETS_LOG / 2);
    144         h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
     144        h |= (service_id & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
    145145            (3 * (UPH_BUCKETS_LOG / 4));
    146146
    … …  
    150150static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item)
    151151{
    152         devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
     152        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
    153153        fat_cluster_t pfc;
    154154        unsigned pdi;
    … …  
    157157        switch (keys) {
    158158        case 1:
    159                 return (devmap_handle == fidx->devmap_handle);
     159                return (service_id == fidx->service_id);
    160160        case 3:
    161161                pfc = (fat_cluster_t) key[UPH_PFC_KEY];
    162162                pdi = (unsigned) key[UPH_PDI_KEY];
    163                 return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) &&
     163                return (service_id == fidx->service_id) && (pfc == fidx->pfc) &&
    164164                    (pdi == fidx->pdi);
    165165        default:
    … …  
    183183/**
    184184 * Global hash table of all used fat_idx_t structures.
    185  * The index structures are hashed by the devmap_handle and index.
     185 * The index structures are hashed by the service_id and index.
    186186 */
    187187static hash_table_t ui_hash;
    … …  
    195195static hash_index_t idx_hash(unsigned long key[])
    196196{
    197         devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
     197        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
    198198        fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
    199199
    200200        hash_index_t h;
    201201
    202         h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
     202        h = service_id & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
    203203        h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) <<
    204204            (UIH_BUCKETS_LOG / 2);
    … …  
    209209static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
    210210{
    211         devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
     211        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
    212212        fs_index_t index;
    213213        fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
    … …  
    215215        switch (keys) {
    216216        case 1:
    217                 return (devmap_handle == fidx->devmap_handle);
     217                return (service_id == fidx->service_id);
    218218        case 2:
    219219                index = (fs_index_t) key[UIH_INDEX_KEY];
    220                 return (devmap_handle == fidx->devmap_handle) &&
     220                return (service_id == fidx->service_id) &&
    221221                    (index == fidx->index);
    222222        default:
    … …  
    241241
    242242/** Allocate a VFS index which is not currently in use. */
    243 static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index)
     243static bool fat_index_alloc(service_id_t service_id, fs_index_t *index)
    244244{
    245245        unused_t *u;
    246246       
    247247        assert(index);
    248         u = unused_find(devmap_handle, true);
     248        u = unused_find(service_id, true);
    249249        if (!u)
    250250                return false;   
    … …  
    303303
    304304/** Free a VFS index, which is no longer in use. */
    305 static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index)
     305static void fat_index_free(service_id_t service_id, fs_index_t index)
    306306{
    307307        unused_t *u;
    308308
    309         u = unused_find(devmap_handle, true);
     309        u = unused_find(service_id, true);
    310310        assert(u);
    311311
    … …  
    365365}
    366366
    367 static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
     367static int fat_idx_create(fat_idx_t **fidxp, service_id_t service_id)
    368368{
    369369        fat_idx_t *fidx;
    … …  
    372372        if (!fidx)
    373373                return ENOMEM;
    374         if (!fat_index_alloc(devmap_handle, &fidx->index)) {
     374        if (!fat_index_alloc(service_id, &fidx->index)) {
    375375                free(fidx);
    376376                return ENOSPC;
    … …  
    380380        link_initialize(&fidx->uih_link);
    381381        fibril_mutex_initialize(&fidx->lock);
    382         fidx->devmap_handle = devmap_handle;
     382        fidx->service_id = service_id;
    383383        fidx->pfc = FAT_CLST_RES0;      /* no parent yet */
    384384        fidx->pdi = 0;
    … …  
    389389}
    390390
    391 int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
     391int fat_idx_get_new(fat_idx_t **fidxp, service_id_t service_id)
    392392{
    393393        fat_idx_t *fidx;
    … …  
    395395
    396396        fibril_mutex_lock(&used_lock);
    397         rc = fat_idx_create(&fidx, devmap_handle);
     397        rc = fat_idx_create(&fidx, service_id);
    398398        if (rc != EOK) {
    399399                fibril_mutex_unlock(&used_lock);
    … …  
    402402               
    403403        unsigned long ikey[] = {
    404                 [UIH_DH_KEY] = devmap_handle,
     404                [UIH_DH_KEY] = service_id,
    405405                [UIH_INDEX_KEY] = fidx->index,
    406406        };
    … …  
    415415
    416416fat_idx_t *
    417 fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi)
     417fat_idx_get_by_pos(service_id_t service_id, fat_cluster_t pfc, unsigned pdi)
    418418{
    419419        fat_idx_t *fidx;
    420420        link_t *l;
    421421        unsigned long pkey[] = {
    422                 [UPH_DH_KEY] = devmap_handle,
     422                [UPH_DH_KEY] = service_id,
    423423                [UPH_PFC_KEY] = pfc,
    424424                [UPH_PDI_KEY] = pdi,
    … …  
    432432                int rc;
    433433
    434                 rc = fat_idx_create(&fidx, devmap_handle);
     434                rc = fat_idx_create(&fidx, service_id);
    435435                if (rc != EOK) {
    436436                        fibril_mutex_unlock(&used_lock);
    … …  
    439439               
    440440                unsigned long ikey[] = {
    441                         [UIH_DH_KEY] = devmap_handle,
     441                        [UIH_DH_KEY] = service_id,
    442442                        [UIH_INDEX_KEY] = fidx->index,
    443443                };
    … …  
    458458{
    459459        unsigned long pkey[] = {
    460                 [UPH_DH_KEY] = idx->devmap_handle,
     460                [UPH_DH_KEY] = idx->service_id,
    461461                [UPH_PFC_KEY] = idx->pfc,
    462462                [UPH_PDI_KEY] = idx->pdi,
    … …  
    471471{
    472472        unsigned long pkey[] = {
    473                 [UPH_DH_KEY] = idx->devmap_handle,
     473                [UPH_DH_KEY] = idx->service_id,
    474474                [UPH_PFC_KEY] = idx->pfc,
    475475                [UPH_PDI_KEY] = idx->pdi,
    … …  
    482482
    483483fat_idx_t *
    484 fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index)
     484fat_idx_get_by_index(service_id_t service_id, fs_index_t index)
    485485{
    486486        fat_idx_t *fidx = NULL;
    487487        link_t *l;
    488488        unsigned long ikey[] = {
    489                 [UIH_DH_KEY] = devmap_handle,
     489                [UIH_DH_KEY] = service_id,
    490490                [UIH_INDEX_KEY] = index,
    491491        };
    … …  
    509509{
    510510        unsigned long ikey[] = {
    511                 [UIH_DH_KEY] = idx->devmap_handle,
     511                [UIH_DH_KEY] = idx->service_id,
    512512                [UIH_INDEX_KEY] = idx->index,
    513513        };
    514         devmap_handle_t devmap_handle = idx->devmap_handle;
     514        service_id_t service_id = idx->service_id;
    515515        fs_index_t index = idx->index;
    516516
    … …  
    526526        fibril_mutex_unlock(&used_lock);
    527527        /* Release the VFS index. */
    528         fat_index_free(devmap_handle, index);
     528        fat_index_free(service_id, index);
    529529        /* The index structure itself is freed in idx_remove_callback(). */
    530530}
    … …  
    548548}
    549549
    550 int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle)
     550int fat_idx_init_by_service_id(service_id_t service_id)
    551551{
    552552        unused_t *u;
    … …  
    556556        if (!u)
    557557                return ENOMEM;
    558         unused_initialize(u, devmap_handle);
     558        unused_initialize(u, service_id);
    559559        fibril_mutex_lock(&unused_lock);
    560         if (!unused_find(devmap_handle, false)) {
     560        if (!unused_find(service_id, false)) {
    561561                list_append(&u->link, &unused_list);
    562562        } else {
    … …  
    568568}
    569569
    570 void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     570void fat_idx_fini_by_service_id(service_id_t service_id)
    571571{
    572572        unsigned long ikey[] = {
    573                 [UIH_DH_KEY] = devmap_handle
     573                [UIH_DH_KEY] = service_id
    574574        };
    575575        unsigned long pkey[] = {
    576                 [UPH_DH_KEY] = devmap_handle
     576                [UPH_DH_KEY] = service_id
    577577        };
    578578
    … …  
    590590         * Free the unused and freed structures for this instance.
    591591         */
    592         unused_t *u = unused_find(devmap_handle, true);
     592        unused_t *u = unused_find(service_id, true);
    593593        assert(u);
    594594        list_remove(&u->link);

  • uspace/srv/fs/fat/fat_ops.c

    ref09a7a r15f3c3f  
    4343#include <libblock.h>
    4444#include <ipc/services.h>
    45 #include <ipc/devmap.h>
     45#include <ipc/loc.h>
    4646#include <macros.h>
    4747#include <async.h>
    … …  
    7272 * Forward declarations of FAT libfs operations.
    7373 */
    74 static int fat_root_get(fs_node_t **, devmap_handle_t);
     74static int fat_root_get(fs_node_t **, service_id_t);
    7575static int fat_match(fs_node_t **, fs_node_t *, const char *);
    76 static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     76static int fat_node_get(fs_node_t **, service_id_t, fs_index_t);
    7777static int fat_node_open(fs_node_t *);
    7878static int fat_node_put(fs_node_t *);
    79 static int fat_create_node(fs_node_t **, devmap_handle_t, int);
     79static int fat_create_node(fs_node_t **, service_id_t, int);
    8080static int fat_destroy_node(fs_node_t *);
    8181static int fat_link(fs_node_t *, fs_node_t *, const char *);
    … …  
    8888static bool fat_is_directory(fs_node_t *);
    8989static bool fat_is_file(fs_node_t *node);
    90 static devmap_handle_t fat_device_get(fs_node_t *node);
     90static service_id_t fat_device_get(fs_node_t *node);
    9191
    9292/*
    … …  
    120120        assert(node->dirty);
    121121
    122         bs = block_bb_get(node->idx->devmap_handle);
     122        bs = block_bb_get(node->idx->service_id);
    123123       
    124124        /* Read the block that contains the dentry of interest. */
    125         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
     125        rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
    126126            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    127127            BLOCK_FLAGS_NONE);
    … …  
    145145}
    146146
    147 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     147static int fat_node_fini_by_service_id(service_id_t service_id)
    148148{
    149149        fat_node_t *nodep;
    … …  
    169169                        goto restart;
    170170                }
    171                 if (nodep->idx->devmap_handle != devmap_handle) {
     171                if (nodep->idx->service_id != service_id) {
    172172                        fibril_mutex_unlock(&nodep->idx->lock);
    173173                        fibril_mutex_unlock(&nodep->lock);
    … …  
    299299                return rc;
    300300
    301         bs = block_bb_get(idxp->devmap_handle);
     301        bs = block_bb_get(idxp->service_id);
    302302
    303303        /* Read the block that contains the dentry of interest. */
    304         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
     304        rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL,
    305305            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    306306        if (rc != EOK) {
    … …  
    323323                 */
    324324                uint16_t clusters;
    325                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     325                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
    326326                    uint16_t_le2host(d->firstc));
    327327                if (rc != EOK) {
    … …  
    357357 */
    358358
    359 int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    360 {
    361         return fat_node_get(rfn, devmap_handle, 0);
     359int fat_root_get(fs_node_t **rfn, service_id_t service_id)
     360{
     361        return fat_node_get(rfn, service_id, 0);
    362362}
    363363
    … …  
    370370        unsigned blocks;
    371371        fat_dentry_t *d;
    372         devmap_handle_t devmap_handle;
     372        service_id_t service_id;
    373373        block_t *b;
    374374        int rc;
    375375
    376376        fibril_mutex_lock(&parentp->idx->lock);
    377         devmap_handle = parentp->idx->devmap_handle;
     377        service_id = parentp->idx->service_id;
    378378        fibril_mutex_unlock(&parentp->idx->lock);
    379379
    380         bs = block_bb_get(devmap_handle);
     380        bs = block_bb_get(service_id);
    381381        blocks = parentp->size / BPS(bs);
    382382        for (i = 0; i < blocks; i++) {
    … …  
    403403                                /* hit */
    404404                                fat_node_t *nodep;
    405                                 fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
     405                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
    406406                                    parentp->firstc, i * DPS(bs) + j);
    407407                                if (!idx) {
    … …  
    436436
    437437/** Instantiate a FAT in-core node. */
    438 int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     438int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    439439{
    440440        fat_node_t *nodep;
    … …  
    442442        int rc;
    443443
    444         idxp = fat_idx_get_by_index(devmap_handle, index);
     444        idxp = fat_idx_get_by_index(service_id, index);
    445445        if (!idxp) {
    446446                *rfn = NULL;
    … …  
    493493}
    494494
    495 int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     495int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    496496{
    497497        fat_idx_t *idxp;
    … …  
    501501        int rc;
    502502
    503         bs = block_bb_get(devmap_handle);
     503        bs = block_bb_get(service_id);
    504504        if (flags & L_DIRECTORY) {
    505505                /* allocate a cluster */
    506                 rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
     506                rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl);
    507507                if (rc != EOK)
    508508                        return rc;
    509509                /* populate the new cluster with unused dentries */
    510                 rc = fat_zero_cluster(bs, devmap_handle, mcl);
     510                rc = fat_zero_cluster(bs, service_id, mcl);
    511511                if (rc != EOK) {
    512                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     512                        (void) fat_free_clusters(bs, service_id, mcl);
    513513                        return rc;
    514514                }
    … …  
    517517        rc = fat_node_get_new(&nodep);
    518518        if (rc != EOK) {
    519                 (void) fat_free_clusters(bs, devmap_handle, mcl);
     519                (void) fat_free_clusters(bs, service_id, mcl);
    520520                return rc;
    521521        }
    522         rc = fat_idx_get_new(&idxp, devmap_handle);
    523         if (rc != EOK) {
    524                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     522        rc = fat_idx_get_new(&idxp, service_id);
     523        if (rc != EOK) {
     524                (void) fat_free_clusters(bs, service_id, mcl); 
    525525                (void) fat_node_put(FS_NODE(nodep));
    526526                return rc;
    … …  
    571571        assert(!has_children);
    572572
    573         bs = block_bb_get(nodep->idx->devmap_handle);
     573        bs = block_bb_get(nodep->idx->service_id);
    574574        if (nodep->firstc != FAT_CLST_RES0) {
    575575                assert(nodep->size);
    576576                /* Free all clusters allocated to the node. */
    577                 rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
     577                rc = fat_free_clusters(bs, nodep->idx->service_id,
    578578                    nodep->firstc);
    579579        }
    … …  
    621621       
    622622        fibril_mutex_lock(&parentp->idx->lock);
    623         bs = block_bb_get(parentp->idx->devmap_handle);
     623        bs = block_bb_get(parentp->idx->service_id);
    624624
    625625        blocks = parentp->size / BPS(bs);
    … …  
    660660                return ENOSPC;
    661661        }
    662         rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
     662        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl);
    663663        if (rc != EOK) {
    664664                fibril_mutex_unlock(&parentp->idx->lock);
    665665                return rc;
    666666        }
    667         rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
    668         if (rc != EOK) {
    669                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     667        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
     668        if (rc != EOK) {
     669                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    670670                fibril_mutex_unlock(&parentp->idx->lock);
    671671                return rc;
    … …  
    673673        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    674674        if (rc != EOK) {
    675                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     675                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    676676                fibril_mutex_unlock(&parentp->idx->lock);
    677677                return rc;
    … …  
    790790        assert(childp->lnkcnt == 1);
    791791        fibril_mutex_lock(&childp->idx->lock);
    792         bs = block_bb_get(childp->idx->devmap_handle);
    793 
    794         rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
     792        bs = block_bb_get(childp->idx->service_id);
     793
     794        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
    795795            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    796796            BLOCK_FLAGS_NONE);
    … …  
    842842       
    843843        fibril_mutex_lock(&nodep->idx->lock);
    844         bs = block_bb_get(nodep->idx->devmap_handle);
     844        bs = block_bb_get(nodep->idx->service_id);
    845845
    846846        blocks = nodep->size / BPS(bs);
    … …  
    916916}
    917917
    918 devmap_handle_t fat_device_get(fs_node_t *node)
     918service_id_t fat_device_get(fs_node_t *node)
    919919{
    920920        return 0;
    … …  
    948948void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    949949{
    950         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     950        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    951951        enum cache_mode cmode;
    952952        fat_bs_t *bs;
    … …  
    970970
    971971        /* initialize libblock */
    972         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     972        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
    973973        if (rc != EOK) {
    974974                async_answer_0(rid, rc);
    … …  
    977977
    978978        /* prepare the boot block */
    979         rc = block_bb_read(devmap_handle, BS_BLOCK);
    980         if (rc != EOK) {
    981                 block_fini(devmap_handle);
     979        rc = block_bb_read(service_id, BS_BLOCK);
     980        if (rc != EOK) {
     981                block_fini(service_id);
    982982                async_answer_0(rid, rc);
    983983                return;
    … …  
    985985
    986986        /* get the buffer with the boot sector */
    987         bs = block_bb_get(devmap_handle);
     987        bs = block_bb_get(service_id);
    988988       
    989989        if (BPS(bs) != BS_SIZE) {
    990                 block_fini(devmap_handle);
     990                block_fini(service_id);
    991991                async_answer_0(rid, ENOTSUP);
    992992                return;
    … …  
    994994
    995995        /* Initialize the block cache */
    996         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
    997         if (rc != EOK) {
    998                 block_fini(devmap_handle);
     996        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
     997        if (rc != EOK) {
     998                block_fini(service_id);
    999999                async_answer_0(rid, rc);
    10001000                return;
    … …  
    10021002
    10031003        /* Do some simple sanity checks on the file system. */
    1004         rc = fat_sanity_check(bs, devmap_handle);
    1005         if (rc != EOK) {
    1006                 (void) block_cache_fini(devmap_handle);
    1007                 block_fini(devmap_handle);
     1004        rc = fat_sanity_check(bs, service_id);
     1005        if (rc != EOK) {
     1006                (void) block_cache_fini(service_id);
     1007                block_fini(service_id);
    10081008                async_answer_0(rid, rc);
    10091009                return;
    10101010        }
    10111011
    1012         rc = fat_idx_init_by_devmap_handle(devmap_handle);
    1013         if (rc != EOK) {
    1014                 (void) block_cache_fini(devmap_handle);
    1015                 block_fini(devmap_handle);
     1012        rc = fat_idx_init_by_service_id(service_id);
     1013        if (rc != EOK) {
     1014                (void) block_cache_fini(service_id);
     1015                block_fini(service_id);
    10161016                async_answer_0(rid, rc);
    10171017                return;
    … …  
    10211021        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    10221022        if (!rfn) {
    1023                 (void) block_cache_fini(devmap_handle);
    1024                 block_fini(devmap_handle);
    1025                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1023                (void) block_cache_fini(service_id);
     1024                block_fini(service_id);
     1025                fat_idx_fini_by_service_id(service_id);
    10261026                async_answer_0(rid, ENOMEM);
    10271027                return;
    … …  
    10311031        if (!rootp) {
    10321032                free(rfn);
    1033                 (void) block_cache_fini(devmap_handle);
    1034                 block_fini(devmap_handle);
    1035                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1033                (void) block_cache_fini(service_id);
     1034                block_fini(service_id);
     1035                fat_idx_fini_by_service_id(service_id);
    10361036                async_answer_0(rid, ENOMEM);
    10371037                return;
    … …  
    10391039        fat_node_initialize(rootp);
    10401040
    1041         fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
     1041        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
    10421042        if (!ridxp) {
    10431043                free(rfn);
    10441044                free(rootp);
    1045                 (void) block_cache_fini(devmap_handle);
    1046                 block_fini(devmap_handle);
    1047                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1045                (void) block_cache_fini(service_id);
     1046                block_fini(service_id);
     1047                fat_idx_fini_by_service_id(service_id);
    10481048                async_answer_0(rid, ENOMEM);
    10491049                return;
    … …  
    10741074void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    10751075{
    1076         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1076        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    10771077        fs_node_t *fn;
    10781078        fat_node_t *nodep;
    10791079        int rc;
    10801080
    1081         rc = fat_root_get(&fn, devmap_handle);
     1081        rc = fat_root_get(&fn, service_id);
    10821082        if (rc != EOK) {
    10831083                async_answer_0(rid, rc);
    … …  
    11071107         * stop using libblock for this instance.
    11081108         */
    1109         (void) fat_node_fini_by_devmap_handle(devmap_handle);
    1110         fat_idx_fini_by_devmap_handle(devmap_handle);
    1111         (void) block_cache_fini(devmap_handle);
    1112         block_fini(devmap_handle);
     1109        (void) fat_node_fini_by_service_id(service_id);
     1110        fat_idx_fini_by_service_id(service_id);
     1111        (void) block_cache_fini(service_id);
     1112        block_fini(service_id);
    11131113
    11141114        async_answer_0(rid, EOK);
    … …  
    11271127void fat_read(ipc_callid_t rid, ipc_call_t *request)
    11281128{
    1129         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1129        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    11301130        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    11311131        aoff64_t pos =
    … …  
    11381138        int rc;
    11391139
    1140         rc = fat_node_get(&fn, devmap_handle, index);
     1140        rc = fat_node_get(&fn, service_id, index);
    11411141        if (rc != EOK) {
    11421142                async_answer_0(rid, rc);
    … …  
    11581158        }
    11591159
    1160         bs = block_bb_get(devmap_handle);
     1160        bs = block_bb_get(service_id);
    11611161
    11621162        if (nodep->type == FAT_FILE) {
    … …  
    12641264void fat_write(ipc_callid_t rid, ipc_call_t *request)
    12651265{
    1266         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1266        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    12671267        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    12681268        aoff64_t pos =
    … …  
    12771277        int rc;
    12781278       
    1279         rc = fat_node_get(&fn, devmap_handle, index);
     1279        rc = fat_node_get(&fn, service_id, index);
    12801280        if (rc != EOK) {
    12811281                async_answer_0(rid, rc);
    … …  
    12971297        }
    12981298
    1299         bs = block_bb_get(devmap_handle);
     1299        bs = block_bb_get(service_id);
    13001300
    13011301        /*
    … …  
    13591359                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13601360                /* create an independent chain of nclsts clusters in all FATs */
    1361                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1361                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
    13621362                if (rc != EOK) {
    13631363                        /* could not allocate a chain of nclsts clusters */
    … …  
    13701370                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13711371                if (rc != EOK) {
    1372                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1372                        (void) fat_free_clusters(bs, service_id, mcl);
    13731373                        (void) fat_node_put(fn);
    13741374                        async_answer_0(callid, rc);
    … …  
    13761376                        return;
    13771377                }
    1378                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1378                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    13791379                    (pos / BPS(bs)) % SPC(bs), flags);
    13801380                if (rc != EOK) {
    1381                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1381                        (void) fat_free_clusters(bs, service_id, mcl);
    13821382                        (void) fat_node_put(fn);
    13831383                        async_answer_0(callid, rc);
    … …  
    13901390                rc = block_put(b);
    13911391                if (rc != EOK) {
    1392                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1392                        (void) fat_free_clusters(bs, service_id, mcl);
    13931393                        (void) fat_node_put(fn);
    13941394                        async_answer_0(rid, rc);
    … …  
    14011401                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14021402                if (rc != EOK) {
    1403                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1403                        (void) fat_free_clusters(bs, service_id, mcl);
    14041404                        (void) fat_node_put(fn);
    14051405                        async_answer_0(rid, rc);
    … …  
    14161416void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    14171417{
    1418         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1418        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    14191419        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    14201420        aoff64_t size =
    … …  
    14251425        int rc;
    14261426
    1427         rc = fat_node_get(&fn, devmap_handle, index);
     1427        rc = fat_node_get(&fn, service_id, index);
    14281428        if (rc != EOK) {
    14291429                async_answer_0(rid, rc);
    … …  
    14361436        nodep = FAT_NODE(fn);
    14371437
    1438         bs = block_bb_get(devmap_handle);
     1438        bs = block_bb_get(service_id);
    14391439
    14401440        if (nodep->size == size) {
    … …  
    14631463                } else {
    14641464                        fat_cluster_t lastc;
    1465                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1465                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    14661466                            &lastc, NULL, (size - 1) / BPC(bs));
    14671467                        if (rc != EOK)
    … …  
    14881488void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    14891489{
    1490         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     1490        service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    14911491        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14921492        fs_node_t *fn;
    … …  
    14941494        int rc;
    14951495
    1496         rc = fat_node_get(&fn, devmap_handle, index);
     1496        rc = fat_node_get(&fn, service_id, index);
    14971497        if (rc != EOK) {
    14981498                async_answer_0(rid, rc);
    … …  
    15271527void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    15281528{
    1529         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1529        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    15301530        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    15311531       
    15321532        fs_node_t *fn;
    1533         int rc = fat_node_get(&fn, devmap_handle, index);
     1533        int rc = fat_node_get(&fn, service_id, index);
    15341534        if (rc != EOK) {
    15351535                async_answer_0(rid, rc);

  • uspace/srv/fs/locfs/Makefile

    ref09a7a r15f3c3f  
    3131LIBS = $(LIBFS_PREFIX)/libfs.a
    3232EXTRA_CFLAGS += -I$(LIBFS_PREFIX)
    33 BINARY = devfs
     33BINARY = locfs
    3434STATIC_NEEDED = y
    3535
    3636SOURCES = \
    37         devfs.c \
    38         devfs_ops.c
     37        locfs.c \
     38        locfs_ops.c
    3939
    4040include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/fs/locfs/locfs.c

    ref09a7a r15f3c3f  
    3232
    3333/**
    34  * @file devfs.c
    35  * @brief Devices file system.
     34 * @file locfs.c
     35 * @brief Location-service file system.
    3636 *
    37  * Every device registered to device mapper is represented as a file in this
     37 * Every service registered with location service is represented as a file in this
    3838 * file system.
    3939 */
    … …  
    4646#include <task.h>
    4747#include <libfs.h>
    48 #include "devfs.h"
    49 #include "devfs_ops.h"
     48#include "locfs.h"
     49#include "locfs_ops.h"
    5050
    51 #define NAME  "devfs"
     51#define NAME  "locfs"
    5252
    53 static vfs_info_t devfs_vfs_info = {
     53static vfs_info_t locfs_vfs_info = {
    5454        .name = NAME,
    5555        .concurrent_read_write = false,
    … …  
    5757};
    5858
    59 fs_reg_t devfs_reg;
     59fs_reg_t locfs_reg;
    6060
    61 static void devfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     61static void locfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    6262{
    6363        if (iid)
    … …  
    7373                switch (IPC_GET_IMETHOD(call)) {
    7474                case VFS_OUT_MOUNTED:
    75                         devfs_mounted(callid, &call);
     75                        locfs_mounted(callid, &call);
    7676                        break;
    7777                case VFS_OUT_MOUNT:
    78                         devfs_mount(callid, &call);
     78                        locfs_mount(callid, &call);
    7979                        break;
    8080                case VFS_OUT_UNMOUNTED:
    81                         devfs_unmounted(callid, &call);
     81                        locfs_unmounted(callid, &call);
    8282                        break;
    8383                case VFS_OUT_UNMOUNT:
    84                         devfs_unmount(callid, &call);
     84                        locfs_unmount(callid, &call);
    8585                        break;
    8686                case VFS_OUT_LOOKUP:
    87                         devfs_lookup(callid, &call);
     87                        locfs_lookup(callid, &call);
    8888                        break;
    8989                case VFS_OUT_OPEN_NODE:
    90                         devfs_open_node(callid, &call);
     90                        locfs_open_node(callid, &call);
    9191                        break;
    9292                case VFS_OUT_STAT:
    93                         devfs_stat(callid, &call);
     93                        locfs_stat(callid, &call);
    9494                        break;
    9595                case VFS_OUT_READ:
    96                         devfs_read(callid, &call);
     96                        locfs_read(callid, &call);
    9797                        break;
    9898                case VFS_OUT_WRITE:
    99                         devfs_write(callid, &call);
     99                        locfs_write(callid, &call);
    100100                        break;
    101101                case VFS_OUT_TRUNCATE:
    102                         devfs_truncate(callid, &call);
     102                        locfs_truncate(callid, &call);
    103103                        break;
    104104                case VFS_OUT_CLOSE:
    105                         devfs_close(callid, &call);
     105                        locfs_close(callid, &call);
    106106                        break;
    107107                case VFS_OUT_SYNC:
    108                         devfs_sync(callid, &call);
     108                        locfs_sync(callid, &call);
    109109                        break;
    110110                case VFS_OUT_DESTROY:
    111                         devfs_destroy(callid, &call);
     111                        locfs_destroy(callid, &call);
    112112                        break;
    113113                default:
    … …  
    122122        printf("%s: HelenOS Device Filesystem\n", NAME);
    123123       
    124         if (!devfs_init()) {
    125                 printf("%s: failed to initialize devfs\n", NAME);
     124        if (!locfs_init()) {
     125                printf("%s: failed to initialize locfs\n", NAME);
    126126                return -1;
    127127        }
    … …  
    134134        }
    135135       
    136         int rc = fs_register(vfs_sess, &devfs_reg, &devfs_vfs_info,
    137             devfs_connection);
     136        int rc = fs_register(vfs_sess, &locfs_reg, &locfs_vfs_info,
     137            locfs_connection);
    138138        if (rc != EOK) {
    139139                printf("%s: Failed to register file system (%d)\n", NAME, rc);

  • uspace/srv/fs/locfs/locfs.h

    ref09a7a r15f3c3f  
    3131 */
    3232
    33 #ifndef DEVFS_DEVFS_H_
    34 #define DEVFS_DEVFS_H_
     33#ifndef LOCFS_LOCFS_H_
     34#define LOCFS_LOCFS_H_
    3535
    3636#include <libfs.h>
    3737
    38 extern fs_reg_t devfs_reg;
     38extern fs_reg_t locfs_reg;
    3939
    4040#endif

  • uspace/srv/fs/locfs/locfs_ops.c

    ref09a7a r15f3c3f  
    3232
    3333/**
    34  * @file devfs_ops.c
    35  * @brief Implementation of VFS operations for the devfs file system server.
     34 * @file locfs_ops.c
     35 * @brief Implementation of VFS operations for the locfs file system server.
    3636 */
    3737
    … …  
    4444#include <fibril_synch.h>
    4545#include <adt/hash_table.h>
    46 #include <ipc/devmap.h>
     46#include <ipc/loc.h>
    4747#include <sys/stat.h>
    4848#include <libfs.h>
    4949#include <assert.h>
    50 #include "devfs.h"
    51 #include "devfs_ops.h"
     50#include "locfs.h"
     51#include "locfs_ops.h"
    5252
    5353typedef struct {
    54         devmap_handle_type_t type;
    55         devmap_handle_t handle;
    56 } devfs_node_t;
    57 
    58 /** Opened devices structure */
     54        loc_object_type_t type;
     55        service_id_t service_id;
     56} locfs_node_t;
     57
     58/** Opened services structure */
    5959typedef struct {
    60         devmap_handle_t handle;
     60        service_id_t service_id;
    6161        async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
    6262        size_t refcount;
    6363        link_t link;
    6464        fibril_condvar_t cv;      /**< Broadcast when completed. */
    65 } device_t;
    66 
    67 /** Hash table of opened devices */
    68 static hash_table_t devices;
     65} service_t;
     66
     67/** Hash table of opened services */
     68static hash_table_t services;
    6969
    7070/** Hash table mutex */
    71 static FIBRIL_MUTEX_INITIALIZE(devices_mutex);
    72 
    73 #define DEVICES_KEYS        1
    74 #define DEVICES_KEY_HANDLE  0
    75 #define DEVICES_BUCKETS     256
     71static FIBRIL_MUTEX_INITIALIZE(services_mutex);
     72
     73#define SERVICES_KEYS        1
     74#define SERVICES_KEY_HANDLE  0
     75#define SERVICES_BUCKETS     256
    7676
    7777/* Implementation of hash table interface for the nodes hash table. */
    78 static hash_index_t devices_hash(unsigned long key[])
    79 {
    80         return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS;
    81 }
    82 
    83 static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item)
    84 {
    85         device_t *dev = hash_table_get_instance(item, device_t, link);
    86         return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]);
    87 }
    88 
    89 static void devices_remove_callback(link_t *item)
    90 {
    91         free(hash_table_get_instance(item, device_t, link));
    92 }
    93 
    94 static hash_table_operations_t devices_ops = {
    95         .hash = devices_hash,
    96         .compare = devices_compare,
    97         .remove_callback = devices_remove_callback
     78static hash_index_t services_hash(unsigned long key[])
     79{
     80        return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS;
     81}
     82
     83static int services_compare(unsigned long key[], hash_count_t keys, link_t *item)
     84{
     85        service_t *dev = hash_table_get_instance(item, service_t, link);
     86        return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]);
     87}
     88
     89static void services_remove_callback(link_t *item)
     90{
     91        free(hash_table_get_instance(item, service_t, link));
     92}
     93
     94static hash_table_operations_t services_ops = {
     95        .hash = services_hash,
     96        .compare = services_compare,
     97        .remove_callback = services_remove_callback
    9898};
    9999
    100 static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,
    101     devmap_handle_t handle)
    102 {
    103         devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));
     100static int locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type,
     101    service_id_t service_id)
     102{
     103        locfs_node_t *node = (locfs_node_t *) malloc(sizeof(locfs_node_t));
    104104        if (node == NULL) {
    105105                *rfn = NULL;
    … …  
    116116        fs_node_initialize(*rfn);
    117117        node->type = type;
    118         node->handle = handle;
     118        node->service_id = service_id;
    119119       
    120120        (*rfn)->data = node;
    … …  
    122122}
    123123
    124 static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    125 {
    126         return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);
    127 }
    128 
    129 static int devfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    130 {
    131         devfs_node_t *node = (devfs_node_t *) pfn->data;
     124static int locfs_root_get(fs_node_t **rfn, service_id_t service_id)
     125{
     126        return locfs_node_get_internal(rfn, LOC_OBJECT_NONE, 0);
     127}
     128
     129static int locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     130{
     131        locfs_node_t *node = (locfs_node_t *) pfn->data;
    132132        int ret;
    133133       
    134         if (node->handle == 0) {
     134        if (node->service_id == 0) {
    135135                /* Root directory */
    136136               
    137                 dev_desc_t *devs;
    138                 size_t count = devmap_get_namespaces(&devs);
     137                loc_sdesc_t *nspaces;
     138                size_t count = loc_get_namespaces(&nspaces);
    139139               
    140140                if (count > 0) {
    … …  
    142142                        for (pos = 0; pos < count; pos++) {
    143143                                /* Ignore root namespace */
    144                                 if (str_cmp(devs[pos].name, "") == 0)
     144                                if (str_cmp(nspaces[pos].name, "") == 0)
    145145                                        continue;
    146146                               
    147                                 if (str_cmp(devs[pos].name, component) == 0) {
    148                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    149                                         free(devs);
     147                                if (str_cmp(nspaces[pos].name, component) == 0) {
     148                                        ret = locfs_node_get_internal(rfn, LOC_OBJECT_NAMESPACE, nspaces[pos].id);
     149                                        free(nspaces);
    150150                                        return ret;
    151151                                }
    152152                        }
    153153                       
    154                         free(devs);
     154                        free(nspaces);
    155155                }
    156156               
    157157                /* Search root namespace */
    158                 devmap_handle_t namespace;
    159                 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    160                         count = devmap_get_devices(namespace, &devs);
     158                service_id_t namespace;
     159                loc_sdesc_t *svcs;
     160                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
     161                        count = loc_get_services(namespace, &svcs);
    161162                       
    162163                        if (count > 0) {
    163164                                size_t pos;
    164165                                for (pos = 0; pos < count; pos++) {
    165                                         if (str_cmp(devs[pos].name, component) == 0) {
    166                                                 ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    167                                                 free(devs);
     166                                        if (str_cmp(svcs[pos].name, component) == 0) {
     167                                                ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id);
     168                                                free(svcs);
    168169                                                return ret;
    169170                                        }
    170171                                }
    171172                               
    172                                 free(devs);
     173                                free(svcs);
    173174                        }
    174175                }
    … …  
    178179        }
    179180       
    180         if (node->type == DEV_HANDLE_NAMESPACE) {
     181        if (node->type == LOC_OBJECT_NAMESPACE) {
    181182                /* Namespace directory */
    182183               
    183                 dev_desc_t *devs;
    184                 size_t count = devmap_get_devices(node->handle, &devs);
     184                loc_sdesc_t *svcs;
     185                size_t count = loc_get_services(node->service_id, &svcs);
    185186                if (count > 0) {
    186187                        size_t pos;
    187188                        for (pos = 0; pos < count; pos++) {
    188                                 if (str_cmp(devs[pos].name, component) == 0) {
    189                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    190                                         free(devs);
     189                                if (str_cmp(svcs[pos].name, component) == 0) {
     190                                        ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id);
     191                                        free(svcs);
    191192                                        return ret;
    192193                                }
    193194                        }
    194195                       
    195                         free(devs);
     196                        free(svcs);
    196197                }
    197198               
    … …  
    204205}
    205206
    206 static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    207 {
    208         return devfs_node_get_internal(rfn, devmap_handle_probe(index), index);
    209 }
    210 
    211 static int devfs_node_open(fs_node_t *fn)
    212 {
    213         devfs_node_t *node = (devfs_node_t *) fn->data;
    214        
    215         if (node->handle == 0) {
     207static int locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     208{
     209        return locfs_node_get_internal(rfn, loc_id_probe(index), index);
     210}
     211
     212static int locfs_node_open(fs_node_t *fn)
     213{
     214        locfs_node_t *node = (locfs_node_t *) fn->data;
     215       
     216        if (node->service_id == 0) {
    216217                /* Root directory */
    217218                return EOK;
    218219        }
    219220       
    220         devmap_handle_type_t type = devmap_handle_probe(node->handle);
    221        
    222         if (type == DEV_HANDLE_NAMESPACE) {
     221        loc_object_type_t type = loc_id_probe(node->service_id);
     222       
     223        if (type == LOC_OBJECT_NAMESPACE) {
    223224                /* Namespace directory */
    224225                return EOK;
    225226        }
    226227       
    227         if (type == DEV_HANDLE_DEVICE) {
     228        if (type == LOC_OBJECT_SERVICE) {
    228229                /* Device node */
    229230               
    230231                unsigned long key[] = {
    231                         [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
     232                        [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id
    232233                };
    233234                link_t *lnk;
    234235               
    235                 fibril_mutex_lock(&devices_mutex);
     236                fibril_mutex_lock(&services_mutex);
    236237restart:
    237                 lnk = hash_table_find(&devices, key);
     238                lnk = hash_table_find(&services, key);
    238239                if (lnk == NULL) {
    239                         device_t *dev = (device_t *) malloc(sizeof(device_t));
     240                        service_t *dev = (service_t *) malloc(sizeof(service_t));
    240241                        if (dev == NULL) {
    241                                 fibril_mutex_unlock(&devices_mutex);
     242                                fibril_mutex_unlock(&services_mutex);
    242243                                return ENOMEM;
    243244                        }
    244245                       
    245                         dev->handle = node->handle;
     246                        dev->service_id = node->service_id;
    246247                       
    247248                        /* Mark as incomplete */
    … …  
    255256                         * below.
    256257                         */
    257                         hash_table_insert(&devices, key, &dev->link);
     258                        hash_table_insert(&services, key, &dev->link);
    258259                       
    259260                        /*
    260                          * Drop the mutex to allow recursive devfs requests.
     261                         * Drop the mutex to allow recursive locfs requests.
    261262                         */
    262                         fibril_mutex_unlock(&devices_mutex);
    263                        
    264                         async_sess_t *sess = devmap_device_connect(EXCHANGE_SERIALIZE,
    265                             node->handle, 0);
    266                        
    267                         fibril_mutex_lock(&devices_mutex);
     263                        fibril_mutex_unlock(&services_mutex);
     264                       
     265                        async_sess_t *sess = loc_service_connect(
     266                            EXCHANGE_SERIALIZE, node->service_id, 0);
     267                       
     268                        fibril_mutex_lock(&services_mutex);
    268269                       
    269270                        /*
    … …  
    278279                                 * entry and free the device structure.
    279280                                 */
    280                                 hash_table_remove(&devices, key, DEVICES_KEYS);
    281                                 fibril_mutex_unlock(&devices_mutex);
     281                                hash_table_remove(&services, key, SERVICES_KEYS);
     282                                fibril_mutex_unlock(&services_mutex);
    282283                               
    283284                                return ENOENT;
    … …  
    287288                        dev->sess = sess;
    288289                } else {
    289                         device_t *dev = hash_table_get_instance(lnk, device_t, link);
     290                        service_t *dev = hash_table_get_instance(lnk, service_t, link);
    290291                       
    291292                        if (!dev->sess) {
    … …  
    297298                                 * fibril_condvar_wait().
    298299                                 */
    299                                 fibril_condvar_wait(&dev->cv, &devices_mutex);
     300                                fibril_condvar_wait(&dev->cv, &services_mutex);
    300301                                goto restart;
    301302                        }
    … …  
    304305                }
    305306               
    306                 fibril_mutex_unlock(&devices_mutex);
     307                fibril_mutex_unlock(&services_mutex);
    307308               
    308309                return EOK;
    … …  
    312313}
    313314
    314 static int devfs_node_put(fs_node_t *fn)
     315static int locfs_node_put(fs_node_t *fn)
    315316{
    316317        free(fn->data);
    … …  
    319320}
    320321
    321 static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
     322static int locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
    322323{
    323324        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    … …  
    327328}
    328329
    329 static int devfs_destroy_node(fs_node_t *fn)
     330static int locfs_destroy_node(fs_node_t *fn)
    330331{
    331332        return ENOTSUP;
    332333}
    333334
    334 static int devfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     335static int locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    335336{
    336337        return ENOTSUP;
    337338}
    338339
    339 static int devfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     340static int locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    340341{
    341342        return ENOTSUP;
    342343}
    343344
    344 static int devfs_has_children(bool *has_children, fs_node_t *fn)
    345 {
    346         devfs_node_t *node = (devfs_node_t *) fn->data;
    347        
    348         if (node->handle == 0) {
    349                 size_t count = devmap_count_namespaces();
     345static int locfs_has_children(bool *has_children, fs_node_t *fn)
     346{
     347        locfs_node_t *node = (locfs_node_t *) fn->data;
     348       
     349        if (node->service_id == 0) {
     350                size_t count = loc_count_namespaces();
    350351                if (count > 0) {
    351352                        *has_children = true;
    … …  
    354355               
    355356                /* Root namespace */
    356                 devmap_handle_t namespace;
    357                 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    358                         count = devmap_count_devices(namespace);
     357                service_id_t namespace;
     358                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
     359                        count = loc_count_services(namespace);
    359360                        if (count > 0) {
    360361                                *has_children = true;
    … …  
    367368        }
    368369       
    369         if (node->type == DEV_HANDLE_NAMESPACE) {
    370                 size_t count = devmap_count_devices(node->handle);
     370        if (node->type == LOC_OBJECT_NAMESPACE) {
     371                size_t count = loc_count_services(node->service_id);
    371372                if (count > 0) {
    372373                        *has_children = true;
    … …  
    382383}
    383384
    384 static fs_index_t devfs_index_get(fs_node_t *fn)
    385 {
    386         devfs_node_t *node = (devfs_node_t *) fn->data;
    387         return node->handle;
    388 }
    389 
    390 static aoff64_t devfs_size_get(fs_node_t *fn)
     385static fs_index_t locfs_index_get(fs_node_t *fn)
     386{
     387        locfs_node_t *node = (locfs_node_t *) fn->data;
     388        return node->service_id;
     389}
     390
     391static aoff64_t locfs_size_get(fs_node_t *fn)
    391392{
    392393        return 0;
    393394}
    394395
    395 static unsigned int devfs_lnkcnt_get(fs_node_t *fn)
    396 {
    397         devfs_node_t *node = (devfs_node_t *) fn->data;
    398        
    399         if (node->handle == 0)
     396static unsigned int locfs_lnkcnt_get(fs_node_t *fn)
     397{
     398        locfs_node_t *node = (locfs_node_t *) fn->data;
     399       
     400        if (node->service_id == 0)
    400401                return 0;
    401402       
    … …  
    403404}
    404405
    405 static char devfs_plb_get_char(unsigned pos)
    406 {
    407         return devfs_reg.plb_ro[pos % PLB_SIZE];
    408 }
    409 
    410 static bool devfs_is_directory(fs_node_t *fn)
    411 {
    412         devfs_node_t *node = (devfs_node_t *) fn->data;
    413        
    414         return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE));
    415 }
    416 
    417 static bool devfs_is_file(fs_node_t *fn)
    418 {
    419         devfs_node_t *node = (devfs_node_t *) fn->data;
    420        
    421         return (node->type == DEV_HANDLE_DEVICE);
    422 }
    423 
    424 static devmap_handle_t devfs_device_get(fs_node_t *fn)
    425 {
    426         devfs_node_t *node = (devfs_node_t *) fn->data;
    427        
    428         if (node->type == DEV_HANDLE_DEVICE)
    429                 return node->handle;
     406static char locfs_plb_get_char(unsigned pos)
     407{
     408        return locfs_reg.plb_ro[pos % PLB_SIZE];
     409}
     410
     411static bool locfs_is_directory(fs_node_t *fn)
     412{
     413        locfs_node_t *node = (locfs_node_t *) fn->data;
     414       
     415        return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE));
     416}
     417
     418static bool locfs_is_file(fs_node_t *fn)
     419{
     420        locfs_node_t *node = (locfs_node_t *) fn->data;
     421       
     422        return (node->type == LOC_OBJECT_SERVICE);
     423}
     424
     425static service_id_t locfs_device_get(fs_node_t *fn)
     426{
     427        locfs_node_t *node = (locfs_node_t *) fn->data;
     428       
     429        if (node->type == LOC_OBJECT_SERVICE)
     430                return node->service_id;
    430431       
    431432        return 0;
    … …  
    433434
    434435/** libfs operations */
    435 libfs_ops_t devfs_libfs_ops = {
    436         .root_get = devfs_root_get,
    437         .match = devfs_match,
    438         .node_get = devfs_node_get,
    439         .node_open = devfs_node_open,
    440         .node_put = devfs_node_put,
    441         .create = devfs_create_node,
    442         .destroy = devfs_destroy_node,
    443         .link = devfs_link_node,
    444         .unlink = devfs_unlink_node,
    445         .has_children = devfs_has_children,
    446         .index_get = devfs_index_get,
    447         .size_get = devfs_size_get,
    448         .lnkcnt_get = devfs_lnkcnt_get,
    449         .plb_get_char = devfs_plb_get_char,
    450         .is_directory = devfs_is_directory,
    451         .is_file = devfs_is_file,
    452         .device_get = devfs_device_get
     436libfs_ops_t locfs_libfs_ops = {
     437        .root_get = locfs_root_get,
     438        .match = locfs_match,
     439        .node_get = locfs_node_get,
     440        .node_open = locfs_node_open,
     441        .node_put = locfs_node_put,
     442        .create = locfs_create_node,
     443        .destroy = locfs_destroy_node,
     444        .link = locfs_link_node,
     445        .unlink = locfs_unlink_node,
     446        .has_children = locfs_has_children,
     447        .index_get = locfs_index_get,
     448        .size_get = locfs_size_get,
     449        .lnkcnt_get = locfs_lnkcnt_get,
     450        .plb_get_char = locfs_plb_get_char,
     451        .is_directory = locfs_is_directory,
     452        .is_file = locfs_is_file,
     453        .device_get = locfs_device_get
    453454};
    454455
    455 bool devfs_init(void)
    456 {
    457         if (!hash_table_create(&devices, DEVICES_BUCKETS,
    458             DEVICES_KEYS, &devices_ops))
     456bool locfs_init(void)
     457{
     458        if (!hash_table_create(&services, SERVICES_BUCKETS,
     459            SERVICES_KEYS, &services_ops))
    459460                return false;
    460461       
    … …  
    462463}
    463464
    464 void devfs_mounted(ipc_callid_t rid, ipc_call_t *request)
     465void locfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    465466{
    466467        char *opts;
    … …  
    478479}
    479480
    480 void devfs_mount(ipc_callid_t rid, ipc_call_t *request)
    481 {
    482         libfs_mount(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
    483 }
    484 
    485 void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
     481void locfs_mount(ipc_callid_t rid, ipc_call_t *request)
     482{
     483        libfs_mount(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
     484}
     485
     486void locfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    486487{
    487488        async_answer_0(rid, ENOTSUP);
    488489}
    489490
    490 void devfs_unmount(ipc_callid_t rid, ipc_call_t *request)
    491 {
    492         libfs_unmount(&devfs_libfs_ops, rid, request);
    493 }
    494 
    495 void devfs_lookup(ipc_callid_t rid, ipc_call_t *request)
    496 {
    497         libfs_lookup(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
    498 }
    499 
    500 void devfs_open_node(ipc_callid_t rid, ipc_call_t *request)
    501 {
    502         libfs_open_node(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
    503 }
    504 
    505 void devfs_stat(ipc_callid_t rid, ipc_call_t *request)
    506 {
    507         libfs_stat(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
    508 }
    509 
    510 void devfs_read(ipc_callid_t rid, ipc_call_t *request)
     491void locfs_unmount(ipc_callid_t rid, ipc_call_t *request)
     492{
     493        libfs_unmount(&locfs_libfs_ops, rid, request);
     494}
     495
     496void locfs_lookup(ipc_callid_t rid, ipc_call_t *request)
     497{
     498        libfs_lookup(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
     499}
     500
     501void locfs_open_node(ipc_callid_t rid, ipc_call_t *request)
     502{
     503        libfs_open_node(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
     504}
     505
     506void locfs_stat(ipc_callid_t rid, ipc_call_t *request)
     507{
     508        libfs_stat(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
     509}
     510
     511void locfs_read(ipc_callid_t rid, ipc_call_t *request)
    511512{
    512513        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    … …  
    523524                }
    524525               
    525                 dev_desc_t *desc;
    526                 size_t count = devmap_get_namespaces(&desc);
     526                loc_sdesc_t *desc;
     527                size_t count = loc_get_namespaces(&desc);
    527528               
    528529                /* Get rid of root namespace */
    … …  
    548549               
    549550                /* Search root namespace */
    550                 devmap_handle_t namespace;
    551                 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    552                         count = devmap_get_devices(namespace, &desc);
     551                service_id_t namespace;
     552                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
     553                        count = loc_get_services(namespace, &desc);
    553554                       
    554555                        if (pos < count) {
    … …  
    567568        }
    568569       
    569         devmap_handle_type_t type = devmap_handle_probe(index);
    570        
    571         if (type == DEV_HANDLE_NAMESPACE) {
     570        loc_object_type_t type = loc_id_probe(index);
     571       
     572        if (type == LOC_OBJECT_NAMESPACE) {
    572573                /* Namespace directory */
    573574                ipc_callid_t callid;
    … …  
    579580                }
    580581               
    581                 dev_desc_t *desc;
    582                 size_t count = devmap_get_devices(index, &desc);
     582                loc_sdesc_t *desc;
     583                size_t count = loc_get_services(index, &desc);
    583584               
    584585                if (pos < count) {
    … …  
    595596        }
    596597       
    597         if (type == DEV_HANDLE_DEVICE) {
     598        if (type == LOC_OBJECT_SERVICE) {
    598599                /* Device node */
    599600               
    600601                unsigned long key[] = {
    601                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     602                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    602603                };
    603604               
    604                 fibril_mutex_lock(&devices_mutex);
    605                 link_t *lnk = hash_table_find(&devices, key);
     605                fibril_mutex_lock(&services_mutex);
     606                link_t *lnk = hash_table_find(&services, key);
    606607                if (lnk == NULL) {
    607                         fibril_mutex_unlock(&devices_mutex);
     608                        fibril_mutex_unlock(&services_mutex);
    608609                        async_answer_0(rid, ENOENT);
    609610                        return;
    610611                }
    611612               
    612                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     613                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    613614                assert(dev->sess);
    614615               
    615616                ipc_callid_t callid;
    616617                if (!async_data_read_receive(&callid, NULL)) {
    617                         fibril_mutex_unlock(&devices_mutex);
     618                        fibril_mutex_unlock(&services_mutex);
    618619                        async_answer_0(callid, EINVAL);
    619620                        async_answer_0(rid, EINVAL);
    … …  
    634635                async_exchange_end(exch);
    635636               
    636                 fibril_mutex_unlock(&devices_mutex);
     637                fibril_mutex_unlock(&services_mutex);
    637638               
    638639                /* Wait for reply from the driver. */
    … …  
    649650}
    650651
    651 void devfs_write(ipc_callid_t rid, ipc_call_t *request)
     652void locfs_write(ipc_callid_t rid, ipc_call_t *request)
    652653{
    653654        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    … …  
    657658        }
    658659       
    659         devmap_handle_type_t type = devmap_handle_probe(index);
    660        
    661         if (type == DEV_HANDLE_NAMESPACE) {
     660        loc_object_type_t type = loc_id_probe(index);
     661       
     662        if (type == LOC_OBJECT_NAMESPACE) {
    662663                /* Namespace directory */
    663664                async_answer_0(rid, ENOTSUP);
    … …  
    665666        }
    666667       
    667         if (type == DEV_HANDLE_DEVICE) {
     668        if (type == LOC_OBJECT_SERVICE) {
    668669                /* Device node */
    669670                unsigned long key[] = {
    670                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     671                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    671672                };
    672673               
    673                 fibril_mutex_lock(&devices_mutex);
    674                 link_t *lnk = hash_table_find(&devices, key);
     674                fibril_mutex_lock(&services_mutex);
     675                link_t *lnk = hash_table_find(&services, key);
    675676                if (lnk == NULL) {
    676                         fibril_mutex_unlock(&devices_mutex);
     677                        fibril_mutex_unlock(&services_mutex);
    677678                        async_answer_0(rid, ENOENT);
    678679                        return;
    679680                }
    680681               
    681                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     682                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    682683                assert(dev->sess);
    683684               
    684685                ipc_callid_t callid;
    685686                if (!async_data_write_receive(&callid, NULL)) {
    686                         fibril_mutex_unlock(&devices_mutex);
     687                        fibril_mutex_unlock(&services_mutex);
    687688                        async_answer_0(callid, EINVAL);
    688689                        async_answer_0(rid, EINVAL);
    … …  
    703704                async_exchange_end(exch);
    704705               
    705                 fibril_mutex_unlock(&devices_mutex);
     706                fibril_mutex_unlock(&services_mutex);
    706707               
    707708                /* Wait for reply from the driver. */
    … …  
    718719}
    719720
    720 void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
     721void locfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    721722{
    722723        async_answer_0(rid, ENOTSUP);
    723724}
    724725
    725 void devfs_close(ipc_callid_t rid, ipc_call_t *request)
     726void locfs_close(ipc_callid_t rid, ipc_call_t *request)
    726727{
    727728        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    … …  
    732733        }
    733734       
    734         devmap_handle_type_t type = devmap_handle_probe(index);
    735        
    736         if (type == DEV_HANDLE_NAMESPACE) {
     735        loc_object_type_t type = loc_id_probe(index);
     736       
     737        if (type == LOC_OBJECT_NAMESPACE) {
    737738                /* Namespace directory */
    738739                async_answer_0(rid, EOK);
    … …  
    740741        }
    741742       
    742         if (type == DEV_HANDLE_DEVICE) {
     743        if (type == LOC_OBJECT_SERVICE) {
    743744                unsigned long key[] = {
    744                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     745                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    745746                };
    746747               
    747                 fibril_mutex_lock(&devices_mutex);
    748                 link_t *lnk = hash_table_find(&devices, key);
     748                fibril_mutex_lock(&services_mutex);
     749                link_t *lnk = hash_table_find(&services, key);
    749750                if (lnk == NULL) {
    750                         fibril_mutex_unlock(&devices_mutex);
     751                        fibril_mutex_unlock(&services_mutex);
    751752                        async_answer_0(rid, ENOENT);
    752753                        return;
    753754                }
    754755               
    755                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     756                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    756757                assert(dev->sess);
    757758                dev->refcount--;
    … …  
    759760                if (dev->refcount == 0) {
    760761                        async_hangup(dev->sess);
    761                         hash_table_remove(&devices, key, DEVICES_KEYS);
    762                 }
    763                
    764                 fibril_mutex_unlock(&devices_mutex);
     762                        hash_table_remove(&services, key, SERVICES_KEYS);
     763                }
     764               
     765                fibril_mutex_unlock(&services_mutex);
    765766               
    766767                async_answer_0(rid, EOK);
    … …  
    771772}
    772773
    773 void devfs_sync(ipc_callid_t rid, ipc_call_t *request)
     774void locfs_sync(ipc_callid_t rid, ipc_call_t *request)
    774775{
    775776        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    … …  
    780781        }
    781782       
    782         devmap_handle_type_t type = devmap_handle_probe(index);
    783        
    784         if (type == DEV_HANDLE_NAMESPACE) {
     783        loc_object_type_t type = loc_id_probe(index);
     784       
     785        if (type == LOC_OBJECT_NAMESPACE) {
    785786                /* Namespace directory */
    786787                async_answer_0(rid, EOK);
    … …  
    788789        }
    789790       
    790         if (type == DEV_HANDLE_DEVICE) {
     791        if (type == LOC_OBJECT_SERVICE) {
    791792                unsigned long key[] = {
    792                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     793                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    793794                };
    794795               
    795                 fibril_mutex_lock(&devices_mutex);
    796                 link_t *lnk = hash_table_find(&devices, key);
     796                fibril_mutex_lock(&services_mutex);
     797                link_t *lnk = hash_table_find(&services, key);
    797798                if (lnk == NULL) {
    798                         fibril_mutex_unlock(&devices_mutex);
     799                        fibril_mutex_unlock(&services_mutex);
    799800                        async_answer_0(rid, ENOENT);
    800801                        return;
    801802                }
    802803               
    803                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     804                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    804805                assert(dev->sess);
    805806               
    … …  
    813814                async_exchange_end(exch);
    814815               
    815                 fibril_mutex_unlock(&devices_mutex);
     816                fibril_mutex_unlock(&services_mutex);
    816817               
    817818                /* Wait for reply from the driver */
    … …  
    827828}
    828829
    829 void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
     830void locfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    830831{
    831832        async_answer_0(rid, ENOTSUP);

  • uspace/srv/fs/locfs/locfs_ops.h

    ref09a7a r15f3c3f  
    3131 */
    3232
    33 #ifndef DEVFS_DEVFS_OPS_H_
    34 #define DEVFS_DEVFS_OPS_H_
     33#ifndef LOCFS_LOCFS_OPS_H_
     34#define LOCFS_LOCFS_OPS_H_
    3535
    3636#include <ipc/common.h>
    3737#include <bool.h>
    3838
    39 extern bool devfs_init(void);
     39extern bool locfs_init(void);
    4040
    41 extern void devfs_mounted(ipc_callid_t, ipc_call_t *);
    42 extern void devfs_mount(ipc_callid_t, ipc_call_t *);
    43 extern void devfs_unmounted(ipc_callid_t, ipc_call_t *);
    44 extern void devfs_unmount(ipc_callid_t, ipc_call_t *);
    45 extern void devfs_lookup(ipc_callid_t, ipc_call_t *);
    46 extern void devfs_open_node(ipc_callid_t, ipc_call_t *);
    47 extern void devfs_stat(ipc_callid_t, ipc_call_t *);
    48 extern void devfs_sync(ipc_callid_t, ipc_call_t *);
    49 extern void devfs_read(ipc_callid_t, ipc_call_t *);
    50 extern void devfs_write(ipc_callid_t, ipc_call_t *);
    51 extern void devfs_truncate(ipc_callid_t, ipc_call_t *);
    52 extern void devfs_close(ipc_callid_t, ipc_call_t *);
    53 extern void devfs_destroy(ipc_callid_t, ipc_call_t *);
     41extern void locfs_mounted(ipc_callid_t, ipc_call_t *);
     42extern void locfs_mount(ipc_callid_t, ipc_call_t *);
     43extern void locfs_unmounted(ipc_callid_t, ipc_call_t *);
     44extern void locfs_unmount(ipc_callid_t, ipc_call_t *);
     45extern void locfs_lookup(ipc_callid_t, ipc_call_t *);
     46extern void locfs_open_node(ipc_callid_t, ipc_call_t *);
     47extern void locfs_stat(ipc_callid_t, ipc_call_t *);
     48extern void locfs_sync(ipc_callid_t, ipc_call_t *);
     49extern void locfs_read(ipc_callid_t, ipc_call_t *);
     50extern void locfs_write(ipc_callid_t, ipc_call_t *);
     51extern void locfs_truncate(ipc_callid_t, ipc_call_t *);
     52extern void locfs_close(ipc_callid_t, ipc_call_t *);
     53extern void locfs_destroy(ipc_callid_t, ipc_call_t *);
    5454
    5555#endif

  • uspace/srv/fs/tmpfs/tmpfs.h

    ref09a7a r15f3c3f  
    6161        fs_node_t *bp;          /**< Back pointer to the FS node. */
    6262        fs_index_t index;       /**< TMPFS node index. */
    63         devmap_handle_t devmap_handle;/**< Device handle. */
     63        service_id_t service_id;/**< Service ID of block device. */
    6464        link_t nh_link;         /**< Nodes hash table link. */
    6565        tmpfs_dentry_type_t type;
    … …  
    9090extern void tmpfs_sync(ipc_callid_t, ipc_call_t *);
    9191
    92 extern bool tmpfs_restore(devmap_handle_t);
     92extern bool tmpfs_restore(service_id_t);
    9393
    9494#endif

  • uspace/srv/fs/tmpfs/tmpfs_dump.c

    ref09a7a r15f3c3f  
    5555
    5656static bool
    57 tmpfs_restore_recursion(devmap_handle_t dev, size_t *bufpos, size_t *buflen,
     57tmpfs_restore_recursion(service_id_t dsid, size_t *bufpos, size_t *buflen,
    5858    aoff64_t *pos, fs_node_t *pfn)
    5959{
    … …  
    6868                uint32_t size;
    6969               
    70                 if (block_seqread(dev, bufpos, buflen, pos, &entry,
     70                if (block_seqread(dsid, bufpos, buflen, pos, &entry,
    7171                    sizeof(entry)) != EOK)
    7272                        return false;
    … …  
    8282                                return false;
    8383                       
    84                         rc = ops->create(&fn, dev, L_FILE);
     84                        rc = ops->create(&fn, dsid, L_FILE);
    8585                        if (rc != EOK || fn == NULL) {
    8686                                free(fname);
    … …  
    8888                        }
    8989                       
    90                         if (block_seqread(dev, bufpos, buflen, pos, fname,
     90                        if (block_seqread(dsid, bufpos, buflen, pos, fname,
    9191                            entry.len) != EOK) {
    9292                                (void) ops->destroy(fn);
    … …  
    104104                        free(fname);
    105105                       
    106                         if (block_seqread(dev, bufpos, buflen, pos, &size,
     106                        if (block_seqread(dsid, bufpos, buflen, pos, &size,
    107107                            sizeof(size)) != EOK)
    108108                                return false;
    … …  
    116116                       
    117117                        nodep->size = size;
    118                         if (block_seqread(dev, bufpos, buflen, pos, nodep->data,
     118                        if (block_seqread(dsid, bufpos, buflen, pos, nodep->data,
    119119                            size) != EOK)
    120120                                return false;
    … …  
    126126                                return false;
    127127                       
    128                         rc = ops->create(&fn, dev, L_DIRECTORY);
     128                        rc = ops->create(&fn, dsid, L_DIRECTORY);
    129129                        if (rc != EOK || fn == NULL) {
    130130                                free(fname);
    … …  
    132132                        }
    133133                       
    134                         if (block_seqread(dev, bufpos, buflen, pos, fname,
     134                        if (block_seqread(dsid, bufpos, buflen, pos, fname,
    135135                            entry.len) != EOK) {
    136136                                (void) ops->destroy(fn);
    … …  
    148148                        free(fname);
    149149                       
    150                         if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
     150                        if (!tmpfs_restore_recursion(dsid, bufpos, buflen, pos,
    151151                            fn))
    152152                                return false;
    … …  
    161161}
    162162
    163 bool tmpfs_restore(devmap_handle_t dev)
     163bool tmpfs_restore(service_id_t dsid)
    164164{
    165165        libfs_ops_t *ops = &tmpfs_libfs_ops;
    … …  
    167167        int rc;
    168168
    169         rc = block_init(EXCHANGE_SERIALIZE, dev, TMPFS_COMM_SIZE);
     169        rc = block_init(EXCHANGE_SERIALIZE, dsid, TMPFS_COMM_SIZE);
    170170        if (rc != EOK)
    171171                return false;
    … …  
    176176       
    177177        char tag[6];
    178         if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5) != EOK)
     178        if (block_seqread(dsid, &bufpos, &buflen, &pos, tag, 5) != EOK)
    179179                goto error;
    180180       
    … …  
    183183                goto error;
    184184       
    185         rc = ops->root_get(&fn, dev);
     185        rc = ops->root_get(&fn, dsid);
    186186        if (rc != EOK)
    187187                goto error;
    188188
    189         if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, fn))
    190                 goto error;
    191                
    192         block_fini(dev);
     189        if (!tmpfs_restore_recursion(dsid, &bufpos, &buflen, &pos, fn))
     190                goto error;
     191               
     192        block_fini(dsid);
    193193        return true;
    194194       
    195195error:
    196         block_fini(dev);
     196        block_fini(dsid);
    197197        return false;
    198198}

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    ref09a7a r15f3c3f  
    6969/* Forward declarations of static functions. */
    7070static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
    71 static int tmpfs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     71static int tmpfs_node_get(fs_node_t **, service_id_t, fs_index_t);
    7272static int tmpfs_node_open(fs_node_t *);
    7373static int tmpfs_node_put(fs_node_t *);
    74 static int tmpfs_create_node(fs_node_t **, devmap_handle_t, int);
     74static int tmpfs_create_node(fs_node_t **, service_id_t, int);
    7575static int tmpfs_destroy_node(fs_node_t *);
    7676static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    … …  
    7878
    7979/* Implementation of helper functions. */
    80 static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    81 {
    82         return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT);
     80static int tmpfs_root_get(fs_node_t **rfn, service_id_t service_id)
     81{
     82        return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT);
    8383}
    8484
    … …  
    119119}
    120120
    121 static devmap_handle_t tmpfs_device_get(fs_node_t *fn)
     121static service_id_t tmpfs_device_get(fs_node_t *fn)
    122122{
    123123        return 0;
    … …  
    164164        switch (keys) {
    165165        case 1:
    166                 return (nodep->devmap_handle == key[NODES_KEY_DEV]);
     166                return (nodep->service_id == key[NODES_KEY_DEV]);
    167167        case 2:
    168                 return ((nodep->devmap_handle == key[NODES_KEY_DEV]) &&
     168                return ((nodep->service_id == key[NODES_KEY_DEV]) &&
    169169                    (nodep->index == key[NODES_KEY_INDEX]));
    170170        default:
    … …  
    208208        nodep->bp = NULL;
    209209        nodep->index = 0;
    210         nodep->devmap_handle = 0;
     210        nodep->service_id = 0;
    211211        nodep->type = TMPFS_NONE;
    212212        nodep->lnkcnt = 0;
    … …  
    232232}
    233233
    234 static bool tmpfs_instance_init(devmap_handle_t devmap_handle)
     234static bool tmpfs_instance_init(service_id_t service_id)
    235235{
    236236        fs_node_t *rfn;
    237237        int rc;
    238238       
    239         rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY);
     239        rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY);
    240240        if (rc != EOK || !rfn)
    241241                return false;
    … …  
    244244}
    245245
    246 static void tmpfs_instance_done(devmap_handle_t devmap_handle)
     246static void tmpfs_instance_done(service_id_t service_id)
    247247{
    248248        unsigned long key[] = {
    249                 [NODES_KEY_DEV] = devmap_handle
     249                [NODES_KEY_DEV] = service_id
    250250        };
    251251        /*
    … …  
    276276}
    277277
    278 int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     278int tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    279279{
    280280        unsigned long key[] = {
    281                 [NODES_KEY_DEV] = devmap_handle,
     281                [NODES_KEY_DEV] = service_id,
    282282                [NODES_KEY_INDEX] = index
    283283        };
    … …  
    305305}
    306306
    307 int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
     307int tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
    308308{
    309309        fs_node_t *rootfn;
    … …  
    324324        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    325325
    326         rc = tmpfs_root_get(&rootfn, devmap_handle);
     326        rc = tmpfs_root_get(&rootfn, service_id);
    327327        assert(rc == EOK);
    328328        if (!rootfn)
    … …  
    330330        else
    331331                nodep->index = tmpfs_next_index++;
    332         nodep->devmap_handle = devmap_handle;
     332        nodep->service_id = service_id;
    333333        if (lflag & L_DIRECTORY)
    334334                nodep->type = TMPFS_DIRECTORY;
    … …  
    338338        /* Insert the new node into the nodes hash table. */
    339339        unsigned long key[] = {
    340                 [NODES_KEY_DEV] = nodep->devmap_handle,
     340                [NODES_KEY_DEV] = nodep->service_id,
    341341                [NODES_KEY_INDEX] = nodep->index
    342342        };
    … …  
    354354
    355355        unsigned long key[] = {
    356                 [NODES_KEY_DEV] = nodep->devmap_handle,
     356                [NODES_KEY_DEV] = nodep->service_id,
    357357                [NODES_KEY_INDEX] = nodep->index
    358358        };
    … …  
    435435void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    436436{
    437         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     437        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    438438        fs_node_t *rootfn;
    439439        int rc;
    … …  
    448448
    449449        /* Check if this device is not already mounted. */
    450         rc = tmpfs_root_get(&rootfn, devmap_handle);
     450        rc = tmpfs_root_get(&rootfn, service_id);
    451451        if ((rc == EOK) && (rootfn)) {
    452452                (void) tmpfs_node_put(rootfn);
    … …  
    457457
    458458        /* Initialize TMPFS instance. */
    459         if (!tmpfs_instance_init(devmap_handle)) {
     459        if (!tmpfs_instance_init(service_id)) {
    460460                free(opts);
    461461                async_answer_0(rid, ENOMEM);
    … …  
    463463        }
    464464
    465         rc = tmpfs_root_get(&rootfn, devmap_handle);
     465        rc = tmpfs_root_get(&rootfn, service_id);
    466466        assert(rc == EOK);
    467467        tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
    468468        if (str_cmp(opts, "restore") == 0) {
    469                 if (tmpfs_restore(devmap_handle))
     469                if (tmpfs_restore(service_id))
    470470                        async_answer_3(rid, EOK, rootp->index, rootp->size,
    471471                            rootp->lnkcnt);
    … …  
    486486void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    487487{
    488         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    489 
    490         tmpfs_instance_done(devmap_handle);
     488        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     489
     490        tmpfs_instance_done(service_id);
    491491        async_answer_0(rid, EOK);
    492492}
    … …  
    504504void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
    505505{
    506         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     506        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    507507        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    508508        aoff64_t pos =
    … …  
    514514        link_t *hlp;
    515515        unsigned long key[] = {
    516                 [NODES_KEY_DEV] = devmap_handle,
     516                [NODES_KEY_DEV] = service_id,
    517517                [NODES_KEY_INDEX] = index
    518518        };
    … …  
    575575void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
    576576{
    577         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     577        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    578578        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    579579        aoff64_t pos =
    … …  
    585585        link_t *hlp;
    586586        unsigned long key[] = {
    587                 [NODES_KEY_DEV] = devmap_handle,
     587                [NODES_KEY_DEV] = service_id,
    588588                [NODES_KEY_INDEX] = index
    589589        };
    … …  
    640640void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    641641{
    642         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     642        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    643643        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    644644        aoff64_t size =
    … …  
    649649         */
    650650        unsigned long key[] = {
    651                 [NODES_KEY_DEV] = devmap_handle,
     651                [NODES_KEY_DEV] = service_id,
    652652                [NODES_KEY_INDEX] = index
    653653        };
    … …  
    693693void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    694694{
    695         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     695        service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    696696        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    697697        int rc;
    … …  
    699699        link_t *hlp;
    700700        unsigned long key[] = {
    701                 [NODES_KEY_DEV] = devmap_handle,
     701                [NODES_KEY_DEV] = service_id,
    702702                [NODES_KEY_INDEX] = index
    703703        };
Note: See TracChangeset for help on using the changeset viewer.