Changeset 15f3c3f in mainline for uspace/srv


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
Files:
1 added
1 deleted
43 edited
6 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    ref09a7a r15f3c3f  
    5757#include <stdint.h>
    5858#include <str.h>
    59 #include <devmap.h>
     59#include <loc.h>
    6060#include <sys/types.h>
    6161#include <inttypes.h>
    … …  
    179179               
    180180                snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
    181                 rc = devmap_device_register(name, &disk[i].devmap_handle);
     181                rc = loc_service_register(name, &disk[i].service_id);
    182182                if (rc != EOK) {
    183183                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    247247        int rc;
    248248
    249         rc = devmap_driver_register(NAME, ata_bd_connection);
     249        rc = loc_server_register(NAME, ata_bd_connection);
    250250        if (rc < 0) {
    251251                printf(NAME ": Unable to register driver.\n");
    … …  
    280280        ipc_call_t call;
    281281        sysarg_t method;
    282         devmap_handle_t dh;
     282        service_id_t dsid;
    283283        unsigned int flags;
    284284        int retval;
    … …  
    287287        int disk_id, i;
    288288
    289         /* Get the device handle. */
    290         dh = IPC_GET_ARG1(*icall);
     289        /* Get the device service ID. */
     290        dsid = IPC_GET_ARG1(*icall);
    291291
    292292        /* Determine which disk device is the client connecting to. */
    293293        disk_id = -1;
    294294        for (i = 0; i < MAX_DISKS; i++)
    295                 if (disk[i].devmap_handle == dh)
     295                if (disk[i].service_id == dsid)
    296296                        disk_id = i;
    297297

  • uspace/srv/bd/ata_bd/ata_bd.h

    ref09a7a r15f3c3f  
    116116
    117117        fibril_mutex_t lock;
    118         devmap_handle_t devmap_handle;
     118        service_id_t service_id;
    119119} disk_t;
    120120

  • uspace/srv/bd/file_bd/file_bd.c

    ref09a7a r15f3c3f  
    4545#include <as.h>
    4646#include <fibril_synch.h>
    47 #include <devmap.h>
     47#include <loc.h>
    4848#include <sys/types.h>
    4949#include <sys/typefmt.h>
    … …  
    6161static FILE *img;
    6262
    63 static devmap_handle_t devmap_handle;
     63static service_id_t service_id;
    6464static fibril_mutex_t dev_lock;
    6565
    … …  
    117117                return -1;
    118118
    119         rc = devmap_device_register(device_name, &devmap_handle);
     119        rc = loc_service_register(device_name, &service_id);
    120120        if (rc != EOK) {
    121121                printf(NAME ": Unable to register device '%s'.\n",
    … …  
    142142        long img_size;
    143143
    144         rc = devmap_driver_register(NAME, file_bd_connection);
     144        rc = loc_server_register(NAME, file_bd_connection);
    145145        if (rc < 0) {
    146146                printf(NAME ": Unable to register driver.\n");

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    ref09a7a r15f3c3f  
    4343#include <as.h>
    4444#include <fibril_synch.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646#include <sys/types.h>
    4747#include <errno.h>
    … …  
    9292static gxe_bd_t *dev;
    9393
    94 static devmap_handle_t devmap_handle[MAX_DISKS];
     94static service_id_t service_id[MAX_DISKS];
    9595
    9696static fibril_mutex_t dev_lock[MAX_DISKS];
    … …  
    126126        char name[16];
    127127
    128         rc = devmap_driver_register(NAME, gxe_bd_connection);
     128        rc = loc_server_register(NAME, gxe_bd_connection);
    129129        if (rc < 0) {
    130130                printf(NAME ": Unable to register driver.\n");
    … …  
    142142        for (i = 0; i < MAX_DISKS; i++) {
    143143                snprintf(name, 16, "%s/disk%d", NAMESPACE, i);
    144                 rc = devmap_device_register(name, &devmap_handle[i]);
     144                rc = loc_service_register(name, &service_id[i]);
    145145                if (rc != EOK) {
    146146                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    159159        ipc_call_t call;
    160160        sysarg_t method;
    161         devmap_handle_t dh;
     161        service_id_t dsid;
    162162        unsigned int flags;
    163163        int retval;
    … …  
    167167
    168168        /* Get the device handle. */
    169         dh = IPC_GET_ARG1(*icall);
     169        dsid = IPC_GET_ARG1(*icall);
    170170
    171171        /* Determine which disk device is the client connecting to. */
    172172        disk_id = -1;
    173173        for (i = 0; i < MAX_DISKS; i++)
    174                 if (devmap_handle[i] == dh)
     174                if (service_id[i] == dsid)
    175175                        disk_id = i;
    176176

  • uspace/srv/bd/part/guid_part/guid_part.c

    ref09a7a r15f3c3f  
    5151#include <as.h>
    5252#include <fibril_synch.h>
    53 #include <devmap.h>
     53#include <loc.h>
    5454#include <sys/types.h>
    5555#include <sys/typefmt.h>
    5656#include <inttypes.h>
    5757#include <libblock.h>
    58 #include <devmap.h>
     58#include <loc.h>
    5959#include <errno.h>
    6060#include <bool.h>
    … …  
    8181        /** Number of blocks */
    8282        aoff64_t length;
    83         /** Device representing the partition (outbound device) */
    84         devmap_handle_t dev;
     83        /** Service representing the partition (outbound device) */
     84        service_id_t dsid;
    8585        /** Points to next partition structure. */
    8686        struct part *next;
    … …  
    9090
    9191/** Partitioned device (inbound device) */
    92 static devmap_handle_t indev_handle;
     92static service_id_t indev_sid;
    9393
    9494/** List of partitions. This structure is an empty head. */
    … …  
    129129        int i;
    130130        char *name;
    131         devmap_handle_t dev;
     131        service_id_t dsid;
    132132        uint64_t size_mb;
    133133        part_t *part;
    134134
    135         rc = devmap_device_get_handle(dev_name, &indev_handle, 0);
     135        rc = loc_service_get_id(dev_name, &indev_sid, 0);
    136136        if (rc != EOK) {
    137137                printf(NAME ": could not resolve device `%s'.\n", dev_name);
    … …  
    139139        }
    140140
    141         rc = block_init(EXCHANGE_SERIALIZE, indev_handle, 2048);
     141        rc = block_init(EXCHANGE_SERIALIZE, indev_sid, 2048);
    142142        if (rc != EOK)  {
    143143                printf(NAME ": could not init libblock.\n");
    … …  
    147147        /* Determine and verify block size. */
    148148
    149         rc = block_get_bsize(indev_handle, &block_size);
     149        rc = block_get_bsize(indev_sid, &block_size);
    150150        if (rc != EOK) {
    151151                printf(NAME ": error getting block size.\n");
    … …  
    163163                return rc;
    164164
    165         /* Register the driver with device mapper. */
    166         rc = devmap_driver_register(NAME, gpt_connection);
     165        /* Register server with location service. */
     166        rc = loc_server_register(NAME, gpt_connection);
    167167        if (rc != EOK) {
    168                 printf(NAME ": Unable to register driver.\n");
     168                printf(NAME ": Unable to register server.\n");
    169169                return rc;
    170170        }
    … …  
    188188                        return ENOMEM;
    189189
    190                 rc = devmap_device_register(name, &dev);
     190                rc = loc_service_register(name, &dsid);
    191191                if (rc != EOK) {
    192                         printf(NAME ": Unable to register device %s.\n", name);
     192                        printf(NAME ": Unable to register service %s.\n", name);
    193193                        return rc;
    194194                }
    … …  
    199199                    "%" PRIuOFF64 " MB.\n", name, part->length, size_mb);
    200200
    201                 part->dev = dev;
     201                part->dsid = dsid;
    202202                free(name);
    203203
    … …  
    228228        }
    229229
    230         rc = block_read_direct(indev_handle, GPT_HDR_BA, 1, gpt_hdr);
     230        rc = block_read_direct(indev_sid, GPT_HDR_BA, 1, gpt_hdr);
    231231        if (rc != EOK) {
    232232                printf(NAME ": Failed reading GPT header block.\n");
    … …  
    256256        }
    257257
    258         rc = block_read_direct(indev_handle, ba, bcnt, etable);
     258        rc = block_read_direct(indev_sid, ba, bcnt, etable);
    259259        if (rc != EOK) {
    260260                printf(NAME ": Failed reading GPT entries.\n");
    … …  
    303303        }
    304304
    305         part->dev = 0;
     305        part->dsid = 0;
    306306        part->next = NULL;
    307307}
    … …  
    314314        ipc_call_t call;
    315315        sysarg_t method;
    316         devmap_handle_t dh;
     316        service_id_t dh;
    317317        unsigned int flags;
    318318        int retval;
    … …  
    330330         */
    331331        part = plist_head.next;
    332         while (part != NULL && part->dev != dh)
     332        while (part != NULL && part->dsid != dh)
    333333                part = part->next;
    334334
    … …  
    410410                return ELIMIT;
    411411
    412         return block_read_direct(indev_handle, gba, cnt, buf);
     412        return block_read_direct(indev_sid, gba, cnt, buf);
    413413}
    414414
    … …  
    421421                return ELIMIT;
    422422
    423         return block_write_direct(indev_handle, gba, cnt, buf);
     423        return block_write_direct(indev_sid, gba, cnt, buf);
    424424}
    425425

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    ref09a7a r15f3c3f  
    6161#include <as.h>
    6262#include <fibril_synch.h>
    63 #include <devmap.h>
     63#include <loc.h>
    6464#include <sys/types.h>
    6565#include <sys/typefmt.h>
    6666#include <inttypes.h>
    6767#include <libblock.h>
    68 #include <devmap.h>
     68#include <loc.h>
    6969#include <errno.h>
    7070#include <bool.h>
    … …  
    100100        aoff64_t length;
    101101        /** Device representing the partition (outbound device) */
    102         devmap_handle_t dev;
     102        service_id_t dsid;
    103103        /** Points to next partition structure. */
    104104        struct part *next;
    … …  
    141141
    142142/** Partitioned device (inbound device) */
    143 static devmap_handle_t indev_handle;
     143static service_id_t indef_sid;
    144144
    145145/** List of partitions. This structure is an empty head. */
    … …  
    180180        int i;
    181181        char *name;
    182         devmap_handle_t dev;
     182        service_id_t dsid;
    183183        uint64_t size_mb;
    184184        part_t *part;
    185185
    186         rc = devmap_device_get_handle(dev_name, &indev_handle, 0);
     186        rc = loc_service_get_id(dev_name, &indef_sid, 0);
    187187        if (rc != EOK) {
    188188                printf(NAME ": could not resolve device `%s'.\n", dev_name);
    … …  
    190190        }
    191191
    192         rc = block_init(EXCHANGE_SERIALIZE, indev_handle, 2048);
     192        rc = block_init(EXCHANGE_SERIALIZE, indef_sid, 2048);
    193193        if (rc != EOK)  {
    194194                printf(NAME ": could not init libblock.\n");
    … …  
    198198        /* Determine and verify block size. */
    199199
    200         rc = block_get_bsize(indev_handle, &block_size);
     200        rc = block_get_bsize(indef_sid, &block_size);
    201201        if (rc != EOK) {
    202202                printf(NAME ": error getting block size.\n");
    … …  
    214214                return rc;
    215215
    216         /* Register the driver with device mapper. */
    217         rc = devmap_driver_register(NAME, mbr_connection);
     216        /* Register server with location service. */
     217        rc = loc_server_register(NAME, mbr_connection);
    218218        if (rc != EOK) {
    219                 printf(NAME ": Unable to register driver.\n");
     219                printf(NAME ": Unable to register server.\n");
    220220                return rc;
    221221        }
    … …  
    239239                        return ENOMEM;
    240240
    241                 rc = devmap_device_register(name, &dev);
     241                rc = loc_service_register(name, &dsid);
    242242                if (rc != EOK) {
    243                         printf(NAME ": Unable to register device %s.\n", name);
     243                        printf(NAME ": Unable to register service %s.\n", name);
    244244                        return rc;
    245245                }
    … …  
    250250                    "%" PRIu64 " MB.\n", name, part->length, size_mb);
    251251
    252                 part->dev = dev;
     252                part->dsid = dsid;
    253253                free(name);
    254254
    … …  
    281281         */
    282282
    283         rc = block_read_direct(indev_handle, 0, 1, brb);
     283        rc = block_read_direct(indef_sid, 0, 1, brb);
    284284        if (rc != EOK) {
    285285                printf(NAME ": Failed reading MBR block.\n");
    … …  
    332332                 */
    333333                ba = cp.start_addr;
    334                 rc = block_read_direct(indev_handle, ba, 1, brb);
     334                rc = block_read_direct(indef_sid, ba, 1, brb);
    335335                if (rc != EOK) {
    336336                        printf(NAME ": Failed reading EBR block at %"
    … …  
    381381        part->present = (pte->ptype != PT_UNUSED) ? true : false;
    382382
    383         part->dev = 0;
     383        part->dsid = 0;
    384384        part->next = NULL;
    385385}
    … …  
    392392        ipc_call_t call;
    393393        sysarg_t method;
    394         devmap_handle_t dh;
     394        service_id_t dh;
    395395        unsigned int flags;
    396396        int retval;
    … …  
    408408         */
    409409        part = plist_head.next;
    410         while (part != NULL && part->dev != dh)
     410        while (part != NULL && part->dsid != dh)
    411411                part = part->next;
    412412
    … …  
    488488                return ELIMIT;
    489489
    490         return block_read_direct(indev_handle, gba, cnt, buf);
     490        return block_read_direct(indef_sid, gba, cnt, buf);
    491491}
    492492
    … …  
    499499                return ELIMIT;
    500500
    501         return block_write_direct(indev_handle, gba, cnt, buf);
     501        return block_write_direct(indef_sid, gba, cnt, buf);
    502502}
    503503

  • uspace/srv/bd/rd/rd.c

    ref09a7a r15f3c3f  
    5252#include <fibril_synch.h>
    5353#include <stdio.h>
    54 #include <devmap.h>
     54#include <loc.h>
    5555#include <ipc/bd.h>
    5656#include <macros.h>
    … …  
    235235            (void *) rd_ph_addr, rd_size);
    236236       
    237         int rc = devmap_driver_register(NAME, rd_connection);
     237        int rc = loc_server_register(NAME, rd_connection);
    238238        if (rc < 0) {
    239239                printf("%s: Unable to register driver (%d)\n", NAME, rc);
    … …  
    241241        }
    242242       
    243         devmap_handle_t devmap_handle;
    244         if (devmap_device_register("bd/initrd", &devmap_handle) != EOK) {
    245                 printf("%s: Unable to register device\n", NAME);
     243        service_id_t service_id;
     244        if (loc_service_register("bd/initrd", &service_id) != EOK) {
     245                printf("%s: Unable to register device service\n", NAME);
    246246                return false;
    247247        }

  • uspace/srv/devman/devman.c

    ref09a7a r15f3c3f  
    3737#include <ipc/driver.h>
    3838#include <ipc/devman.h>
    39 #include <devmap.h>
     39#include <loc.h>
    4040#include <str_error.h>
    4141#include <stdio.h>
    … …  
    6666}
    6767
    68 static int devmap_functions_compare(unsigned long key[], hash_count_t keys,
     68static int loc_functions_compare(unsigned long key[], hash_count_t keys,
    6969    link_t *item)
    7070{
    71         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devmap_fun);
    72         return (fun->devmap_handle == (devmap_handle_t) key[0]);
    73 }
    74 
    75 static int devmap_devices_class_compare(unsigned long key[], hash_count_t keys,
     71        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
     72        return (fun->service_id == (service_id_t) key[0]);
     73}
     74
     75static int loc_devices_class_compare(unsigned long key[], hash_count_t keys,
    7676    link_t *item)
    7777{
    7878        dev_class_info_t *class_info
    79             = hash_table_get_instance(item, dev_class_info_t, devmap_link);
     79            = hash_table_get_instance(item, dev_class_info_t, loc_link);
    8080        assert(class_info != NULL);
    8181
    82         return (class_info->devmap_handle == (devmap_handle_t) key[0]);
     82        return (class_info->service_id == (service_id_t) key[0]);
    8383}
    8484
    … …  
    9999};
    100100
    101 static hash_table_operations_t devmap_devices_ops = {
     101static hash_table_operations_t loc_devices_ops = {
    102102        .hash = devices_hash,
    103         .compare = devmap_functions_compare,
     103        .compare = loc_functions_compare,
    104104        .remove_callback = devices_remove_callback
    105105};
    106106
    107 static hash_table_operations_t devmap_devices_class_ops = {
     107static hash_table_operations_t loc_devices_class_ops = {
    108108        .hash = devices_hash,
    109         .compare = devmap_devices_class_compare,
     109        .compare = loc_devices_class_compare,
    110110        .remove_callback = devices_remove_callback
    111111};
    … …  
    700700}
    701701
    702 /** Create devmap path and name for the function. */
    703 void devmap_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
    704 {
    705         char *devmap_pathname = NULL;
    706         char *devmap_name = NULL;
    707        
    708         asprintf(&devmap_name, "%s", fun->pathname);
    709         if (devmap_name == NULL)
     702/** Create loc path and name for the function. */
     703void loc_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
     704{
     705        char *loc_pathname = NULL;
     706        char *loc_name = NULL;
     707       
     708        asprintf(&loc_name, "%s", fun->pathname);
     709        if (loc_name == NULL)
    710710                return;
    711711       
    712         replace_char(devmap_name, '/', DEVMAP_SEPARATOR);
    713        
    714         asprintf(&devmap_pathname, "%s/%s", DEVMAP_DEVICE_NAMESPACE,
    715             devmap_name);
    716         if (devmap_pathname == NULL) {
    717                 free(devmap_name);
     712        replace_char(loc_name, '/', LOC_SEPARATOR);
     713       
     714        asprintf(&loc_pathname, "%s/%s", LOC_DEVICE_NAMESPACE,
     715            loc_name);
     716        if (loc_pathname == NULL) {
     717                free(loc_name);
    718718                return;
    719719        }
    720720       
    721         devmap_device_register_with_iface(devmap_pathname,
    722             &fun->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
    723        
    724         tree_add_devmap_function(tree, fun);
    725        
    726         free(devmap_name);
    727         free(devmap_pathname);
     721        loc_service_register_with_iface(loc_pathname,
     722            &fun->service_id, DEVMAN_CONNECT_FROM_LOC);
     723       
     724        tree_add_loc_function(tree, fun);
     725       
     726        free(loc_name);
     727        free(loc_pathname);
    728728}
    729729
    … …  
    855855        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
    856856            &devman_functions_ops);
    857         hash_table_create(&tree->devmap_functions, DEVICE_BUCKETS, 1,
    858             &devmap_devices_ops);
     857        hash_table_create(&tree->loc_functions, DEVICE_BUCKETS, 1,
     858            &loc_devices_ops);
    859859       
    860860        fibril_rwlock_initialize(&tree->rwlock);
    … …  
    951951                list_initialize(&res->classes);
    952952                link_initialize(&res->devman_fun);
    953                 link_initialize(&res->devmap_fun);
     953                link_initialize(&res->loc_fun);
    954954        }
    955955       
    … …  
    12671267                memset(info, 0, sizeof(dev_class_info_t));
    12681268                link_initialize(&info->dev_classes);
    1269                 link_initialize(&info->devmap_link);
     1269                link_initialize(&info->loc_link);
    12701270                link_initialize(&info->link);
    12711271        }
    … …  
    14131413        list_initialize(&class_list->classes);
    14141414        fibril_rwlock_initialize(&class_list->rwlock);
    1415         hash_table_create(&class_list->devmap_functions, DEVICE_BUCKETS, 1,
    1416             &devmap_devices_class_ops);
    1417 }
    1418 
    1419 
    1420 /* Devmap devices */
    1421 
    1422 fun_node_t *find_devmap_tree_function(dev_tree_t *tree, devmap_handle_t devmap_handle)
     1415        hash_table_create(&class_list->loc_functions, DEVICE_BUCKETS, 1,
     1416            &loc_devices_class_ops);
     1417}
     1418
     1419
     1420/* loc devices */
     1421
     1422fun_node_t *find_loc_tree_function(dev_tree_t *tree, service_id_t service_id)
    14231423{
    14241424        fun_node_t *fun = NULL;
    14251425        link_t *link;
    1426         unsigned long key = (unsigned long) devmap_handle;
     1426        unsigned long key = (unsigned long) service_id;
    14271427       
    14281428        fibril_rwlock_read_lock(&tree->rwlock);
    1429         link = hash_table_find(&tree->devmap_functions, &key);
     1429        link = hash_table_find(&tree->loc_functions, &key);
    14301430        if (link != NULL)
    1431                 fun = hash_table_get_instance(link, fun_node_t, devmap_fun);
     1431                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
    14321432        fibril_rwlock_read_unlock(&tree->rwlock);
    14331433       
    … …  
    14351435}
    14361436
    1437 fun_node_t *find_devmap_class_function(class_list_t *classes,
    1438     devmap_handle_t devmap_handle)
     1437fun_node_t *find_loc_class_function(class_list_t *classes,
     1438    service_id_t service_id)
    14391439{
    14401440        fun_node_t *fun = NULL;
    14411441        dev_class_info_t *cli;
    14421442        link_t *link;
    1443         unsigned long key = (unsigned long)devmap_handle;
     1443        unsigned long key = (unsigned long)service_id;
    14441444       
    14451445        fibril_rwlock_read_lock(&classes->rwlock);
    1446         link = hash_table_find(&classes->devmap_functions, &key);
     1446        link = hash_table_find(&classes->loc_functions, &key);
    14471447        if (link != NULL) {
    14481448                cli = hash_table_get_instance(link, dev_class_info_t,
    1449                     devmap_link);
     1449                    loc_link);
    14501450                fun = cli->fun;
    14511451        }
    … …  
    14551455}
    14561456
    1457 void class_add_devmap_function(class_list_t *class_list, dev_class_info_t *cli)
    1458 {
    1459         unsigned long key = (unsigned long) cli->devmap_handle;
     1457void class_add_loc_function(class_list_t *class_list, dev_class_info_t *cli)
     1458{
     1459        unsigned long key = (unsigned long) cli->service_id;
    14601460       
    14611461        fibril_rwlock_write_lock(&class_list->rwlock);
    1462         hash_table_insert(&class_list->devmap_functions, &key, &cli->devmap_link);
     1462        hash_table_insert(&class_list->loc_functions, &key, &cli->loc_link);
    14631463        fibril_rwlock_write_unlock(&class_list->rwlock);
    14641464
    1465         assert(find_devmap_class_function(class_list, cli->devmap_handle) != NULL);
    1466 }
    1467 
    1468 void tree_add_devmap_function(dev_tree_t *tree, fun_node_t *fun)
    1469 {
    1470         unsigned long key = (unsigned long) fun->devmap_handle;
     1465        assert(find_loc_class_function(class_list, cli->service_id) != NULL);
     1466}
     1467
     1468void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
     1469{
     1470        unsigned long key = (unsigned long) fun->service_id;
    14711471        fibril_rwlock_write_lock(&tree->rwlock);
    1472         hash_table_insert(&tree->devmap_functions, &key, &fun->devmap_fun);
     1472        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    14731473        fibril_rwlock_write_unlock(&tree->rwlock);
    14741474}

  • uspace/srv/devman/devman.h

    ref09a7a r15f3c3f  
    4141#include <adt/hash_table.h>
    4242#include <ipc/devman.h>
    43 #include <ipc/devmap.h>
     43#include <ipc/loc.h>
    4444#include <fibril_synch.h>
    4545#include <atomic.h>
    … …  
    5353#define DEVICE_BUCKETS 256
    5454
    55 #define DEVMAP_CLASS_NAMESPACE "class"
    56 #define DEVMAP_DEVICE_NAMESPACE "devices"
    57 #define DEVMAP_SEPARATOR '\\'
     55#define LOC_CLASS_NAMESPACE "class"
     56#define LOC_DEVICE_NAMESPACE "devices"
     57#define LOC_SEPARATOR '\\'
    5858
    5959struct dev_node;
    … …  
    172172        /** List of device classes to which this device function belongs. */
    173173        list_t classes;
    174         /** Devmap handle if the device function is registered by devmap. */
    175         devmap_handle_t devmap_handle;
     174        /** Service ID if the device function is registered with loc. */
     175        service_id_t service_id;
    176176       
    177177        /**
    … …  
    181181       
    182182        /**
    183          * Used by the hash table of functions indexed by devmap device handles.
    184          */
    185         link_t devmap_fun;
     183         * Used by the hash table of functions indexed by service IDs.
     184         */
     185        link_t loc_fun;
    186186};
    187187
    … …  
    208208       
    209209        /**
    210          * Hash table of devices registered by devmapper, indexed by devmap
    211          * handles.
    212          */
    213         hash_table_t devmap_functions;
     210         * Hash table of services registered with location service, indexed by
     211         * service IDs.
     212         */
     213        hash_table_t loc_functions;
    214214} dev_tree_t;
    215215
    … …  
    267267        /** The name of the device function within the class. */
    268268        char *dev_name;
    269         /** The handle of the device by device mapper in the class namespace. */
    270         devmap_handle_t devmap_handle;
    271        
    272         /**
    273          * Link in the hash table of devices registered by the devmapper using
     269        /** Service ID in the class namespace. */
     270        service_id_t service_id;
     271       
     272        /**
     273         * Link to hash table of services registered with location service using
    274274         * their class names.
    275275         */
    276         link_t devmap_link;
     276        link_t loc_link;
    277277} dev_class_info_t;
    278278
    … …  
    283283       
    284284        /**
    285          * Hash table of devices registered by devmapper using their class name,
    286          * indexed by devmap handles.
    287          */
    288         hash_table_t devmap_functions;
     285         * Hash table of services registered with location service using their
     286         * class name, indexed by service IDs.
     287         */
     288        hash_table_t loc_functions;
    289289       
    290290        /** Fibril mutex for list of classes. */
    … …  
    364364extern void add_dev_class_no_lock(class_list_t *, dev_class_t *);
    365365
    366 /* Devmap devices */
    367 
    368 extern void devmap_register_tree_function(fun_node_t *, dev_tree_t *);
    369 
    370 extern fun_node_t *find_devmap_tree_function(dev_tree_t *, devmap_handle_t);
    371 extern fun_node_t *find_devmap_class_function(class_list_t *, devmap_handle_t);
    372 
    373 extern void class_add_devmap_function(class_list_t *, dev_class_info_t *);
    374 extern void tree_add_devmap_function(dev_tree_t *, fun_node_t *);
     366/* Loc services */
     367
     368extern void loc_register_tree_function(fun_node_t *, dev_tree_t *);
     369
     370extern fun_node_t *find_loc_tree_function(dev_tree_t *, service_id_t);
     371extern fun_node_t *find_loc_class_function(class_list_t *, service_id_t);
     372
     373extern void class_add_loc_function(class_list_t *, dev_class_info_t *);
     374extern void tree_add_loc_function(dev_tree_t *, fun_node_t *);
    375375
    376376#endif

  • uspace/srv/devman/main.c

    ref09a7a r15f3c3f  
    5656#include <ipc/driver.h>
    5757#include <thread.h>
    58 #include <devmap.h>
     58#include <loc.h>
    5959
    6060#include "devman.h"
    … …  
    326326                }
    327327        } else {
    328                 devmap_register_tree_function(fun, tree);
     328                loc_register_tree_function(fun, tree);
    329329        }
    330330       
    … …  
    333333}
    334334
    335 static void devmap_register_class_dev(dev_class_info_t *cli)
    336 {
    337         /* Create devmap path and name for the device. */
    338         char *devmap_pathname = NULL;
    339 
    340         asprintf(&devmap_pathname, "%s/%s%c%s", DEVMAP_CLASS_NAMESPACE,
    341             cli->dev_class->name, DEVMAP_SEPARATOR, cli->dev_name);
    342         if (devmap_pathname == NULL)
     335static void loc_register_class_dev(dev_class_info_t *cli)
     336{
     337        /* Create loc path and name for the service. */
     338        char *loc_pathname = NULL;
     339
     340        asprintf(&loc_pathname, "%s/%s%c%s", LOC_CLASS_NAMESPACE,
     341            cli->dev_class->name, LOC_SEPARATOR, cli->dev_name);
     342        if (loc_pathname == NULL)
    343343                return;
    344344       
    345345        /*
    346          * Register the device by the device mapper and remember its devmap
    347          * handle.
     346         * Register the device with location service and remember its
     347         * service ID.
    348348         */
    349         devmap_device_register_with_iface(devmap_pathname,
    350             &cli->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
     349        loc_service_register_with_iface(loc_pathname,
     350            &cli->service_id, DEVMAN_CONNECT_FROM_LOC);
    351351       
    352352        /*
    353          * Add device to the hash map of class devices registered by device
    354          * mapper.
     353         * Add device to the hash map of class devices registered with
     354         * location service.
    355355         */
    356         class_add_devmap_function(&class_list, cli);
    357        
    358         free(devmap_pathname);
     356        class_add_loc_function(&class_list, cli);
     357       
     358        free(loc_pathname);
    359359}
    360360
    … …  
    381381        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
    382382       
    383         /* Register the device's class alias by devmapper. */
    384         devmap_register_class_dev(class_info);
     383        /* Register the device's class alias with location service. */
     384        loc_register_class_dev(class_info);
    385385       
    386386        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
    … …  
    659659}
    660660
    661 /** Function for handling connections from a client forwarded by the device
    662  * mapper to the device manager. */
    663 static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall)
    664 {
    665         devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
     661/** Function for handling connections from a client forwarded by the location
     662 * service to the device manager. */
     663static void devman_connection_loc(ipc_callid_t iid, ipc_call_t *icall)
     664{
     665        service_id_t service_id = IPC_GET_ARG2(*icall);
    666666        fun_node_t *fun;
    667667        dev_node_t *dev;
    668668
    669         fun = find_devmap_tree_function(&device_tree, devmap_handle);
     669        fun = find_loc_tree_function(&device_tree, service_id);
    670670        if (fun == NULL)
    671                 fun = find_devmap_class_function(&class_list, devmap_handle);
     671                fun = find_loc_class_function(&class_list, service_id);
    672672       
    673673        if (fun == NULL || fun->dev->drv == NULL) {
    … …  
    689689       
    690690        log_msg(LVL_DEBUG,
    691             "Forwarding devmapper request for `%s' function to driver `%s'.",
     691            "Forwarding loc service request for `%s' function to driver `%s'.",
    692692            fun->pathname, dev->drv->name);
    693693}
    … …  
    708708                devman_forward(iid, icall, false);
    709709                break;
    710         case DEVMAN_CONNECT_FROM_DEVMAP:
    711                 /* Someone connected through devmap node. */
    712                 devman_connection_devmapper(iid, icall);
     710        case DEVMAN_CONNECT_FROM_LOC:
     711                /* Someone connected through loc node. */
     712                devman_connection_loc(iid, icall);
    713713                break;
    714714        case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
    … …  
    746746       
    747747        /*
    748          * !!! devman_connection ... as the device manager is not a real devmap
     748         * !!! devman_connection ... as the device manager is not a real loc
    749749         * driver (it uses a completely different ipc protocol than an ordinary
    750          * devmap driver) forwarding a connection from client to the devman by
    751          * devmapper would not work.
     750         * loc driver) forwarding a connection from client to the devman by
     751         * location service would not work.
    752752         */
    753         devmap_driver_register(NAME, devman_connection);
     753        loc_server_register(NAME, devman_connection);
    754754       
    755755        return true;

  • 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        };

  • uspace/srv/hid/console/console.c

    ref09a7a r15f3c3f  
    5353#include <sysinfo.h>
    5454#include <event.h>
    55 #include <devmap.h>
     55#include <loc.h>
    5656#include <fcntl.h>
    5757#include <vfs/vfs.h>
    … …  
    8181        size_t index;             /**< Console index */
    8282        size_t refcount;          /**< Connection reference count */
    83         devmap_handle_t devmap_handle;  /**< Device handle */
     83        service_id_t service_id;  /**< Service ID */
    8484        keybuffer_t keybuffer;    /**< Buffer for incoming keys. */
    8585        screenbuffer_t scr;       /**< Screenbuffer for saving screen
    … …  
    582582                        continue;
    583583               
    584                 if (consoles[i].devmap_handle == (devmap_handle_t) IPC_GET_ARG1(*icall)) {
     584                if (consoles[i].service_id == (service_id_t) IPC_GET_ARG1(*icall)) {
    585585                        cons = &consoles[i];
    586586                        break;
    … …  
    724724}
    725725
    726 static async_sess_t *connect_input(const char *dev_path)
     726static async_sess_t *connect_input(const char *svc_path)
    727727{
    728728        async_sess_t *sess;
    729729        async_exch_t *exch;
    730         devmap_handle_t handle;
    731        
    732         int rc = devmap_device_get_handle(dev_path, &handle, 0);
     730        service_id_t service_id;
     731       
     732        int rc = loc_service_get_id(svc_path, &service_id, 0);
    733733        if (rc == EOK) {
    734                 sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     734                sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    735735                if (sess == NULL) {
    736736                        printf("%s: Failed to connect to input server\n", NAME);
    … …  
    776776        }
    777777       
    778         /* Register driver */
    779         int rc = devmap_driver_register(NAME, client_connection);
     778        /* Register server */
     779        int rc = loc_server_register(NAME, client_connection);
    780780        if (rc < 0) {
    781                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     781                printf("%s: Unable to register server (%d)\n", NAME, rc);
    782782                return false;
    783783        }
    … …  
    823823                        consoles[i].refcount = 0;
    824824                       
    825                         char vc[DEVMAP_NAME_MAXLEN + 1];
    826                         snprintf(vc, DEVMAP_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
     825                        char vc[LOC_NAME_MAXLEN + 1];
     826                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    827827                       
    828                         if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) {
    829                                 printf("%s: Unable to register device %s\n", NAME, vc);
     828                        if (loc_service_register(vc, &consoles[i].service_id) != EOK) {
     829                                printf("%s: Unable to register service %s\n", NAME, vc);
    830830                                return false;
    831831                        }

  • uspace/srv/hid/input/generic/input.c

    ref09a7a r15f3c3f  
    5353#include <io/console.h>
    5454#include <io/keycode.h>
    55 #include <devmap.h>
     55#include <loc.h>
    5656#include <input.h>
    5757#include <kbd.h>
    … …  
    324324/** Add new kbdev device.
    325325 *
    326  * @param dev_path Filesystem path to the device (/dev/class/...)
     326 * @param dev_path Filesystem path to the device (/loc/class/...)
    327327 *
    328328 */
    … …  
    352352/** Add new mousedev device.
    353353 *
    354  * @param dev_path Filesystem path to the device (/dev/class/...)
     354 * @param dev_path Filesystem path to the device (/loc/class/...)
    355355 *
    356356 */
    … …  
    486486/** Periodically check for new input devices.
    487487 *
    488  * Looks under /dev/class/keyboard and /dev/class/mouse.
     488 * Looks under /loc/class/keyboard and /loc/class/mouse.
    489489 *
    490490 * @param arg Ignored
    … …  
    504504                 * Check for new keyboard device
    505505                 */
    506                 rc = asprintf(&dev_path, "/dev/class/keyboard\\%zu", kbd_id);
     506                rc = asprintf(&dev_path, "/loc/class/keyboard\\%zu", kbd_id);
    507507                if (rc < 0)
    508508                        continue;
    … …  
    521521                 * Check for new mouse device
    522522                 */
    523                 rc = asprintf(&dev_path, "/dev/class/mouse\\%zu", mouse_id);
     523                rc = asprintf(&dev_path, "/loc/class/mouse\\%zu", mouse_id);
    524524                if (rc < 0)
    525525                        continue;
    … …  
    573573        /* Add legacy keyboard devices. */
    574574        kbd_add_legacy_devs();
    575        
     575
    576576        /* Add legacy mouse devices. */
    577577        mouse_add_legacy_devs();
    578578       
    579579        /* Register driver */
    580         int rc = devmap_driver_register(NAME, client_connection);
     580        int rc = loc_server_register(NAME, client_connection);
    581581        if (rc < 0) {
    582                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     582                printf("%s: Unable to register server (%d)\n", NAME, rc);
    583583                return -1;
    584584        }
    585585       
    586         char kbd[DEVMAP_NAME_MAXLEN + 1];
    587         snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
    588        
    589         devmap_handle_t devmap_handle;
    590         if (devmap_device_register(kbd, &devmap_handle) != EOK) {
    591                 printf("%s: Unable to register device %s\n", NAME, kbd);
     586        char kbd[LOC_NAME_MAXLEN + 1];
     587        snprintf(kbd, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
     588       
     589        service_id_t service_id;
     590        if (loc_service_register(kbd, &service_id) != EOK) {
     591                printf("%s: Unable to register service %s\n", NAME, kbd);
    592592                return -1;
    593593        }

  • uspace/srv/hid/input/port/adb.c

    ref09a7a r15f3c3f  
    4343#include <fcntl.h>
    4444#include <errno.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646
    4747static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    6666{
    6767        const char *dev = "adb/kbd";
    68         devmap_handle_t handle;
     68        service_id_t service_id;
    6969        async_exch_t *exch;
    7070        int rc;
    … …  
    7272        kbd_dev = kdev;
    7373       
    74         rc = devmap_device_get_handle(dev, &handle, 0);
     74        rc = loc_service_get_id(dev, &service_id, 0);
    7575        if (rc != EOK)
    7676                return rc;
    7777       
    78         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     78        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    7979        if (dev_sess == NULL) {
    8080                printf("%s: Failed to connect to device\n", NAME);

  • uspace/srv/hid/input/port/adb_mouse.c

    ref09a7a r15f3c3f  
    4141#include <mouse.h>
    4242#include <errno.h>
    43 #include <devmap.h>
     43#include <loc.h>
    4444
    4545static mouse_dev_t *mouse_dev;
    … …  
    7878        mouse_dev = mdev;
    7979       
    80         devmap_handle_t handle;
    81         int rc = devmap_device_get_handle(dev, &handle, 0);
     80        service_id_t service_id;
     81        int rc = loc_service_get_id(dev, &service_id, 0);
    8282        if (rc != EOK)
    8383                return rc;
    8484       
    85         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     85        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    8686        if (dev_sess == NULL) {
    8787                printf("%s: Failed to connect to device\n", NAME);

  • uspace/srv/hid/input/port/chardev.c

    ref09a7a r15f3c3f  
    4040#include <kbd_port.h>
    4141#include <kbd.h>
    42 #include <devmap.h>
     42#include <loc.h>
    4343#include <errno.h>
    4444#include <stdio.h>
    … …  
    7171static int chardev_port_init(kbd_dev_t *kdev)
    7272{
    73         devmap_handle_t handle;
     73        service_id_t service_id;
    7474        async_exch_t *exch;
    7575        unsigned int i;
    … …  
    7979       
    8080        for (i = 0; i < num_devs; i++) {
    81                 rc = devmap_device_get_handle(in_devs[i], &handle, 0);
     81                rc = loc_service_get_id(in_devs[i], &service_id, 0);
    8282                if (rc == EOK)
    8383                        break;
    … …  
    8989        }
    9090       
    91         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
     91        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
    9292            IPC_FLAG_BLOCKING);
    9393        if (dev_sess == NULL) {

  • uspace/srv/hid/input/port/chardev_mouse.c

    ref09a7a r15f3c3f  
    3939#include <async.h>
    4040#include <errno.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <input.h>
    4343#include <mouse_port.h>
    … …  
    8282static int chardev_port_init(mouse_dev_t *mdev)
    8383{
    84         devmap_handle_t handle;
     84        service_id_t service_id;
    8585        unsigned int i;
    8686        int rc;
    … …  
    8989       
    9090        for (i = 0; i < num_devs; i++) {
    91                 rc = devmap_device_get_handle(in_devs[i], &handle, 0);
     91                rc = loc_service_get_id(in_devs[i], &service_id, 0);
    9292                if (rc == EOK)
    9393                        break;
    … …  
    9999        }
    100100       
    101         dev_sess = devmap_device_connect(EXCHANGE_ATOMIC, handle,
     101        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
    102102            IPC_FLAG_BLOCKING);
    103103        if (dev_sess == NULL) {

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    ref09a7a r15f3c3f  
    3939#include <ddi.h>
    4040#include <libarch/ddi.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <io/console.h>
    4343#include <vfs/vfs.h>
    … …  
    9090        printf(NAME ": S3C24xx touchscreen driver\n");
    9191
    92         rc = devmap_driver_register(NAME, s3c24xx_ts_connection);
     92        rc = loc_server_register(NAME, s3c24xx_ts_connection);
    9393        if (rc < 0) {
    9494                printf(NAME ": Unable to register driver.\n");
    … …  
    103103                return -1;
    104104
    105         rc = devmap_device_register(NAMESPACE "/mouse", &ts->devmap_handle);
     105        rc = loc_service_register(NAMESPACE "/mouse", &ts->service_id);
    106106        if (rc != EOK) {
    107107                printf(NAME ": Unable to register device %s.\n",

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h

    ref09a7a r15f3c3f  
    124124        int client_phone;
    125125
    126         /** Device handle */
    127         devmap_handle_t devmap_handle;
     126        /** Service ID */
     127        service_id_t service_id;
    128128
    129129        /** Device/driver state */

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    ref09a7a r15f3c3f  
    4343#include <ddi.h>
    4444#include <libarch/ddi.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646#include <sysinfo.h>
    4747#include <errno.h>
    … …  
    147147int main(int argc, char *argv[])
    148148{
    149         devmap_handle_t devmap_handle;
     149        service_id_t service_id;
    150150        int rc;
    151151        int i;
    … …  
    155155        for (i = 0; i < ADB_MAX_ADDR; ++i) {
    156156                adb_dev[i].client_phone = -1;
    157                 adb_dev[i].devmap_handle = 0;
    158         }
    159 
    160         rc = devmap_driver_register(NAME, cuda_connection);
     157                adb_dev[i].service_id = 0;
     158        }
     159
     160        rc = loc_server_register(NAME, cuda_connection);
    161161        if (rc < 0) {
    162                 printf(NAME ": Unable to register driver.\n");
     162                printf(NAME ": Unable to register server.\n");
    163163                return rc;
    164164        }
    165165
    166         rc = devmap_device_register("adb/kbd", &devmap_handle);
     166        rc = loc_service_register("adb/kbd", &service_id);
    167167        if (rc != EOK) {
    168                 printf(NAME ": Unable to register device %s.\n", "adb/kdb");
     168                printf(NAME ": Unable to register service %s.\n", "adb/kdb");
    169169                return rc;
    170170        }
    171171
    172         adb_dev[2].devmap_handle = devmap_handle;
    173         adb_dev[8].devmap_handle = devmap_handle;
    174 
    175         rc = devmap_device_register("adb/mouse", &devmap_handle);
     172        adb_dev[2].service_id = service_id;
     173        adb_dev[8].service_id = service_id;
     174
     175        rc = loc_service_register("adb/mouse", &service_id);
    176176        if (rc != EOK) {
    177                 printf(NAME ": Unable to register device %s.\n", "adb/mouse");
     177                printf(NAME ": Unable to register servise %s.\n", "adb/mouse");
    178178                return rc;
    179179        }
    180180
    181         adb_dev[9].devmap_handle = devmap_handle;
     181        adb_dev[9].service_id = service_id;
    182182
    183183        if (cuda_init() < 0) {
    … …  
    198198        ipc_call_t call;
    199199        sysarg_t method;
    200         devmap_handle_t dh;
     200        service_id_t dsid;
    201201        int retval;
    202202        int dev_addr, i;
    203203
    204204        /* Get the device handle. */
    205         dh = IPC_GET_ARG1(*icall);
     205        dsid = IPC_GET_ARG1(*icall);
    206206
    207207        /* Determine which disk device is the client connecting to. */
    208208        dev_addr = -1;
    209209        for (i = 0; i < ADB_MAX_ADDR; i++) {
    210                 if (adb_dev[i].devmap_handle == dh)
     210                if (adb_dev[i].service_id == dsid)
    211211                        dev_addr = i;
    212212        }
    … …  
    242242                         */
    243243                        for (i = 0; i < ADB_MAX_ADDR; ++i) {
    244                                 if (adb_dev[i].devmap_handle == dh) {
     244                                if (adb_dev[i].service_id == dsid) {
    245245                                        adb_dev[i].client_phone = IPC_GET_ARG5(call);
    246246                                }

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.h

    ref09a7a r15f3c3f  
    3838
    3939#include <sys/types.h>
    40 #include <ipc/devmap.h>
     40#include <ipc/loc.h>
    4141#include <fibril_synch.h>
    4242
    … …  
    104104
    105105typedef struct {
    106         devmap_handle_t devmap_handle;
     106        service_id_t service_id;
    107107        int client_phone;
    108108} adb_dev_t;

  • uspace/srv/hw/char/i8042/i8042.c

    ref09a7a r15f3c3f  
    3939#include <ddi.h>
    4040#include <libarch/ddi.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <async.h>
    4343#include <async_obsolete.h>
    … …  
    135135        printf(NAME ": i8042 PS/2 port driver\n");
    136136
    137         rc = devmap_driver_register(NAME, i8042_connection);
     137        rc = loc_server_register(NAME, i8042_connection);
    138138        if (rc < 0) {
    139                 printf(NAME ": Unable to register driver.\n");
     139                printf(NAME ": Unable to register server.\n");
    140140                return rc;
    141141        }
    … …  
    148148
    149149                snprintf(name, 16, "%s/ps2%c", NAMESPACE, dchar[i]);
    150                 rc = devmap_device_register(name, &i8042_port[i].devmap_handle);
     150                rc = loc_service_register(name, &i8042_port[i].service_id);
    151151                if (rc != EOK) {
    152152                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    221221        ipc_call_t call;
    222222        sysarg_t method;
    223         devmap_handle_t dh;
     223        service_id_t dsid;
    224224        int retval;
    225225        int dev_id, i;
    … …  
    228228
    229229        /* Get the device handle. */
    230         dh = IPC_GET_ARG1(*icall);
     230        dsid = IPC_GET_ARG1(*icall);
    231231
    232232        /* Determine which disk device is the client connecting to. */
    233233        dev_id = -1;
    234234        for (i = 0; i < MAX_DEVS; i++) {
    235                 if (i8042_port[i].devmap_handle == dh)
     235                if (i8042_port[i].service_id == dsid)
    236236                        dev_id = i;
    237237        }

  • uspace/srv/hw/char/i8042/i8042.h

    ref09a7a r15f3c3f  
    5252/** Softstate structure, one for each serial port (primary and aux). */
    5353typedef struct {
    54         devmap_handle_t devmap_handle;
     54        service_id_t service_id;
    5555        int client_phone;
    5656} i8042_port_t;

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    ref09a7a r15f3c3f  
    3939#include <ddi.h>
    4040#include <libarch/ddi.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <ipc/char.h>
    4343#include <async.h>
    … …  
    8383        printf(NAME ": S3C24xx on-chip UART driver\n");
    8484
    85         rc = devmap_driver_register(NAME, s3c24xx_uart_connection);
     85        rc = loc_server_register(NAME, s3c24xx_uart_connection);
    8686        if (rc < 0) {
    87                 printf(NAME ": Unable to register driver.\n");
     87                printf(NAME ": Unable to register server.\n");
    8888                return -1;
    8989        }
    … …  
    9696                return -1;
    9797
    98         rc = devmap_device_register(NAMESPACE "/" NAME, &uart->devmap_handle);
     98        rc = loc_service_register(NAMESPACE "/" NAME, &uart->service_id);
    9999        if (rc != EOK) {
    100100                printf(NAME ": Unable to register device %s.\n",

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h

    ref09a7a r15f3c3f  
    8787        int client_phone;
    8888
    89         /** Device handle */
    90         devmap_handle_t devmap_handle;
     89        /** Service ID */
     90        service_id_t service_id;
    9191} s3c24xx_uart_t;
    9292

  • uspace/srv/hw/irc/apic/apic.c

    ref09a7a r15f3c3f  
    5050#include <async.h>
    5151#include <stdio.h>
    52 #include <ipc/devmap.h>
     52#include <ipc/loc.h>
    5353
    5454#define NAME  "apic"

  • uspace/srv/hw/irc/fhc/fhc.c

    ref09a7a r15f3c3f  
    4949#include <async.h>
    5050#include <stdio.h>
    51 #include <ipc/devmap.h>
     51#include <ipc/loc.h>
    5252
    5353#define NAME "fhc"

  • uspace/srv/hw/irc/i8259/i8259.c

    ref09a7a r15f3c3f  
    5050#include <async.h>
    5151#include <stdio.h>
    52 #include <ipc/devmap.h>
     52#include <ipc/loc.h>
    5353
    5454#define NAME  "i8259"

  • uspace/srv/hw/irc/obio/obio.c

    ref09a7a r15f3c3f  
    5555#include <async.h>
    5656#include <stdio.h>
    57 #include <ipc/devmap.h>
     57#include <ipc/loc.h>
    5858
    5959#define NAME "obio"

  • uspace/srv/loc/Makefile

    ref09a7a r15f3c3f  
    2929
    3030USPACE_PREFIX = ../..
    31 BINARY = devmap
     31BINARY = loc
    3232STATIC_NEEDED = y
    3333
    3434SOURCES = \
    35         devmap.c
     35        loc.c
    3636
    3737include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/vfs/vfs.h

    ref09a7a r15f3c3f  
    3838#include <fibril_synch.h>
    3939#include <sys/types.h>
    40 #include <devmap.h>
     40#include <loc.h>
    4141#include <bool.h>
    4242#include <ipc/vfs.h>
    … …  
    6161#define VFS_PAIR \
    6262        fs_handle_t fs_handle; \
    63         devmap_handle_t devmap_handle;
     63        service_id_t service_id;
    6464
    6565/**
    … …  
    6767 * doesn't contain any state. For a stateful structure, see vfs_node_t.
    6868 *
    69  * @note        fs_handle, devmap_handle and index are meant to be returned in one
     69 * @note        fs_handle, service_id and index are meant to be returned in one
    7070 *              IPC reply.
    7171 */
    … …  
    181181extern void vfs_node_put(vfs_node_t *);
    182182extern void vfs_node_forget(vfs_node_t *);
    183 extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, devmap_handle_t);
     183extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, service_id_t);
    184184
    185185

  • uspace/srv/vfs/vfs_file.c

    ref09a7a r15f3c3f  
    115115       
    116116        ipc_call_t answer;
    117         aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->devmap_handle,
     117        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
    118118            file->node->index, &answer);
    119119       

  • uspace/srv/vfs/vfs_lookup.c

    ref09a7a r15f3c3f  
    162162        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) first,
    163163            (sysarg_t) (first + len - 1) % PLB_SIZE,
    164             (sysarg_t) root->devmap_handle, (sysarg_t) lflag, (sysarg_t) index,
     164            (sysarg_t) root->service_id, (sysarg_t) lflag, (sysarg_t) index,
    165165            &answer);
    166166       
    … …  
    185185       
    186186        result->triplet.fs_handle = (fs_handle_t) rc;
    187         result->triplet.devmap_handle = (devmap_handle_t) IPC_GET_ARG1(answer);
     187        result->triplet.service_id = (service_id_t) IPC_GET_ARG1(answer);
    188188        result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
    189189        result->size =
    … …  
    212212        ipc_call_t answer;
    213213        aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
    214             (sysarg_t) result->triplet.devmap_handle,
     214            (sysarg_t) result->triplet.service_id,
    215215            (sysarg_t) result->triplet.index, &answer);
    216216       

  • uspace/srv/vfs/vfs_node.c

    ref09a7a r15f3c3f  
    116116                unsigned long key[] = {
    117117                        [KEY_FS_HANDLE] = node->fs_handle,
    118                         [KEY_DEV_HANDLE] = node->devmap_handle,
     118                        [KEY_DEV_HANDLE] = node->service_id,
    119119                        [KEY_INDEX] = node->index
    120120                };
    … …  
    138138                async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    139139                sysarg_t rc = async_req_2_0(exch, VFS_OUT_DESTROY,
    140                     (sysarg_t) node->devmap_handle, (sysarg_t)node->index);
     140                    (sysarg_t) node->service_id, (sysarg_t)node->index);
    141141               
    142142                assert(rc == EOK);
    … …  
    160160        unsigned long key[] = {
    161161                [KEY_FS_HANDLE] = node->fs_handle,
    162                 [KEY_DEV_HANDLE] = node->devmap_handle,
     162                [KEY_DEV_HANDLE] = node->service_id,
    163163                [KEY_INDEX] = node->index
    164164        };
    … …  
    184184        unsigned long key[] = {
    185185                [KEY_FS_HANDLE] = result->triplet.fs_handle,
    186                 [KEY_DEV_HANDLE] = result->triplet.devmap_handle,
     186                [KEY_DEV_HANDLE] = result->triplet.service_id,
    187187                [KEY_INDEX] = result->triplet.index
    188188        };
    … …  
    200200                memset(node, 0, sizeof(vfs_node_t));
    201201                node->fs_handle = result->triplet.fs_handle;
    202                 node->devmap_handle = result->triplet.devmap_handle;
     202                node->service_id = result->triplet.service_id;
    203203                node->index = result->triplet.index;
    204204                node->size = result->size;
    … …  
    252252        vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
    253253        return (node->fs_handle == (fs_handle_t) key[KEY_FS_HANDLE]) &&
    254             (node->devmap_handle == key[KEY_DEV_HANDLE]) &&
     254            (node->service_id == key[KEY_DEV_HANDLE]) &&
    255255            (node->index == key[KEY_INDEX]);
    256256}
    … …  
    264264        unsigned refcnt;
    265265        fs_handle_t fs_handle;
    266         devmap_handle_t devmap_handle;
     266        service_id_t service_id;
    267267};
    268268
    … …  
    273273
    274274        if ((node->fs_handle == rd->fs_handle) &&
    275             (node->devmap_handle == rd->devmap_handle))
     275            (node->service_id == rd->service_id))
    276276                rd->refcnt += node->refcnt;
    277277}
    278278
    279279unsigned
    280 vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle)
     280vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, service_id_t service_id)
    281281{
    282282        struct refcnt_data rd = {
    283283                .refcnt = 0,
    284284                .fs_handle = fs_handle,
    285                 .devmap_handle = devmap_handle
     285                .service_id = service_id
    286286        };
    287287

  • uspace/srv/vfs/vfs_ops.c

    ref09a7a r15f3c3f  
    5454
    5555/* Forward declarations of static functions. */
    56 static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
     56static int vfs_truncate_internal(fs_handle_t, service_id_t, fs_index_t,
    5757    aoff64_t);
    5858
    … …  
    6565vfs_pair_t rootfs = {
    6666        .fs_handle = 0,
    67         .devmap_handle = 0
     67        .service_id = 0
    6868};
    6969
    70 static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
     70static void vfs_mount_internal(ipc_callid_t rid, service_id_t service_id,
    7171    fs_handle_t fs_handle, char *mp, char *opts)
    7272{
    … …  
    125125                        exch = vfs_exchange_grab(fs_handle);
    126126                        msg = async_send_1(exch, VFS_OUT_MOUNTED,
    127                             (sysarg_t) devmap_handle, &answer);
     127                            (sysarg_t) service_id, &answer);
    128128                        /* Send the mount options */
    129129                        rc = async_data_write_start(exch, (void *)opts,
    … …  
    150150                       
    151151                        mr_res.triplet.fs_handle = fs_handle;
    152                         mr_res.triplet.devmap_handle = devmap_handle;
     152                        mr_res.triplet.service_id = service_id;
    153153                        mr_res.triplet.index = rindex;
    154154                        mr_res.size = rsize;
    … …  
    157157                       
    158158                        rootfs.fs_handle = fs_handle;
    159                         rootfs.devmap_handle = devmap_handle;
     159                        rootfs.service_id = service_id;
    160160                       
    161161                        /* Add reference to the mounted root. */
    … …  
    178178       
    179179        /*
    180          * At this point, we have all necessary pieces: file system and device
    181          * handles, and we know the mount point VFS node.
     180         * At this point, we have all necessary pieces: file system handle
     181         * and service ID, and we know the mount point VFS node.
    182182         */
    183183       
    … …  
    187187        exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
    188188        msg = async_send_4(exch, VFS_OUT_MOUNT,
    189             (sysarg_t) mp_res.triplet.devmap_handle,
     189            (sysarg_t) mp_res.triplet.service_id,
    190190            (sysarg_t) mp_res.triplet.index,
    191191            (sysarg_t) fs_handle,
    192             (sysarg_t) devmap_handle, &answer);
     192            (sysarg_t) service_id, &answer);
    193193       
    194194        /* Send connection */
    … …  
    233233               
    234234                mr_res.triplet.fs_handle = fs_handle;
    235                 mr_res.triplet.devmap_handle = devmap_handle;
     235                mr_res.triplet.service_id = service_id;
    236236                mr_res.triplet.index = rindex;
    237237                mr_res.size = rsize;
    … …  
    254254void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
    255255{
    256         devmap_handle_t devmap_handle;
     256        service_id_t service_id;
    257257
    258258        /*
    … …  
    261261         * in the request.
    262262         */
    263         devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     263        service_id = (service_id_t) IPC_GET_ARG1(*request);
    264264       
    265265        /*
    … …  
    349349       
    350350        /* Do the mount */
    351         vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
     351        vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
    352352        free(mp);
    353353        free(fs_name);
    … …  
    408408         */
    409409        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    410             mr_node->devmap_handle) != 2) {
     410            mr_node->service_id) != 2) {
    411411                fibril_rwlock_write_unlock(&namespace_rwlock);
    412412                vfs_node_put(mr_node);
    … …  
    429429                exch = vfs_exchange_grab(mr_node->fs_handle);
    430430                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    431                     mr_node->devmap_handle);
     431                    mr_node->service_id);
    432432                vfs_exchange_release(exch);
    433433               
    … …  
    440440               
    441441                rootfs.fs_handle = 0;
    442                 rootfs.devmap_handle = 0;
     442                rootfs.service_id = 0;
    443443        } else {
    444444               
    … …  
    469469                exch = vfs_exchange_grab(mp_node->fs_handle);
    470470                rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
    471                     mp_node->devmap_handle, mp_node->index);
     471                    mp_node->service_id, mp_node->index);
    472472                vfs_exchange_release(exch);
    473473               
    … …  
    574574                if (node->size) {
    575575                        rc = vfs_truncate_internal(node->fs_handle,
    576                             node->devmap_handle, node->index, 0);
     576                            node->service_id, node->index, 0);
    577577                        if (rc) {
    578578                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    627627       
    628628        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
    629         lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
     629        lr.triplet.service_id = IPC_GET_ARG2(*request);
    630630        lr.triplet.index = IPC_GET_ARG3(*request);
    631631        int oflag = IPC_GET_ARG4(*request);
    … …  
    648648                if (node->size) {
    649649                        rc = vfs_truncate_internal(node->fs_handle,
    650                             node->devmap_handle, node->index, 0);
     650                            node->service_id, node->index, 0);
    651651                        if (rc) {
    652652                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    711711        aid_t msg;
    712712        ipc_call_t answer;
    713         msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
     713        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
    714714            file->node->index, &answer);
    715715       
    … …  
    796796        if (read) {
    797797                rc = async_data_read_forward_3_1(fs_exch, VFS_OUT_READ,
    798                     file->node->devmap_handle, file->node->index, file->pos,
     798                    file->node->service_id, file->node->index, file->pos,
    799799                    &answer);
    800800        } else {
    … …  
    803803               
    804804                rc = async_data_write_forward_3_1(fs_exch, VFS_OUT_WRITE,
    805                     file->node->devmap_handle, file->node->index, file->pos,
     805                    file->node->service_id, file->node->index, file->pos,
    806806                    &answer);
    807807        }
    … …  
    933933}
    934934
    935 int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     935int vfs_truncate_internal(fs_handle_t fs_handle, service_id_t service_id,
    936936    fs_index_t index, aoff64_t size)
    937937{
    938938        async_exch_t *exch = vfs_exchange_grab(fs_handle);
    939939        sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
    940             (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
     940            (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
    941941            UPPER32(size));
    942942        vfs_exchange_release(exch);
    … …  
    961961        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    962962        rc = vfs_truncate_internal(file->node->fs_handle,
    963             file->node->devmap_handle, file->node->index, size);
     963            file->node->service_id, file->node->index, size);
    964964        if (rc == EOK)
    965965                file->node->size = size;
    … …  
    995995       
    996996        aid_t msg;
    997         msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
     997        msg = async_send_3(exch, VFS_OUT_STAT, file->node->service_id,
    998998            file->node->index, true, NULL);
    999999        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    10481048       
    10491049        aid_t msg;
    1050         msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
     1050        msg = async_send_3(exch, VFS_OUT_STAT, node->service_id,
    10511051            node->index, false, NULL);
    10521052        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    12251225        /* Check whether linking to the same file system instance. */
    12261226        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1227             (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
     1227            (old_node->service_id != new_par_lr.triplet.service_id)) {
    12281228                fibril_rwlock_write_unlock(&namespace_rwlock);
    12291229                vfs_node_put(old_node);

  • uspace/srv/vfs/vfs_register.c

    ref09a7a r15f3c3f  
    306306        list_foreach(fs_list, cur) {
    307307                fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
    308                 if (str_cmp(fs->vfs_info.name, name) == 0) { 
     308                if (str_cmp(fs->vfs_info.name, name) == 0) {
    309309                        handle = fs->fs_handle;
    310310                        break;
Note: See TracChangeset for help on using the changeset viewer.