Changeset 15f3c3f in mainline for uspace/srv/bd


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

Rename devmap to loc, devfs to locfs.

Location:
uspace/srv/bd
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

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

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

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

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

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

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

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

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