Changeset 16dc887 in mainline for uspace/srv


Ignore:
Timestamp:
2011-08-16T14:00:32Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
278ac72, b112055
Parents:
3751a08 (diff), cc574511 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge Location service.

Location:
uspace/srv
Files:
4 added
1 deleted
45 edited
6 moved

Legend:

Unmodified
Added
Removed

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

    r3751a08 r16dc887  
    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>
    … …  
    176176               
    177177                snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
    178                 rc = devmap_device_register(name, &disk[i].devmap_handle);
     178                rc = loc_service_register(name, &disk[i].service_id);
    179179                if (rc != EOK) {
    180180                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    244244        int rc;
    245245
    246         rc = devmap_driver_register(NAME, ata_bd_connection);
     246        rc = loc_server_register(NAME, ata_bd_connection);
    247247        if (rc < 0) {
    248248                printf(NAME ": Unable to register driver.\n");
    … …  
    277277        ipc_call_t call;
    278278        sysarg_t method;
    279         devmap_handle_t dh;
     279        service_id_t dsid;
    280280        size_t comm_size;       /**< Size of the communication area. */
    281281        unsigned int flags;
    … …  
    285285        int disk_id, i;
    286286
    287         /* Get the device handle. */
    288         dh = IPC_GET_ARG1(*icall);
     287        /* Get the device service ID. */
     288        dsid = IPC_GET_ARG1(*icall);
    289289
    290290        /* Determine which disk device is the client connecting to. */
    291291        disk_id = -1;
    292292        for (i = 0; i < MAX_DISKS; i++)
    293                 if (disk[i].devmap_handle == dh)
     293                if (disk[i].service_id == dsid)
    294294                        disk_id = i;
    295295

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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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};
    … …  
    701701}
    702702
    703 /** Create devmap path and name for the function. */
    704 void devmap_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
    705 {
    706         char *devmap_pathname = NULL;
    707         char *devmap_name = NULL;
    708        
    709         asprintf(&devmap_name, "%s", fun->pathname);
    710         if (devmap_name == NULL)
     703/** Create loc path and name for the function. */
     704void loc_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
     705{
     706        char *loc_pathname = NULL;
     707        char *loc_name = NULL;
     708       
     709        asprintf(&loc_name, "%s", fun->pathname);
     710        if (loc_name == NULL)
    711711                return;
    712712       
    713         replace_char(devmap_name, '/', DEVMAP_SEPARATOR);
    714        
    715         asprintf(&devmap_pathname, "%s/%s", DEVMAP_DEVICE_NAMESPACE,
    716             devmap_name);
    717         if (devmap_pathname == NULL) {
    718                 free(devmap_name);
     713        replace_char(loc_name, '/', LOC_SEPARATOR);
     714       
     715        asprintf(&loc_pathname, "%s/%s", LOC_DEVICE_NAMESPACE,
     716            loc_name);
     717        if (loc_pathname == NULL) {
     718                free(loc_name);
    719719                return;
    720720        }
    721721       
    722         devmap_device_register_with_iface(devmap_pathname,
    723             &fun->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
    724        
    725         tree_add_devmap_function(tree, fun);
    726        
    727         free(devmap_name);
    728         free(devmap_pathname);
     722        loc_service_register_with_iface(loc_pathname,
     723            &fun->service_id, DEVMAN_CONNECT_FROM_LOC);
     724       
     725        tree_add_loc_function(tree, fun);
     726       
     727        free(loc_name);
     728        free(loc_pathname);
    729729}
    730730
    … …  
    856856        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
    857857            &devman_functions_ops);
    858         hash_table_create(&tree->devmap_functions, DEVICE_BUCKETS, 1,
    859             &devmap_devices_ops);
     858        hash_table_create(&tree->loc_functions, DEVICE_BUCKETS, 1,
     859            &loc_devices_ops);
    860860       
    861861        fibril_rwlock_initialize(&tree->rwlock);
    … …  
    952952                list_initialize(&res->classes);
    953953                link_initialize(&res->devman_fun);
    954                 link_initialize(&res->devmap_fun);
     954                link_initialize(&res->loc_fun);
    955955        }
    956956       
    … …  
    12681268                memset(info, 0, sizeof(dev_class_info_t));
    12691269                link_initialize(&info->dev_classes);
    1270                 link_initialize(&info->devmap_link);
     1270                link_initialize(&info->loc_link);
    12711271                link_initialize(&info->link);
    12721272        }
    … …  
    14141414        list_initialize(&class_list->classes);
    14151415        fibril_rwlock_initialize(&class_list->rwlock);
    1416         hash_table_create(&class_list->devmap_functions, DEVICE_BUCKETS, 1,
    1417             &devmap_devices_class_ops);
    1418 }
    1419 
    1420 
    1421 /* Devmap devices */
    1422 
    1423 fun_node_t *find_devmap_tree_function(dev_tree_t *tree, devmap_handle_t devmap_handle)
     1416        hash_table_create(&class_list->loc_functions, DEVICE_BUCKETS, 1,
     1417            &loc_devices_class_ops);
     1418}
     1419
     1420
     1421/* loc devices */
     1422
     1423fun_node_t *find_loc_tree_function(dev_tree_t *tree, service_id_t service_id)
    14241424{
    14251425        fun_node_t *fun = NULL;
    14261426        link_t *link;
    1427         unsigned long key = (unsigned long) devmap_handle;
     1427        unsigned long key = (unsigned long) service_id;
    14281428       
    14291429        fibril_rwlock_read_lock(&tree->rwlock);
    1430         link = hash_table_find(&tree->devmap_functions, &key);
     1430        link = hash_table_find(&tree->loc_functions, &key);
    14311431        if (link != NULL)
    1432                 fun = hash_table_get_instance(link, fun_node_t, devmap_fun);
     1432                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
    14331433        fibril_rwlock_read_unlock(&tree->rwlock);
    14341434       
    … …  
    14361436}
    14371437
    1438 fun_node_t *find_devmap_class_function(class_list_t *classes,
    1439     devmap_handle_t devmap_handle)
     1438fun_node_t *find_loc_class_function(class_list_t *classes,
     1439    service_id_t service_id)
    14401440{
    14411441        fun_node_t *fun = NULL;
    14421442        dev_class_info_t *cli;
    14431443        link_t *link;
    1444         unsigned long key = (unsigned long)devmap_handle;
     1444        unsigned long key = (unsigned long)service_id;
    14451445       
    14461446        fibril_rwlock_read_lock(&classes->rwlock);
    1447         link = hash_table_find(&classes->devmap_functions, &key);
     1447        link = hash_table_find(&classes->loc_functions, &key);
    14481448        if (link != NULL) {
    14491449                cli = hash_table_get_instance(link, dev_class_info_t,
    1450                     devmap_link);
     1450                    loc_link);
    14511451                fun = cli->fun;
    14521452        }
    … …  
    14561456}
    14571457
    1458 void class_add_devmap_function(class_list_t *class_list, dev_class_info_t *cli)
    1459 {
    1460         unsigned long key = (unsigned long) cli->devmap_handle;
     1458void class_add_loc_function(class_list_t *class_list, dev_class_info_t *cli)
     1459{
     1460        unsigned long key = (unsigned long) cli->service_id;
    14611461       
    14621462        fibril_rwlock_write_lock(&class_list->rwlock);
    1463         hash_table_insert(&class_list->devmap_functions, &key, &cli->devmap_link);
     1463        hash_table_insert(&class_list->loc_functions, &key, &cli->loc_link);
    14641464        fibril_rwlock_write_unlock(&class_list->rwlock);
    14651465
    1466         assert(find_devmap_class_function(class_list, cli->devmap_handle) != NULL);
    1467 }
    1468 
    1469 void tree_add_devmap_function(dev_tree_t *tree, fun_node_t *fun)
    1470 {
    1471         unsigned long key = (unsigned long) fun->devmap_handle;
     1466        assert(find_loc_class_function(class_list, cli->service_id) != NULL);
     1467}
     1468
     1469void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
     1470{
     1471        unsigned long key = (unsigned long) fun->service_id;
    14721472        fibril_rwlock_write_lock(&tree->rwlock);
    1473         hash_table_insert(&tree->devmap_functions, &key, &fun->devmap_fun);
     1473        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    14741474        fibril_rwlock_write_unlock(&tree->rwlock);
    14751475}

  • uspace/srv/devman/devman.h

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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
    … …  
    362362{
    363363        devman_handle_t handle = IPC_GET_ARG1(*call);
     364        category_id_t cat_id;
     365        int rc;
    364366       
    365367        /* Get class name. */
    366368        char *class_name;
    367         int rc = async_data_write_accept((void **) &class_name, true,
     369        rc = async_data_write_accept((void **) &class_name, true,
    368370            0, 0, 0, 0);
    369371        if (rc != EOK) {
    … …  
    381383        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
    382384       
    383         /* Register the device's class alias by devmapper. */
    384         devmap_register_class_dev(class_info);
     385        /* Register the device's class alias with location service. */
     386        loc_register_class_dev(class_info);
     387       
     388        rc = loc_category_get_id(class_name, &cat_id, IPC_FLAG_BLOCKING);
     389        if (rc == EOK) {
     390                loc_service_add_to_cat(fun->service_id, cat_id);
     391        } else {
     392                log_msg(LVL_ERROR, "Failed adding function `%s' to category "
     393                    "`%s'.", fun->pathname, class_name);
     394        }
    385395       
    386396        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
    … …  
    659669}
    660670
    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);
     671/** Function for handling connections from a client forwarded by the location
     672 * service to the device manager. */
     673static void devman_connection_loc(ipc_callid_t iid, ipc_call_t *icall)
     674{
     675        service_id_t service_id = IPC_GET_ARG2(*icall);
    666676        fun_node_t *fun;
    667677        dev_node_t *dev;
    668678
    669         fun = find_devmap_tree_function(&device_tree, devmap_handle);
     679        fun = find_loc_tree_function(&device_tree, service_id);
    670680        if (fun == NULL)
    671                 fun = find_devmap_class_function(&class_list, devmap_handle);
     681                fun = find_loc_class_function(&class_list, service_id);
    672682       
    673683        if (fun == NULL || fun->dev->drv == NULL) {
    … …  
    689699       
    690700        log_msg(LVL_DEBUG,
    691             "Forwarding devmapper request for `%s' function to driver `%s'.",
     701            "Forwarding loc service request for `%s' function to driver `%s'.",
    692702            fun->pathname, dev->drv->name);
    693703}
    … …  
    708718                devman_forward(iid, icall, false);
    709719                break;
    710         case DEVMAN_CONNECT_FROM_DEVMAP:
    711                 /* Someone connected through devmap node. */
    712                 devman_connection_devmapper(iid, icall);
     720        case DEVMAN_CONNECT_FROM_LOC:
     721                /* Someone connected through loc node. */
     722                devman_connection_loc(iid, icall);
    713723                break;
    714724        case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
    … …  
    746756       
    747757        /*
    748          * !!! devman_connection ... as the device manager is not a real devmap
     758         * !!! devman_connection ... as the device manager is not a real loc
    749759         * 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.
     760         * loc driver) forwarding a connection from client to the devman by
     761         * location service would not work.
    752762         */
    753         devmap_driver_register(NAME, devman_connection);
     763        loc_server_register(NAME, devman_connection);
    754764       
    755765        return true;
    … …  
    760770        printf(NAME ": HelenOS Device Manager\n");
    761771
    762         if (log_init(NAME, LVL_ERROR) != EOK) {
     772        if (log_init(NAME, LVL_WARN) != EOK) {
    763773                printf(NAME ": Error initializing logging subsystem.\n");
    764774                return -1;

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

    r3751a08 r16dc887  
    4242#include <libext2.h>
    4343#include <ipc/services.h>
    44 #include <ipc/devmap.h>
     44#include <ipc/loc.h>
    4545#include <macros.h>
    4646#include <async.h>
    … …  
    6969typedef struct ext2fs_instance {
    7070        link_t link;
    71         devmap_handle_t devmap_handle;
     71        service_id_t service_id;
    7272        ext2_filesystem_t *filesystem;
    7373        unsigned int open_nodes_count;
    … …  
    8585 * Forward declarations of auxiliary functions
    8686 */
    87 static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_t **);
     87static int ext2fs_instance_get(service_id_t, ext2fs_instance_t **);
    8888static int ext2fs_read_directory(ipc_callid_t, aoff64_t, size_t,
    8989    ext2fs_instance_t *, ext2_inode_ref_t *, size_t *);
    … …  
    9797 * Forward declarations of EXT2 libfs operations.
    9898 */
    99 static int ext2fs_root_get(fs_node_t **, devmap_handle_t);
     99static int ext2fs_root_get(fs_node_t **, service_id_t);
    100100static int ext2fs_match(fs_node_t **, fs_node_t *, const char *);
    101 static int ext2fs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     101static int ext2fs_node_get(fs_node_t **, service_id_t, fs_index_t);
    102102static int ext2fs_node_open(fs_node_t *);
    103103static int ext2fs_node_put(fs_node_t *);
    104 static int ext2fs_create_node(fs_node_t **, devmap_handle_t, int);
     104static int ext2fs_create_node(fs_node_t **, service_id_t, int);
    105105static int ext2fs_destroy_node(fs_node_t *);
    106106static int ext2fs_link(fs_node_t *, fs_node_t *, const char *);
    … …  
    112112static bool ext2fs_is_directory(fs_node_t *);
    113113static bool ext2fs_is_file(fs_node_t *node);
    114 static devmap_handle_t ext2fs_device_get(fs_node_t *node);
     114static service_id_t ext2fs_device_get(fs_node_t *node);
    115115
    116116/*
    … …  
    134134        ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
    135135        assert(keys > 0);
    136         if (enode->instance->devmap_handle !=
    137             ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
     136        if (enode->instance->service_id !=
     137            ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
    138138                return false;
    139139        }
    … …  
    180180
    181181/**
    182  * Find an instance of filesystem for the given devmap_handle
    183  */
    184 int ext2fs_instance_get(devmap_handle_t devmap_handle, ext2fs_instance_t **inst)
    185 {
    186         EXT2FS_DBG("(%" PRIun ", -)", devmap_handle);
     182 * Find an instance of filesystem for the given service_id
     183 */
     184int ext2fs_instance_get(service_id_t service_id, ext2fs_instance_t **inst)
     185{
     186        EXT2FS_DBG("(%" PRIun ", -)", service_id);
    187187        ext2fs_instance_t *tmp;
    188188       
    … …  
    198198                tmp = list_get_instance(link, ext2fs_instance_t, link);
    199199               
    200                 if (tmp->devmap_handle == devmap_handle) {
     200                if (tmp->service_id == service_id) {
    201201                        *inst = tmp;
    202202                        fibril_mutex_unlock(&instance_list_mutex);
    … …  
    213213
    214214
    215 int ext2fs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    216 {
    217         EXT2FS_DBG("(-, %" PRIun ")", devmap_handle);
    218         return ext2fs_node_get(rfn, devmap_handle, EXT2_INODE_ROOT_INDEX);
     215int ext2fs_root_get(fs_node_t **rfn, service_id_t service_id)
     216{
     217        EXT2FS_DBG("(-, %" PRIun ")", service_id);
     218        return ext2fs_node_get(rfn, service_id, EXT2_INODE_ROOT_INDEX);
    219219}
    220220
    … …  
    289289
    290290/** Instantiate a EXT2 in-core node. */
    291 int ext2fs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    292 {
    293         EXT2FS_DBG("(-,%" PRIun ",%u)", devmap_handle, index);
     291int ext2fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     292{
     293        EXT2FS_DBG("(-,%" PRIun ",%u)", service_id, index);
    294294       
    295295        ext2fs_instance_t *inst = NULL;
    296296        int rc;
    297297       
    298         rc = ext2fs_instance_get(devmap_handle, &inst);
     298        rc = ext2fs_instance_get(service_id, &inst);
    299299        if (rc != EOK) {
    300300                return rc;
    … …  
    317317        /* Check if the node is not already open */
    318318        unsigned long key[] = {
    319                 [OPEN_NODES_DEV_HANDLE_KEY] = inst->devmap_handle,
     319                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
    320320                [OPEN_NODES_INODE_KEY] = index,
    321321        };
    … …  
    411411
    412412        unsigned long key[] = {
    413                 [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->devmap_handle,
     413                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
    414414                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
    415415        };
    … …  
    429429}
    430430
    431 int ext2fs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     431int ext2fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    432432{
    433433        EXT2FS_DBG("");
    … …  
    557557}
    558558
    559 devmap_handle_t ext2fs_device_get(fs_node_t *fn)
     559service_id_t ext2fs_device_get(fs_node_t *fn)
    560560{
    561561        EXT2FS_DBG("");
    562562        ext2fs_node_t *enode = EXT2FS_NODE(fn);
    563         return enode->instance->devmap_handle;
     563        return enode->instance->service_id;
    564564}
    565565
    … …  
    588588 */
    589589
    590 static int ext2fs_mounted(devmap_handle_t devmap_handle, const char *opts,
     590static int ext2fs_mounted(service_id_t service_id, const char *opts,
    591591   fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    592592{
    … …  
    610610       
    611611        /* Initialize the filesystem  */
    612         rc = ext2_filesystem_init(fs, devmap_handle);
     612        rc = ext2_filesystem_init(fs, service_id);
    613613        if (rc != EOK) {
    614614                free(fs);
    … …  
    637637        /* Initialize instance */
    638638        link_initialize(&inst->link);
    639         inst->devmap_handle = devmap_handle;
     639        inst->service_id = service_id;
    640640        inst->filesystem = fs;
    641641        inst->open_nodes_count = 0;
    … …  
    666666}
    667667
    668 static int ext2fs_unmounted(devmap_handle_t devmap_handle)
     668static int ext2fs_unmounted(service_id_t service_id)
    669669{
    670670        EXT2FS_DBG("");
    … …  
    672672        int rc;
    673673       
    674         rc = ext2fs_instance_get(devmap_handle, &inst);
     674        rc = ext2fs_instance_get(service_id, &inst);
    675675       
    676676        if (rc != EOK)
    … …  
    698698
    699699static int
    700 ext2fs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     700ext2fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    701701    size_t *rbytes)
    702702{
    … …  
    717717        }
    718718       
    719         rc = ext2fs_instance_get(devmap_handle, &inst);
     719        rc = ext2fs_instance_get(service_id, &inst);
    720720        if (rc != EOK) {
    721721                async_answer_0(callid, rc);
    … …  
    907907       
    908908        /* Usual case - we need to read a block from device */
    909         rc = block_get(&block, inst->devmap_handle, fs_block, BLOCK_FLAGS_NONE);
     909        rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
    910910        if (rc != EOK) {
    911911                async_answer_0(callid, rc);
    … …  
    925925
    926926static int
    927 ext2fs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     927ext2fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    928928    size_t *wbytes, aoff64_t *nsize)
    929929{
    … …  
    933933
    934934static int
    935 ext2fs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     935ext2fs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    936936{
    937937        EXT2FS_DBG("");
    … …  
    939939}
    940940
    941 static int ext2fs_close(devmap_handle_t devmap_handle, fs_index_t index)
    942 {
    943         EXT2FS_DBG("");
    944         return EOK;
    945 }
    946 
    947 static int ext2fs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     941static int ext2fs_close(service_id_t service_id, fs_index_t index)
     942{
     943        EXT2FS_DBG("");
     944        return EOK;
     945}
     946
     947static int ext2fs_destroy(service_id_t service_id, fs_index_t index)
    948948{
    949949        EXT2FS_DBG("");
    … …  
    951951}
    952952
    953 static int ext2fs_sync(devmap_handle_t devmap_handle, fs_index_t index)
     953static int ext2fs_sync(service_id_t service_id, fs_index_t index)
    954954{
    955955        EXT2FS_DBG("");

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

    r3751a08 r16dc887  
    175175
    176176        fibril_mutex_t  lock;
    177         devmap_handle_t devmap_handle;
     177        service_id_t    service_id;
    178178        fs_index_t      index;
    179179        /**
    … …  
    227227extern libfs_ops_t fat_libfs_ops;
    228228
    229 extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t);
    230 extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned);
    231 extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t);
     229extern int fat_idx_get_new(fat_idx_t **, service_id_t);
     230extern fat_idx_t *fat_idx_get_by_pos(service_id_t, fat_cluster_t, unsigned);
     231extern fat_idx_t *fat_idx_get_by_index(service_id_t, fs_index_t);
    232232extern void fat_idx_destroy(fat_idx_t *);
    233233extern void fat_idx_hashin(fat_idx_t *);
    … …  
    236236extern int fat_idx_init(void);
    237237extern void fat_idx_fini(void);
    238 extern int fat_idx_init_by_devmap_handle(devmap_handle_t);
    239 extern void fat_idx_fini_by_devmap_handle(devmap_handle_t);
     238extern int fat_idx_init_by_service_id(service_id_t);
     239extern void fat_idx_fini_by_service_id(service_id_t);
    240240
    241241#endif

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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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 *);
    … …  
    8787static bool fat_is_directory(fs_node_t *);
    8888static bool fat_is_file(fs_node_t *node);
    89 static devmap_handle_t fat_device_get(fs_node_t *node);
     89static service_id_t fat_device_get(fs_node_t *node);
    9090
    9191/*
    … …  
    119119        assert(node->dirty);
    120120
    121         bs = block_bb_get(node->idx->devmap_handle);
     121        bs = block_bb_get(node->idx->service_id);
    122122       
    123123        /* Read the block that contains the dentry of interest. */
    124         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
     124        rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
    125125            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    126126            BLOCK_FLAGS_NONE);
    … …  
    144144}
    145145
    146 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     146static int fat_node_fini_by_service_id(service_id_t service_id)
    147147{
    148148        fat_node_t *nodep;
    … …  
    168168                        goto restart;
    169169                }
    170                 if (nodep->idx->devmap_handle != devmap_handle) {
     170                if (nodep->idx->service_id != service_id) {
    171171                        fibril_mutex_unlock(&nodep->idx->lock);
    172172                        fibril_mutex_unlock(&nodep->lock);
    … …  
    298298                return rc;
    299299
    300         bs = block_bb_get(idxp->devmap_handle);
     300        bs = block_bb_get(idxp->service_id);
    301301
    302302        /* Read the block that contains the dentry of interest. */
    303         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
     303        rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL,
    304304            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    305305        if (rc != EOK) {
    … …  
    322322                 */
    323323                uint16_t clusters;
    324                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     324                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
    325325                    uint16_t_le2host(d->firstc));
    326326                if (rc != EOK) {
    … …  
    356356 */
    357357
    358 int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    359 {
    360         return fat_node_get(rfn, devmap_handle, 0);
     358int fat_root_get(fs_node_t **rfn, service_id_t service_id)
     359{
     360        return fat_node_get(rfn, service_id, 0);
    361361}
    362362
    … …  
    369369        unsigned blocks;
    370370        fat_dentry_t *d;
    371         devmap_handle_t devmap_handle;
     371        service_id_t service_id;
    372372        block_t *b;
    373373        int rc;
    374374
    375375        fibril_mutex_lock(&parentp->idx->lock);
    376         devmap_handle = parentp->idx->devmap_handle;
     376        service_id = parentp->idx->service_id;
    377377        fibril_mutex_unlock(&parentp->idx->lock);
    378378
    379         bs = block_bb_get(devmap_handle);
     379        bs = block_bb_get(service_id);
    380380        blocks = parentp->size / BPS(bs);
    381381        for (i = 0; i < blocks; i++) {
    … …  
    402402                                /* hit */
    403403                                fat_node_t *nodep;
    404                                 fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
     404                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
    405405                                    parentp->firstc, i * DPS(bs) + j);
    406406                                if (!idx) {
    … …  
    435435
    436436/** Instantiate a FAT in-core node. */
    437 int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     437int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    438438{
    439439        fat_node_t *nodep;
    … …  
    441441        int rc;
    442442
    443         idxp = fat_idx_get_by_index(devmap_handle, index);
     443        idxp = fat_idx_get_by_index(service_id, index);
    444444        if (!idxp) {
    445445                *rfn = NULL;
    … …  
    492492}
    493493
    494 int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     494int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    495495{
    496496        fat_idx_t *idxp;
    … …  
    500500        int rc;
    501501
    502         bs = block_bb_get(devmap_handle);
     502        bs = block_bb_get(service_id);
    503503        if (flags & L_DIRECTORY) {
    504504                /* allocate a cluster */
    505                 rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
     505                rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl);
    506506                if (rc != EOK)
    507507                        return rc;
    508508                /* populate the new cluster with unused dentries */
    509                 rc = fat_zero_cluster(bs, devmap_handle, mcl);
     509                rc = fat_zero_cluster(bs, service_id, mcl);
    510510                if (rc != EOK) {
    511                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     511                        (void) fat_free_clusters(bs, service_id, mcl);
    512512                        return rc;
    513513                }
    … …  
    516516        rc = fat_node_get_new(&nodep);
    517517        if (rc != EOK) {
    518                 (void) fat_free_clusters(bs, devmap_handle, mcl);
    519                 return rc;
    520         }
    521         rc = fat_idx_get_new(&idxp, devmap_handle);
     518                (void) fat_free_clusters(bs, service_id, mcl);
     519                return rc;
     520        }
     521        rc = fat_idx_get_new(&idxp, service_id);
    522522        if (rc != EOK) {
    523                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     523                (void) fat_free_clusters(bs, service_id, mcl); 
    524524                (void) fat_node_put(FS_NODE(nodep));
    525525                return rc;
    … …  
    570570        assert(!has_children);
    571571
    572         bs = block_bb_get(nodep->idx->devmap_handle);
     572        bs = block_bb_get(nodep->idx->service_id);
    573573        if (nodep->firstc != FAT_CLST_RES0) {
    574574                assert(nodep->size);
    575575                /* Free all clusters allocated to the node. */
    576                 rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
     576                rc = fat_free_clusters(bs, nodep->idx->service_id,
    577577                    nodep->firstc);
    578578        }
    … …  
    620620       
    621621        fibril_mutex_lock(&parentp->idx->lock);
    622         bs = block_bb_get(parentp->idx->devmap_handle);
     622        bs = block_bb_get(parentp->idx->service_id);
    623623
    624624        blocks = parentp->size / BPS(bs);
    … …  
    659659                return ENOSPC;
    660660        }
    661         rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
     661        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl);
    662662        if (rc != EOK) {
    663663                fibril_mutex_unlock(&parentp->idx->lock);
    664664                return rc;
    665665        }
    666         rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
     666        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
    667667        if (rc != EOK) {
    668                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     668                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    669669                fibril_mutex_unlock(&parentp->idx->lock);
    670670                return rc;
    … …  
    672672        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    673673        if (rc != EOK) {
    674                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     674                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    675675                fibril_mutex_unlock(&parentp->idx->lock);
    676676                return rc;
    … …  
    789789        assert(childp->lnkcnt == 1);
    790790        fibril_mutex_lock(&childp->idx->lock);
    791         bs = block_bb_get(childp->idx->devmap_handle);
    792 
    793         rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
     791        bs = block_bb_get(childp->idx->service_id);
     792
     793        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
    794794            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    795795            BLOCK_FLAGS_NONE);
    … …  
    841841       
    842842        fibril_mutex_lock(&nodep->idx->lock);
    843         bs = block_bb_get(nodep->idx->devmap_handle);
     843        bs = block_bb_get(nodep->idx->service_id);
    844844
    845845        blocks = nodep->size / BPS(bs);
    … …  
    910910}
    911911
    912 devmap_handle_t fat_device_get(fs_node_t *node)
     912service_id_t fat_device_get(fs_node_t *node)
    913913{
    914914        return 0;
    … …  
    940940
    941941static int
    942 fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
     942fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    943943    aoff64_t *size, unsigned *linkcnt)
    944944{
    … …  
    954954
    955955        /* initialize libblock */
    956         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     956        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
    957957        if (rc != EOK)
    958958                return rc;
    959959
    960960        /* prepare the boot block */
    961         rc = block_bb_read(devmap_handle, BS_BLOCK);
     961        rc = block_bb_read(service_id, BS_BLOCK);
    962962        if (rc != EOK) {
    963                 block_fini(devmap_handle);
     963                block_fini(service_id);
    964964                return rc;
    965965        }
    966966
    967967        /* get the buffer with the boot sector */
    968         bs = block_bb_get(devmap_handle);
     968        bs = block_bb_get(service_id);
    969969       
    970970        if (BPS(bs) != BS_SIZE) {
    971                 block_fini(devmap_handle);
     971                block_fini(service_id);
    972972                return ENOTSUP;
    973973        }
    974974
    975975        /* Initialize the block cache */
    976         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
     976        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
    977977        if (rc != EOK) {
    978                 block_fini(devmap_handle);
     978                block_fini(service_id);
    979979                return rc;
    980980        }
    981981
    982982        /* Do some simple sanity checks on the file system. */
    983         rc = fat_sanity_check(bs, devmap_handle);
     983        rc = fat_sanity_check(bs, service_id);
    984984        if (rc != EOK) {
    985                 (void) block_cache_fini(devmap_handle);
    986                 block_fini(devmap_handle);
    987                 return rc;
    988         }
    989 
    990         rc = fat_idx_init_by_devmap_handle(devmap_handle);
     985                (void) block_cache_fini(service_id);
     986                block_fini(service_id);
     987                return rc;
     988        }
     989
     990        rc = fat_idx_init_by_service_id(service_id);
    991991        if (rc != EOK) {
    992                 (void) block_cache_fini(devmap_handle);
    993                 block_fini(devmap_handle);
     992                (void) block_cache_fini(service_id);
     993                block_fini(service_id);
    994994                return rc;
    995995        }
    … …  
    998998        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    999999        if (!rfn) {
    1000                 (void) block_cache_fini(devmap_handle);
    1001                 block_fini(devmap_handle);
    1002                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1000                (void) block_cache_fini(service_id);
     1001                block_fini(service_id);
     1002                fat_idx_fini_by_service_id(service_id);
    10031003                return ENOMEM;
    10041004        }
    … …  
    10071007        if (!rootp) {
    10081008                free(rfn);
    1009                 (void) block_cache_fini(devmap_handle);
    1010                 block_fini(devmap_handle);
    1011                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1009                (void) block_cache_fini(service_id);
     1010                block_fini(service_id);
     1011                fat_idx_fini_by_service_id(service_id);
    10121012                return ENOMEM;
    10131013        }
    10141014        fat_node_initialize(rootp);
    10151015
    1016         fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
     1016        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
    10171017        if (!ridxp) {
    10181018                free(rfn);
    10191019                free(rootp);
    1020                 (void) block_cache_fini(devmap_handle);
    1021                 block_fini(devmap_handle);
    1022                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1020                (void) block_cache_fini(service_id);
     1021                block_fini(service_id);
     1022                fat_idx_fini_by_service_id(service_id);
    10231023                return ENOMEM;
    10241024        }
    … …  
    10451045}
    10461046
    1047 static int fat_unmounted(devmap_handle_t devmap_handle)
     1047static int fat_unmounted(service_id_t service_id)
    10481048{
    10491049        fs_node_t *fn;
    … …  
    10511051        int rc;
    10521052
    1053         rc = fat_root_get(&fn, devmap_handle);
     1053        rc = fat_root_get(&fn, service_id);
    10541054        if (rc != EOK)
    10551055                return rc;
    … …  
    10761076         * stop using libblock for this instance.
    10771077         */
    1078         (void) fat_node_fini_by_devmap_handle(devmap_handle);
    1079         fat_idx_fini_by_devmap_handle(devmap_handle);
    1080         (void) block_cache_fini(devmap_handle);
    1081         block_fini(devmap_handle);
     1078        (void) fat_node_fini_by_service_id(service_id);
     1079        fat_idx_fini_by_service_id(service_id);
     1080        (void) block_cache_fini(service_id);
     1081        block_fini(service_id);
    10821082
    10831083        return EOK;
    … …  
    10851085
    10861086static int
    1087 fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1087fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    10881088    size_t *rbytes)
    10891089{
    … …  
    10951095        int rc;
    10961096
    1097         rc = fat_node_get(&fn, devmap_handle, index);
     1097        rc = fat_node_get(&fn, service_id, index);
    10981098        if (rc != EOK)
    10991099                return rc;
    … …  
    11101110        }
    11111111
    1112         bs = block_bb_get(devmap_handle);
     1112        bs = block_bb_get(service_id);
    11131113
    11141114        if (nodep->type == FAT_FILE) {
    … …  
    12131213
    12141214static int
    1215 fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1215fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12161216    size_t *wbytes, aoff64_t *nsize)
    12171217{
    … …  
    12251225        int rc;
    12261226       
    1227         rc = fat_node_get(&fn, devmap_handle, index);
     1227        rc = fat_node_get(&fn, service_id, index);
    12281228        if (rc != EOK)
    12291229                return rc;
    … …  
    12401240        }
    12411241
    1242         bs = block_bb_get(devmap_handle);
     1242        bs = block_bb_get(service_id);
    12431243
    12441244        /*
    … …  
    12991299                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13001300                /* create an independent chain of nclsts clusters in all FATs */
    1301                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1301                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
    13021302                if (rc != EOK) {
    13031303                        /* could not allocate a chain of nclsts clusters */
    … …  
    13091309                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13101310                if (rc != EOK) {
    1311                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1311                        (void) fat_free_clusters(bs, service_id, mcl);
    13121312                        (void) fat_node_put(fn);
    13131313                        async_answer_0(callid, rc);
    13141314                        return rc;
    13151315                }
    1316                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1316                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    13171317                    (pos / BPS(bs)) % SPC(bs), flags);
    13181318                if (rc != EOK) {
    1319                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1319                        (void) fat_free_clusters(bs, service_id, mcl);
    13201320                        (void) fat_node_put(fn);
    13211321                        async_answer_0(callid, rc);
    … …  
    13271327                rc = block_put(b);
    13281328                if (rc != EOK) {
    1329                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1329                        (void) fat_free_clusters(bs, service_id, mcl);
    13301330                        (void) fat_node_put(fn);
    13311331                        return rc;
    … …  
    13371337                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    13381338                if (rc != EOK) {
    1339                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1339                        (void) fat_free_clusters(bs, service_id, mcl);
    13401340                        (void) fat_node_put(fn);
    13411341                        return rc;
    … …  
    13501350
    13511351static int
    1352 fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     1352fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    13531353{
    13541354        fs_node_t *fn;
    … …  
    13571357        int rc;
    13581358
    1359         rc = fat_node_get(&fn, devmap_handle, index);
     1359        rc = fat_node_get(&fn, service_id, index);
    13601360        if (rc != EOK)
    13611361                return rc;
    … …  
    13641364        nodep = FAT_NODE(fn);
    13651365
    1366         bs = block_bb_get(devmap_handle);
     1366        bs = block_bb_get(service_id);
    13671367
    13681368        if (nodep->size == size) {
    … …  
    13911391                } else {
    13921392                        fat_cluster_t lastc;
    1393                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1393                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    13941394                            &lastc, NULL, (size - 1) / BPC(bs));
    13951395                        if (rc != EOK)
    … …  
    14081408}
    14091409
    1410 static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
     1410static int fat_close(service_id_t service_id, fs_index_t index)
    14111411{
    14121412        return EOK;
    14131413}
    14141414
    1415 static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     1415static int fat_destroy(service_id_t service_id, fs_index_t index)
    14161416{
    14171417        fs_node_t *fn;
    … …  
    14191419        int rc;
    14201420
    1421         rc = fat_node_get(&fn, devmap_handle, index);
     1421        rc = fat_node_get(&fn, service_id, index);
    14221422        if (rc != EOK)
    14231423                return rc;
    … …  
    14361436}
    14371437
    1438 static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
     1438static int fat_sync(service_id_t service_id, fs_index_t index)
    14391439{
    14401440        fs_node_t *fn;
    1441         int rc = fat_node_get(&fn, devmap_handle, index);
     1441        int rc = fat_node_get(&fn, service_id, index);
    14421442        if (rc != EOK)
    14431443                return rc;

  • uspace/srv/fs/locfs/Makefile

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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,
    … …  
    6161        printf("%s: HelenOS Device Filesystem\n", NAME);
    6262       
    63         if (!devfs_init()) {
    64                 printf("%s: failed to initialize devfs\n", NAME);
     63        if (!locfs_init()) {
     64                printf("%s: failed to initialize locfs\n", NAME);
    6565                return -1;
    6666        }
    … …  
    7373        }
    7474       
    75         int rc = fs_register(vfs_sess, &devfs_vfs_info, &devfs_ops,
    76             &devfs_libfs_ops);
     75        int rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops,
     76            &locfs_libfs_ops);
    7777        if (rc != EOK) {
    7878                printf("%s: Failed to register file system (%d)\n", NAME, rc);

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

    r3751a08 r16dc887  
    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 vfs_out_ops_t devfs_ops;
    39 extern libfs_ops_t devfs_libfs_ops;
     38extern vfs_out_ops_t locfs_ops;
     39extern libfs_ops_t locfs_libfs_ops;
    4040
    4141#endif

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

    r3751a08 r16dc887  
    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 bool devfs_is_directory(fs_node_t *fn)
    406 {
    407         devfs_node_t *node = (devfs_node_t *) fn->data;
    408        
    409         return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE));
    410 }
    411 
    412 static bool devfs_is_file(fs_node_t *fn)
    413 {
    414         devfs_node_t *node = (devfs_node_t *) fn->data;
    415        
    416         return (node->type == DEV_HANDLE_DEVICE);
    417 }
    418 
    419 static devmap_handle_t devfs_device_get(fs_node_t *fn)
    420 {
    421         devfs_node_t *node = (devfs_node_t *) fn->data;
    422        
    423         if (node->type == DEV_HANDLE_DEVICE)
    424                 return node->handle;
     406static bool locfs_is_directory(fs_node_t *fn)
     407{
     408        locfs_node_t *node = (locfs_node_t *) fn->data;
     409       
     410        return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE));
     411}
     412
     413static bool locfs_is_file(fs_node_t *fn)
     414{
     415        locfs_node_t *node = (locfs_node_t *) fn->data;
     416       
     417        return (node->type == LOC_OBJECT_SERVICE);
     418}
     419
     420static service_id_t locfs_device_get(fs_node_t *fn)
     421{
     422        locfs_node_t *node = (locfs_node_t *) fn->data;
     423       
     424        if (node->type == LOC_OBJECT_SERVICE)
     425                return node->service_id;
    425426       
    426427        return 0;
    … …  
    428429
    429430/** libfs operations */
    430 libfs_ops_t devfs_libfs_ops = {
    431         .root_get = devfs_root_get,
    432         .match = devfs_match,
    433         .node_get = devfs_node_get,
    434         .node_open = devfs_node_open,
    435         .node_put = devfs_node_put,
    436         .create = devfs_create_node,
    437         .destroy = devfs_destroy_node,
    438         .link = devfs_link_node,
    439         .unlink = devfs_unlink_node,
    440         .has_children = devfs_has_children,
    441         .index_get = devfs_index_get,
    442         .size_get = devfs_size_get,
    443         .lnkcnt_get = devfs_lnkcnt_get,
    444         .is_directory = devfs_is_directory,
    445         .is_file = devfs_is_file,
    446         .device_get = devfs_device_get
     431libfs_ops_t locfs_libfs_ops = {
     432        .root_get = locfs_root_get,
     433        .match = locfs_match,
     434        .node_get = locfs_node_get,
     435        .node_open = locfs_node_open,
     436        .node_put = locfs_node_put,
     437        .create = locfs_create_node,
     438        .destroy = locfs_destroy_node,
     439        .link = locfs_link_node,
     440        .unlink = locfs_unlink_node,
     441        .has_children = locfs_has_children,
     442        .index_get = locfs_index_get,
     443        .size_get = locfs_size_get,
     444        .lnkcnt_get = locfs_lnkcnt_get,
     445        .is_directory = locfs_is_directory,
     446        .is_file = locfs_is_file,
     447        .device_get = locfs_device_get
    447448};
    448449
    449 bool devfs_init(void)
    450 {
    451         if (!hash_table_create(&devices, DEVICES_BUCKETS,
    452             DEVICES_KEYS, &devices_ops))
     450bool locfs_init(void)
     451{
     452        if (!hash_table_create(&services, SERVICES_BUCKETS,
     453            SERVICES_KEYS, &services_ops))
    453454                return false;
    454455       
    … …  
    456457}
    457458
    458 static int devfs_mounted(devmap_handle_t devmap_handle, const char *opts,
     459static int locfs_mounted(service_id_t service_id, const char *opts,
    459460    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    460461{
    … …  
    465466}
    466467
    467 static int devfs_unmounted(devmap_handle_t devmap_handle)
     468static int locfs_unmounted(service_id_t service_id)
    468469{
    469470        return ENOTSUP;
    … …  
    471472
    472473static int
    473 devfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     474locfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    474475    size_t *rbytes)
    475476{
    … …  
    482483                }
    483484               
    484                 dev_desc_t *desc;
    485                 size_t count = devmap_get_namespaces(&desc);
     485                loc_sdesc_t *desc;
     486                size_t count = loc_get_namespaces(&desc);
    486487               
    487488                /* Get rid of root namespace */
    … …  
    507508               
    508509                /* Search root namespace */
    509                 devmap_handle_t namespace;
    510                 if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
    511                         count = devmap_get_devices(namespace, &desc);
     510                service_id_t namespace;
     511                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
     512                        count = loc_get_services(namespace, &desc);
    512513                       
    513514                        if (pos < count) {
    … …  
    525526        }
    526527       
    527         devmap_handle_type_t type = devmap_handle_probe(index);
    528        
    529         if (type == DEV_HANDLE_NAMESPACE) {
     528        loc_object_type_t type = loc_id_probe(index);
     529       
     530        if (type == LOC_OBJECT_NAMESPACE) {
    530531                /* Namespace directory */
    531532                ipc_callid_t callid;
    … …  
    536537                }
    537538               
    538                 dev_desc_t *desc;
    539                 size_t count = devmap_get_devices(index, &desc);
     539                loc_sdesc_t *desc;
     540                size_t count = loc_get_services(index, &desc);
    540541               
    541542                if (pos < count) {
    … …  
    551552        }
    552553       
    553         if (type == DEV_HANDLE_DEVICE) {
     554        if (type == LOC_OBJECT_SERVICE) {
    554555                /* Device node */
    555556               
    556557                unsigned long key[] = {
    557                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     558                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    558559                };
    559560               
    560                 fibril_mutex_lock(&devices_mutex);
    561                 link_t *lnk = hash_table_find(&devices, key);
     561                fibril_mutex_lock(&services_mutex);
     562                link_t *lnk = hash_table_find(&services, key);
    562563                if (lnk == NULL) {
    563                         fibril_mutex_unlock(&devices_mutex);
     564                        fibril_mutex_unlock(&services_mutex);
    564565                        return ENOENT;
    565566                }
    566567               
    567                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     568                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    568569                assert(dev->sess);
    569570               
    570571                ipc_callid_t callid;
    571572                if (!async_data_read_receive(&callid, NULL)) {
    572                         fibril_mutex_unlock(&devices_mutex);
     573                        fibril_mutex_unlock(&services_mutex);
    573574                        async_answer_0(callid, EINVAL);
    574575                        return EINVAL;
    … …  
    579580               
    580581                ipc_call_t answer;
    581                 aid_t msg = async_send_4(exch, VFS_OUT_READ, devmap_handle,
     582                aid_t msg = async_send_4(exch, VFS_OUT_READ, service_id,
    582583                    index, LOWER32(pos), UPPER32(pos), &answer);
    583584               
    … …  
    587588                async_exchange_end(exch);
    588589               
    589                 fibril_mutex_unlock(&devices_mutex);
     590                fibril_mutex_unlock(&services_mutex);
    590591               
    591592                /* Wait for reply from the driver. */
    … …  
    601602
    602603static int
    603 devfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     604locfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    604605    size_t *wbytes, aoff64_t *nsize)
    605606{
    … …  
    607608                return ENOTSUP;
    608609       
    609         devmap_handle_type_t type = devmap_handle_probe(index);
    610        
    611         if (type == DEV_HANDLE_NAMESPACE) {
     610        loc_object_type_t type = loc_id_probe(index);
     611       
     612        if (type == LOC_OBJECT_NAMESPACE) {
    612613                /* Namespace directory */
    613614                return ENOTSUP;
    614615        }
    615616       
    616         if (type == DEV_HANDLE_DEVICE) {
     617        if (type == LOC_OBJECT_SERVICE) {
    617618                /* Device node */
    618619                unsigned long key[] = {
    619                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     620                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    620621                };
    621622               
    622                 fibril_mutex_lock(&devices_mutex);
    623                 link_t *lnk = hash_table_find(&devices, key);
     623                fibril_mutex_lock(&services_mutex);
     624                link_t *lnk = hash_table_find(&services, key);
    624625                if (lnk == NULL) {
    625                         fibril_mutex_unlock(&devices_mutex);
     626                        fibril_mutex_unlock(&services_mutex);
    626627                        return ENOENT;
    627628                }
    628629               
    629                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     630                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    630631                assert(dev->sess);
    631632               
    632633                ipc_callid_t callid;
    633634                if (!async_data_write_receive(&callid, NULL)) {
    634                         fibril_mutex_unlock(&devices_mutex);
     635                        fibril_mutex_unlock(&services_mutex);
    635636                        async_answer_0(callid, EINVAL);
    636637                        return EINVAL;
    … …  
    641642               
    642643                ipc_call_t answer;
    643                 aid_t msg = async_send_4(exch, VFS_OUT_WRITE, devmap_handle,
     644                aid_t msg = async_send_4(exch, VFS_OUT_WRITE, service_id,
    644645                    index, LOWER32(pos), UPPER32(pos), &answer);
    645646               
    … …  
    649650                async_exchange_end(exch);
    650651               
    651                 fibril_mutex_unlock(&devices_mutex);
     652                fibril_mutex_unlock(&services_mutex);
    652653               
    653654                /* Wait for reply from the driver. */
    … …  
    664665
    665666static int
    666 devfs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     667locfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    667668{
    668669        return ENOTSUP;
    669670}
    670671
    671 static int devfs_close(devmap_handle_t devmap_handle, fs_index_t index)
     672static int locfs_close(service_id_t service_id, fs_index_t index)
    672673{
    673674        if (index == 0)
    674675                return EOK;
    675676       
    676         devmap_handle_type_t type = devmap_handle_probe(index);
    677        
    678         if (type == DEV_HANDLE_NAMESPACE) {
     677        loc_object_type_t type = loc_id_probe(index);
     678       
     679        if (type == LOC_OBJECT_NAMESPACE) {
    679680                /* Namespace directory */
    680681                return EOK;
    681682        }
    682683       
    683         if (type == DEV_HANDLE_DEVICE) {
     684        if (type == LOC_OBJECT_SERVICE) {
    684685                unsigned long key[] = {
    685                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     686                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    686687                };
    687688               
    688                 fibril_mutex_lock(&devices_mutex);
    689                 link_t *lnk = hash_table_find(&devices, key);
     689                fibril_mutex_lock(&services_mutex);
     690                link_t *lnk = hash_table_find(&services, key);
    690691                if (lnk == NULL) {
    691                         fibril_mutex_unlock(&devices_mutex);
     692                        fibril_mutex_unlock(&services_mutex);
    692693                        return ENOENT;
    693694                }
    694695               
    695                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     696                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    696697                assert(dev->sess);
    697698                dev->refcount--;
    … …  
    699700                if (dev->refcount == 0) {
    700701                        async_hangup(dev->sess);
    701                         hash_table_remove(&devices, key, DEVICES_KEYS);
    702                 }
    703                
    704                 fibril_mutex_unlock(&devices_mutex);
     702                        hash_table_remove(&services, key, SERVICES_KEYS);
     703                }
     704               
     705                fibril_mutex_unlock(&services_mutex);
    705706               
    706707                return EOK;
    … …  
    710711}
    711712
    712 static int devfs_sync(devmap_handle_t devmap_handle, fs_index_t index)
     713static int locfs_sync(service_id_t service_id, fs_index_t index)
    713714{
    714715        if (index == 0)
    715716                return EOK;
    716717       
    717         devmap_handle_type_t type = devmap_handle_probe(index);
    718        
    719         if (type == DEV_HANDLE_NAMESPACE) {
     718        loc_object_type_t type = loc_id_probe(index);
     719       
     720        if (type == LOC_OBJECT_NAMESPACE) {
    720721                /* Namespace directory */
    721722                return EOK;
    722723        }
    723724       
    724         if (type == DEV_HANDLE_DEVICE) {
     725        if (type == LOC_OBJECT_SERVICE) {
    725726                unsigned long key[] = {
    726                         [DEVICES_KEY_HANDLE] = (unsigned long) index
     727                        [SERVICES_KEY_HANDLE] = (unsigned long) index
    727728                };
    728729               
    729                 fibril_mutex_lock(&devices_mutex);
    730                 link_t *lnk = hash_table_find(&devices, key);
     730                fibril_mutex_lock(&services_mutex);
     731                link_t *lnk = hash_table_find(&services, key);
    731732                if (lnk == NULL) {
    732                         fibril_mutex_unlock(&devices_mutex);
     733                        fibril_mutex_unlock(&services_mutex);
    733734                        return ENOENT;
    734735                }
    735736               
    736                 device_t *dev = hash_table_get_instance(lnk, device_t, link);
     737                service_t *dev = hash_table_get_instance(lnk, service_t, link);
    737738                assert(dev->sess);
    738739               
    … …  
    741742               
    742743                ipc_call_t answer;
    743                 aid_t msg = async_send_2(exch, VFS_OUT_SYNC, devmap_handle,
     744                aid_t msg = async_send_2(exch, VFS_OUT_SYNC, service_id,
    744745                    index, &answer);
    745746               
    746747                async_exchange_end(exch);
    747748               
    748                 fibril_mutex_unlock(&devices_mutex);
     749                fibril_mutex_unlock(&services_mutex);
    749750               
    750751                /* Wait for reply from the driver */
    … …  
    758759}
    759760
    760 static int devfs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     761static int locfs_destroy(service_id_t service_id, fs_index_t index)
    761762{
    762763        return ENOTSUP;
    763764}
    764765
    765 vfs_out_ops_t devfs_ops = {
    766         .mounted = devfs_mounted,
    767         .unmounted = devfs_unmounted,
    768         .read = devfs_read,
    769         .write = devfs_write,
    770         .truncate = devfs_truncate,
    771         .close = devfs_close,
    772         .destroy = devfs_destroy,
    773         .sync = devfs_sync,
     766vfs_out_ops_t locfs_ops = {
     767        .mounted = locfs_mounted,
     768        .unmounted = locfs_unmounted,
     769        .read = locfs_read,
     770        .write = locfs_write,
     771        .truncate = locfs_truncate,
     772        .close = locfs_close,
     773        .destroy = locfs_destroy,
     774        .sync = locfs_sync,
    774775};
    775776

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

    r3751a08 r16dc887  
    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 <bool.h>
    3737
    38 extern bool devfs_init(void);
     38extern bool locfs_init(void);
    3939
    4040#endif

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

    r3751a08 r16dc887  
    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;
    … …  
    7474
    7575extern bool tmpfs_init(void);
    76 extern bool tmpfs_restore(devmap_handle_t);
     76extern bool tmpfs_restore(service_id_t);
    7777
    7878#endif

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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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
    … …  
    114114}
    115115
    116 static devmap_handle_t tmpfs_device_get(fs_node_t *fn)
     116static service_id_t tmpfs_device_get(fs_node_t *fn)
    117117{
    118118        return 0;
    … …  
    158158        switch (keys) {
    159159        case 1:
    160                 return (nodep->devmap_handle == key[NODES_KEY_DEV]);
     160                return (nodep->service_id == key[NODES_KEY_DEV]);
    161161        case 2:
    162                 return ((nodep->devmap_handle == key[NODES_KEY_DEV]) &&
     162                return ((nodep->service_id == key[NODES_KEY_DEV]) &&
    163163                    (nodep->index == key[NODES_KEY_INDEX]));
    164164        default:
    … …  
    202202        nodep->bp = NULL;
    203203        nodep->index = 0;
    204         nodep->devmap_handle = 0;
     204        nodep->service_id = 0;
    205205        nodep->type = TMPFS_NONE;
    206206        nodep->lnkcnt = 0;
    … …  
    226226}
    227227
    228 static bool tmpfs_instance_init(devmap_handle_t devmap_handle)
     228static bool tmpfs_instance_init(service_id_t service_id)
    229229{
    230230        fs_node_t *rfn;
    231231        int rc;
    232232       
    233         rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY);
     233        rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY);
    234234        if (rc != EOK || !rfn)
    235235                return false;
    … …  
    238238}
    239239
    240 static void tmpfs_instance_done(devmap_handle_t devmap_handle)
    241 {
    242         unsigned long key[] = {
    243                 [NODES_KEY_DEV] = devmap_handle
     240static void tmpfs_instance_done(service_id_t service_id)
     241{
     242        unsigned long key[] = {
     243                [NODES_KEY_DEV] = service_id
    244244        };
    245245        /*
    … …  
    270270}
    271271
    272 int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    273 {
    274         unsigned long key[] = {
    275                 [NODES_KEY_DEV] = devmap_handle,
     272int tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     273{
     274        unsigned long key[] = {
     275                [NODES_KEY_DEV] = service_id,
    276276                [NODES_KEY_INDEX] = index
    277277        };
    … …  
    299299}
    300300
    301 int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
     301int tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
    302302{
    303303        fs_node_t *rootfn;
    … …  
    318318        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    319319
    320         rc = tmpfs_root_get(&rootfn, devmap_handle);
     320        rc = tmpfs_root_get(&rootfn, service_id);
    321321        assert(rc == EOK);
    322322        if (!rootfn)
    … …  
    324324        else
    325325                nodep->index = tmpfs_next_index++;
    326         nodep->devmap_handle = devmap_handle;
     326        nodep->service_id = service_id;
    327327        if (lflag & L_DIRECTORY)
    328328                nodep->type = TMPFS_DIRECTORY;
    … …  
    332332        /* Insert the new node into the nodes hash table. */
    333333        unsigned long key[] = {
    334                 [NODES_KEY_DEV] = nodep->devmap_handle,
     334                [NODES_KEY_DEV] = nodep->service_id,
    335335                [NODES_KEY_INDEX] = nodep->index
    336336        };
    … …  
    348348
    349349        unsigned long key[] = {
    350                 [NODES_KEY_DEV] = nodep->devmap_handle,
     350                [NODES_KEY_DEV] = nodep->service_id,
    351351                [NODES_KEY_INDEX] = nodep->index
    352352        };
    … …  
    432432
    433433static int
    434 tmpfs_mounted(devmap_handle_t devmap_handle, const char *opts,
     434tmpfs_mounted(service_id_t service_id, const char *opts,
    435435    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    436436{
    … …  
    439439       
    440440        /* Check if this device is not already mounted. */
    441         rc = tmpfs_root_get(&rootfn, devmap_handle);
     441        rc = tmpfs_root_get(&rootfn, service_id);
    442442        if ((rc == EOK) && (rootfn)) {
    443443                (void) tmpfs_node_put(rootfn);
    … …  
    446446
    447447        /* Initialize TMPFS instance. */
    448         if (!tmpfs_instance_init(devmap_handle))
     448        if (!tmpfs_instance_init(service_id))
    449449                return ENOMEM;
    450450
    451         rc = tmpfs_root_get(&rootfn, devmap_handle);
     451        rc = tmpfs_root_get(&rootfn, service_id);
    452452        assert(rc == EOK);
    453453        tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
    454454        if (str_cmp(opts, "restore") == 0) {
    455                 if (!tmpfs_restore(devmap_handle))
     455                if (!tmpfs_restore(service_id))
    456456                        return ELIMIT;
    457457        }
    … …  
    464464}
    465465
    466 static int tmpfs_unmounted(devmap_handle_t devmap_handle)
    467 {
    468         tmpfs_instance_done(devmap_handle);
    469         return EOK;
    470 }
    471 
    472 static int tmpfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     466static int tmpfs_unmounted(service_id_t service_id)
     467{
     468        tmpfs_instance_done(service_id);
     469        return EOK;
     470}
     471
     472static int tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    473473    size_t *rbytes)
    474474{
    … …  
    478478        link_t *hlp;
    479479        unsigned long key[] = {
    480                 [NODES_KEY_DEV] = devmap_handle,
     480                [NODES_KEY_DEV] = service_id,
    481481                [NODES_KEY_INDEX] = index
    482482        };
    … …  
    532532
    533533static int
    534 tmpfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     534tmpfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    535535    size_t *wbytes, aoff64_t *nsize)
    536536{
    … …  
    540540        link_t *hlp;
    541541        unsigned long key[] = {
    542                 [NODES_KEY_DEV] = devmap_handle,
     542                [NODES_KEY_DEV] = service_id,
    543543                [NODES_KEY_INDEX] = index
    544544        };
    … …  
    594594}
    595595
    596 static int tmpfs_truncate(devmap_handle_t devmap_handle, fs_index_t index,
     596static int tmpfs_truncate(service_id_t service_id, fs_index_t index,
    597597    aoff64_t size)
    598598{
    … …  
    601601         */
    602602        unsigned long key[] = {
    603                 [NODES_KEY_DEV] = devmap_handle,
     603                [NODES_KEY_DEV] = service_id,
    604604                [NODES_KEY_INDEX] = index
    605605        };
    … …  
    629629}
    630630
    631 static int tmpfs_close(devmap_handle_t devmap_handle, fs_index_t index)
    632 {
    633         return EOK;
    634 }
    635 
    636 static int tmpfs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     631static int tmpfs_close(service_id_t service_id, fs_index_t index)
     632{
     633        return EOK;
     634}
     635
     636static int tmpfs_destroy(service_id_t service_id, fs_index_t index)
    637637{
    638638        link_t *hlp;
    639639        unsigned long key[] = {
    640                 [NODES_KEY_DEV] = devmap_handle,
     640                [NODES_KEY_DEV] = service_id,
    641641                [NODES_KEY_INDEX] = index
    642642        };
    … …  
    649649}
    650650
    651 static int tmpfs_sync(devmap_handle_t devmap_handle, fs_index_t index)
     651static int tmpfs_sync(service_id_t service_id, fs_index_t index)
    652652{
    653653        /*

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

    r3751a08 r16dc887  
    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;
    … …  
    721721}
    722722
    723 static async_sess_t *connect_input(const char *dev_path)
     723static async_sess_t *connect_input(const char *svc_path)
    724724{
    725725        async_sess_t *sess;
    726726        async_exch_t *exch;
    727         devmap_handle_t handle;
    728        
    729         int rc = devmap_device_get_handle(dev_path, &handle, 0);
     727        service_id_t service_id;
     728       
     729        int rc = loc_service_get_id(svc_path, &service_id, 0);
    730730        if (rc == EOK) {
    731                 sess = devmap_device_connect(EXCHANGE_ATOMIC, handle, 0);
     731                sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
    732732                if (sess == NULL) {
    733733                        printf("%s: Failed to connect to input server\n", NAME);
    … …  
    773773        }
    774774       
    775         /* Register driver */
    776         int rc = devmap_driver_register(NAME, client_connection);
     775        /* Register server */
     776        int rc = loc_server_register(NAME, client_connection);
    777777        if (rc < 0) {
    778                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     778                printf("%s: Unable to register server (%d)\n", NAME, rc);
    779779                return false;
    780780        }
    … …  
    820820                        consoles[i].refcount = 0;
    821821                       
    822                         char vc[DEVMAP_NAME_MAXLEN + 1];
    823                         snprintf(vc, DEVMAP_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
     822                        char vc[LOC_NAME_MAXLEN + 1];
     823                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    824824                       
    825                         if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) {
    826                                 printf("%s: Unable to register device %s\n", NAME, vc);
     825                        if (loc_service_register(vc, &consoles[i].service_id) != EOK) {
     826                                printf("%s: Unable to register service %s\n", NAME, vc);
    827827                                return false;
    828828                        }

  • uspace/srv/hid/input/ctl/kbdev.c

    r3751a08 r16dc887  
    4848#include <kbd_ctl.h>
    4949#include <kbd_port.h>
     50#include <loc.h>
    5051#include <stdlib.h>
     52#include <sys/typefmt.h>
    5153#include <vfs/vfs_sess.h>
    5254
    … …  
    7072        /** Session with kbdev device */
    7173        async_sess_t *sess;
    72 
    73         /** File descriptor of open kbdev device */
    74         int fd;
    7574} kbdev_t;
    7675
    … …  
    8483
    8584        kbdev->kbd_dev = kdev;
    86         kbdev->fd = -1;
    8785
    8886        return kbdev;
    … …  
    9391        if (kbdev->sess != NULL)
    9492                async_hangup(kbdev->sess);
    95         if (kbdev->fd >= 0)
    96                 close(kbdev->fd);
    9793        free(kbdev);
    9894}
    … …  
    10096static int kbdev_ctl_init(kbd_dev_t *kdev)
    10197{
    102         const char *pathname;
    10398        async_sess_t *sess;
    10499        async_exch_t *exch;
    105100        kbdev_t *kbdev;
    106         int fd;
     101        char *svc_name;
    107102        int rc;
    108103
    109         pathname = kdev->dev_path;
     104        if (asprintf(&svc_name, "devname%" PRIun, kdev->service_id) > 0)
     105                svc_name = (char *) "unknown";
    110106
    111         fd = open(pathname, O_RDWR);
    112         if (fd < 0) {
    113                 return -1;
    114         }
    115 
    116         sess = fd_session(EXCHANGE_SERIALIZE, fd);
     107        sess = loc_service_connect(EXCHANGE_SERIALIZE, kdev->service_id, 0);
    117108        if (sess == NULL) {
    118                 printf("%s: Failed starting session with '%s'\n", NAME, pathname);
    119                 close(fd);
     109                printf("%s: Failed starting session with '%s.'\n", NAME,
     110                    svc_name);
    120111                return -1;
    121112        }
    … …  
    124115        if (kbdev == NULL) {
    125116                printf("%s: Failed allocating device structure for '%s'.\n",
    126                     NAME, pathname);
     117                    NAME, svc_name);
    127118                return -1;
    128119        }
    129120
    130         kbdev->fd = fd;
    131121        kbdev->sess = sess;
    132122
    133123        exch = async_exchange_begin(sess);
    134124        if (exch == NULL) {
    135                 printf("%s: Failed starting exchange with '%s'.\n", NAME, pathname);
     125                printf("%s: Failed starting exchange with '%s'.\n", NAME,
     126                    svc_name);
    136127                kbdev_destroy(kbdev);
    137128                return -1;
    … …  
    141132        if (rc != EOK) {
    142133                printf("%s: Failed creating callback connection from '%s'.\n",
    143                     NAME, pathname);
     134                    NAME, svc_name);
    144135                async_exchange_end(exch);
    145136                kbdev_destroy(kbdev);

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

    r3751a08 r16dc887  
    3838
    3939#include <adt/list.h>
     40#include <bool.h>
    4041#include <ipc/services.h>
    4142#include <ipc/input.h>
    … …  
    5354#include <io/console.h>
    5455#include <io/keycode.h>
    55 #include <devmap.h>
     56#include <loc.h>
    5657#include <input.h>
    5758#include <kbd.h>
    … …  
    275276        kdev->port_ops = port;
    276277        kdev->ctl_ops = ctl;
    277         kdev->dev_path = NULL;
     278        kdev->service_id = 0;
    278279       
    279280        /* Initialize port driver. */
    … …  
    303304        mdev->port_ops = port;
    304305        mdev->proto_ops = proto;
    305         mdev->dev_path = NULL;
     306        mdev->service_id = 0;
    306307       
    307308        /* Initialize port driver. */
    … …  
    324325/** Add new kbdev device.
    325326 *
    326  * @param dev_path Filesystem path to the device (/dev/class/...)
     327 * @param service_id    Service ID of the keyboard device
    327328 *
    328329 */
    329 static int kbd_add_kbdev(const char *dev_path)
     330static int kbd_add_kbdev(service_id_t service_id)
    330331{
    331332        kbd_dev_t *kdev = kbd_dev_new();
    … …  
    333334                return -1;
    334335       
    335         kdev->dev_path = dev_path;
     336        kdev->service_id = service_id;
    336337        kdev->port_ops = NULL;
    337338        kdev->ctl_ops = &kbdev_ctl;
    … …  
    352353/** Add new mousedev device.
    353354 *
    354  * @param dev_path Filesystem path to the device (/dev/class/...)
     355 * @param service_id    Service ID of the mouse device
    355356 *
    356357 */
    357 static int mouse_add_mousedev(const char *dev_path)
     358static int mouse_add_mousedev(service_id_t service_id)
    358359{
    359360        mouse_dev_t *mdev = mouse_dev_new();
    … …  
    361362                return -1;
    362363       
    363         mdev->dev_path = dev_path;
     364        mdev->service_id = service_id;
    364365        mdev->port_ops = NULL;
    365366        mdev->proto_ops = &mousedev_proto;
    … …  
    482483/** Periodically check for new input devices.
    483484 *
    484  * Looks under /dev/class/keyboard and /dev/class/mouse.
     485 * Looks under /loc/class/keyboard and /loc/class/mouse.
    485486 *
    486487 * @param arg Ignored
    487488 *
    488489 */
     490#include <sys/typefmt.h>
    489491static int dev_discovery_fibril(void *arg)
    490492{
    491         char *dev_path;
    492         size_t kbd_id = 1;
    493         size_t mouse_id = 1;
     493        category_id_t keyboard_cat, mouse_cat;
     494        service_id_t *svcs;
     495        size_t count, i;
     496        bool already_known;
     497        const char *dev_name = "todo";
    494498        int rc;
     499       
     500        rc = loc_category_get_id("keyboard", &keyboard_cat, IPC_FLAG_BLOCKING);
     501        if (rc != EOK) {
     502                printf("%s: Failed resolving category 'keyboard'.\n", NAME);
     503                return ENOENT;
     504        }
     505       
     506        rc = loc_category_get_id("mouse", &mouse_cat, IPC_FLAG_BLOCKING);
     507        if (rc != EOK) {
     508                printf("%s: Failed resolving category 'mouse'.\n", NAME);
     509                return ENOENT;
     510        }
    495511       
    496512        while (true) {
    … …  
    498514               
    499515                /*
    500                  * Check for new keyboard device
     516                 * Check for new keyboard devices
    501517                 */
    502                 rc = asprintf(&dev_path, "/dev/class/keyboard\\%zu", kbd_id);
    503                 if (rc < 0)
     518                rc = loc_category_get_svcs(keyboard_cat, &svcs, &count);
     519                if (rc != EOK) {
     520                        printf("%s: Failed getting list of keyboard devices.\n",
     521                            NAME);
    504522                        continue;
    505                
    506                 if (kbd_add_kbdev(dev_path) == EOK) {
    507                         printf("%s: Connected keyboard device '%s'\n",
    508                             NAME, dev_path);
     523                }
     524
     525                for (i = 0; i < count; i++) {
     526                        already_known = false;
    509527                       
    510                         /* XXX Handle device removal */
    511                         ++kbd_id;
     528                        /* Determine whether we already know this device. */
     529                        list_foreach(kbd_devs, kdev_link) {
     530                                kbd_dev_t *kdev = list_get_instance(kdev_link,
     531                                    kbd_dev_t, kbd_devs);
     532                                if (kdev->service_id == svcs[i]) {
     533                                        already_known = true;
     534                                        break;
     535                                }
     536                        }
     537
     538                        if (!already_known) {
     539                                if (kbd_add_kbdev(svcs[i]) == EOK) {
     540                                        printf("%s: Connected keyboard device '%s'\n",
     541                                            NAME, dev_name);
     542                                }
     543                        }
    512544                }
    513545               
    514                 free(dev_path);
     546                /* XXX Handle device removal */
    515547               
    516548                /*
    517                  * Check for new mouse device
     549                 * Check for new mouse devices
    518550                 */
    519                 rc = asprintf(&dev_path, "/dev/class/mouse\\%zu", mouse_id);
    520                 if (rc < 0)
     551                rc = loc_category_get_svcs(mouse_cat, &svcs, &count);
     552                if (rc != EOK) {
     553                        printf("%s: Failed getting list of mouse devices.\n",
     554                            NAME);
    521555                        continue;
    522                
    523                 if (mouse_add_mousedev(dev_path) == EOK) {
    524                         printf("%s: Connected mouse device '%s'\n",
    525                             NAME, dev_path);
     556                }
     557
     558                for (i = 0; i < count; i++) {
     559                        already_known = false;
    526560                       
    527                         /* XXX Handle device removal */
    528                         ++mouse_id;
     561                        /* Determine whether we already know this device. */
     562                        list_foreach(mouse_devs, mdev_link) {
     563                                mouse_dev_t *mdev = list_get_instance(mdev_link,
     564                                    mouse_dev_t, mouse_devs);
     565                                if (mdev->service_id == svcs[i]) {
     566                                        already_known = true;
     567                                        break;
     568                                }
     569                        }
     570
     571                        if (!already_known) {
     572                                if (mouse_add_mousedev(svcs[i]) == EOK) {
     573                                        printf("%s: Connected mouse device '%s'\n",
     574                                            NAME, dev_name);
     575                                }
     576                        }
    529577                }
    530578               
    531                 free(dev_path);
     579                /* XXX Handle device removal */
    532580        }
    533581       
    … …  
    567615        /* Add legacy keyboard devices. */
    568616        kbd_add_legacy_devs();
    569        
     617
    570618        /* Add legacy mouse devices. */
    571619        mouse_add_legacy_devs();
    572620       
    573621        /* Register driver */
    574         int rc = devmap_driver_register(NAME, client_connection);
     622        int rc = loc_server_register(NAME, client_connection);
    575623        if (rc < 0) {
    576                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     624                printf("%s: Unable to register server (%d)\n", NAME, rc);
    577625                return -1;
    578626        }
    579627       
    580         char kbd[DEVMAP_NAME_MAXLEN + 1];
    581         snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
    582        
    583         devmap_handle_t devmap_handle;
    584         if (devmap_device_register(kbd, &devmap_handle) != EOK) {
    585                 printf("%s: Unable to register device %s\n", NAME, kbd);
     628        char kbd[LOC_NAME_MAXLEN + 1];
     629        snprintf(kbd, LOC_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
     630       
     631        service_id_t service_id;
     632        if (loc_service_register(kbd, &service_id) != EOK) {
     633                printf("%s: Unable to register service %s\n", NAME, kbd);
    586634                return -1;
    587635        }

  • uspace/srv/hid/input/include/kbd.h

    r3751a08 r16dc887  
    4040
    4141#include <adt/list.h>
     42#include <ipc/loc.h>
    4243
    4344struct kbd_port_ops;
    … …  
    4950        link_t kbd_devs;
    5051
    51         /** Path to the device (only for kbdev devices) */
    52         const char *dev_path;
     52        /** Service ID (only for kbdev devices) */
     53        service_id_t service_id;
    5354
    5455        /** Port ops */

  • uspace/srv/hid/input/include/mouse.h

    r3751a08 r16dc887  
    3939
    4040#include <adt/list.h>
     41#include <ipc/loc.h>
    4142
    4243struct mouse_port_ops;
    … …  
    4748        link_t mouse_devs;
    4849       
    49         /** Path to the device (only for mouseev devices) */
    50         const char *dev_path;
     50        /** Service ID (only for mousedev devices) */
     51        service_id_t service_id;
    5152       
    5253        /** Port ops */

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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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/input/proto/mousedev.c

    r3751a08 r16dc887  
    4444#include <ipc/mouseev.h>
    4545#include <input.h>
     46#include <loc.h>
    4647#include <mouse.h>
    4748#include <mouse_port.h>
    4849#include <mouse_proto.h>
     50#include <sys/typefmt.h>
    4951
    5052/** Mousedev softstate */
    … …  
    5557        /** Session to mouse device */
    5658        async_sess_t *sess;
    57        
    58         /** File descriptor of open mousedev device */
    59         int fd;
    6059} mousedev_t;
    6160
    … …  
    6766       
    6867        mousedev->mouse_dev = mdev;
    69         mousedev->fd = -1;
    7068       
    7169        return mousedev;
    … …  
    7674        if (mousedev->sess != NULL)
    7775                async_hangup(mousedev->sess);
    78        
    79         if (mousedev->fd >= 0)
    80                 close(mousedev->fd);
    8176       
    8277        free(mousedev);
    … …  
    122117static int mousedev_proto_init(mouse_dev_t *mdev)
    123118{
    124         const char *pathname = mdev->dev_path;
     119        char *svc_name;
    125120       
    126         int fd = open(pathname, O_RDWR);
    127         if (fd < 0)
    128                 return -1;
     121        if (asprintf(&svc_name, "devname%" PRIun, mdev->service_id) > 0)
     122                svc_name = (char *) "unknown";
    129123       
    130         async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
     124        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
     125            mdev->service_id, 0);
    131126        if (sess == NULL) {
    132                 printf("%s: Failed starting session with '%s'\n", NAME, pathname);
    133                 close(fd);
     127                printf("%s: Failed starting session with '%s'\n", NAME, svc_name);
    134128                return -1;
    135129        }
    … …  
    138132        if (mousedev == NULL) {
    139133                printf("%s: Failed allocating device structure for '%s'.\n",
    140                     NAME, pathname);
     134                    NAME, svc_name);
    141135                return -1;
    142136        }
    143137       
    144         mousedev->fd = fd;
    145138        mousedev->sess = sess;
    146139       
    147140        async_exch_t *exch = async_exchange_begin(sess);
    148141        if (exch == NULL) {
    149                 printf("%s: Failed starting exchange with '%s'.\n", NAME, pathname);
     142                printf("%s: Failed starting exchange with '%s'.\n", NAME,
     143                    svc_name);
    150144                mousedev_destroy(mousedev);
    151145                return -1;
    … …  
    157151        if (rc != EOK) {
    158152                printf("%s: Failed creating callback connection from '%s'.\n",
    159                     NAME, pathname);
     153                    NAME, svc_name);
    160154                mousedev_destroy(mousedev);
    161155                return -1;

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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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/i8259/i8259.c

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    2929
    3030USPACE_PREFIX = ../..
    31 BINARY = devmap
     31BINARY = loc
    3232STATIC_NEEDED = y
    3333
    3434SOURCES = \
    35         devmap.c
     35        category.c \
     36        loc.c
    3637
    3738include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/vfs/vfs.h

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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

    r3751a08 r16dc887  
    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 */
    … …  
    234234               
    235235                mr_res.triplet.fs_handle = fs_handle;
    236                 mr_res.triplet.devmap_handle = devmap_handle;
     236                mr_res.triplet.service_id = service_id;
    237237                mr_res.triplet.index = rindex;
    238238                mr_res.size = rsize;
    … …  
    255255void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
    256256{
    257         devmap_handle_t devmap_handle;
     257        service_id_t service_id;
    258258
    259259        /*
    … …  
    262262         * in the request.
    263263         */
    264         devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     264        service_id = (service_id_t) IPC_GET_ARG1(*request);
    265265       
    266266        /*
    … …  
    350350       
    351351        /* Do the mount */
    352         vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
     352        vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
    353353        free(mp);
    354354        free(fs_name);
    … …  
    409409         */
    410410        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    411             mr_node->devmap_handle) != 2) {
     411            mr_node->service_id) != 2) {
    412412                fibril_rwlock_write_unlock(&namespace_rwlock);
    413413                vfs_node_put(mr_node);
    … …  
    430430                exch = vfs_exchange_grab(mr_node->fs_handle);
    431431                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    432                     mr_node->devmap_handle);
     432                    mr_node->service_id);
    433433                vfs_exchange_release(exch);
    434434               
    … …  
    441441               
    442442                rootfs.fs_handle = 0;
    443                 rootfs.devmap_handle = 0;
     443                rootfs.service_id = 0;
    444444        } else {
    445445               
    … …  
    470470                exch = vfs_exchange_grab(mp_node->fs_handle);
    471471                rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
    472                     mp_node->devmap_handle, mp_node->index);
     472                    mp_node->service_id, mp_node->index);
    473473                vfs_exchange_release(exch);
    474474               
    … …  
    575575                if (node->size) {
    576576                        rc = vfs_truncate_internal(node->fs_handle,
    577                             node->devmap_handle, node->index, 0);
     577                            node->service_id, node->index, 0);
    578578                        if (rc) {
    579579                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    628628       
    629629        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
    630         lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
     630        lr.triplet.service_id = IPC_GET_ARG2(*request);
    631631        lr.triplet.index = IPC_GET_ARG3(*request);
    632632        int oflag = IPC_GET_ARG4(*request);
    … …  
    649649                if (node->size) {
    650650                        rc = vfs_truncate_internal(node->fs_handle,
    651                             node->devmap_handle, node->index, 0);
     651                            node->service_id, node->index, 0);
    652652                        if (rc) {
    653653                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    712712        aid_t msg;
    713713        ipc_call_t answer;
    714         msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
     714        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
    715715            file->node->index, &answer);
    716716       
    … …  
    797797        if (read) {
    798798                rc = async_data_read_forward_4_1(fs_exch, VFS_OUT_READ,
    799                     file->node->devmap_handle, file->node->index,
     799                    file->node->service_id, file->node->index,
    800800                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    801801        } else {
    … …  
    804804               
    805805                rc = async_data_write_forward_4_1(fs_exch, VFS_OUT_WRITE,
    806                     file->node->devmap_handle, file->node->index,
     806                    file->node->service_id, file->node->index,
    807807                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    808808        }
    … …  
    935935}
    936936
    937 int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     937int vfs_truncate_internal(fs_handle_t fs_handle, service_id_t service_id,
    938938    fs_index_t index, aoff64_t size)
    939939{
    940940        async_exch_t *exch = vfs_exchange_grab(fs_handle);
    941941        sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
    942             (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
     942            (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
    943943            UPPER32(size));
    944944        vfs_exchange_release(exch);
    … …  
    963963        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    964964        rc = vfs_truncate_internal(file->node->fs_handle,
    965             file->node->devmap_handle, file->node->index, size);
     965            file->node->service_id, file->node->index, size);
    966966        if (rc == EOK)
    967967                file->node->size = size;
    … …  
    997997       
    998998        aid_t msg;
    999         msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
     999        msg = async_send_3(exch, VFS_OUT_STAT, file->node->service_id,
    10001000            file->node->index, true, NULL);
    10011001        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    10501050       
    10511051        aid_t msg;
    1052         msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
     1052        msg = async_send_3(exch, VFS_OUT_STAT, node->service_id,
    10531053            node->index, false, NULL);
    10541054        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    12271227        /* Check whether linking to the same file system instance. */
    12281228        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1229             (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
     1229            (old_node->service_id != new_par_lr.triplet.service_id)) {
    12301230                fibril_rwlock_write_unlock(&namespace_rwlock);
    12311231                vfs_node_put(old_node);

  • uspace/srv/vfs/vfs_register.c

    r3751a08 r16dc887  
    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.