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

Changeset 28ed0d9 in mainline


Ignore:
Timestamp:
2015-06-27T19:50:12Z (6 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
78d50bd
Parents:
22fb7ab
Message:

VBD client API, liblabel API, pass partition creation/deletion through to VBD.

Location:
uspace
Files:
4 added
10 edited

Legend:

Unmodified
Added
Removed
  • uspace/Makefile.common

    r22fb7ab r28ed0d9  
    123123LIBBLOCK_PREFIX = $(LIB_PREFIX)/block
    124124LIBFDISK_PREFIX = $(LIB_PREFIX)/fdisk
     125LIBLABEL_PREFIX = $(LIB_PREFIX)/label
    125126LIBFS_PREFIX = $(LIB_PREFIX)/fs
    126127LIBCLUI_PREFIX = $(LIB_PREFIX)/clui
  • uspace/lib/c/generic/vbd.c

    r22fb7ab r28ed0d9  
    3737#include <ipc/vbd.h>
    3838#include <loc.h>
     39#include <mem.h>
    3940#include <stdlib.h>
    4041#include <types/label.h>
     
    153154}
    154155
     156/** Get list of IDs into a buffer of fixed size.
     157 *
     158 * @param vbd      Virtual Block Device
     159 * @param method   IPC method
     160 * @param arg1     First argument
     161 * @param id_buf   Buffer to store IDs
     162 * @param buf_size Buffer size
     163 * @param act_size Place to store actual size of complete data.
     164 *
     165 * @return EOK on success or negative error code.
     166 */
     167static int vbd_get_ids_once(vbd_t *vbd, sysarg_t method, sysarg_t arg1,
     168    sysarg_t *id_buf, size_t buf_size, size_t *act_size)
     169{
     170        async_exch_t *exch = async_exchange_begin(vbd->sess);
     171
     172        ipc_call_t answer;
     173        aid_t req = async_send_1(exch, method, arg1, &answer);
     174        int rc = async_data_read_start(exch, id_buf, buf_size);
     175
     176        async_exchange_end(exch);
     177
     178        if (rc != EOK) {
     179                async_forget(req);
     180                return rc;
     181        }
     182
     183        sysarg_t retval;
     184        async_wait_for(req, &retval);
     185
     186        if (retval != EOK) {
     187                return retval;
     188        }
     189
     190        *act_size = IPC_GET_ARG1(answer);
     191        return EOK;
     192}
     193
     194/** Get list of IDs.
     195 *
     196 * Returns an allocated array of service IDs.
     197 *
     198 * @param vbd    Virtual Block Device
     199 * @param method IPC method
     200 * @param arg1   IPC argument 1
     201 * @param data   Place to store pointer to array of IDs
     202 * @param count  Place to store number of IDs
     203 * @return       EOK on success or negative error code
     204 */
     205static int vbd_get_ids_internal(vbd_t *vbd, sysarg_t method, sysarg_t arg1,
     206    sysarg_t **data, size_t *count)
     207{
     208        *data = NULL;
     209        *count = 0;
     210
     211        size_t act_size = 0;
     212        int rc = vbd_get_ids_once(vbd, method, arg1, NULL, 0, &act_size);
     213        if (rc != EOK)
     214                return rc;
     215
     216        size_t alloc_size = act_size;
     217        service_id_t *ids = malloc(alloc_size);
     218        if (ids == NULL)
     219                return ENOMEM;
     220
     221        while (true) {
     222                rc = vbd_get_ids_once(vbd, method, arg1, ids, alloc_size,
     223                    &act_size);
     224                if (rc != EOK)
     225                        return rc;
     226
     227                if (act_size <= alloc_size)
     228                        break;
     229
     230                alloc_size = act_size;
     231                ids = realloc(ids, alloc_size);
     232                if (ids == NULL)
     233                        return ENOMEM;
     234        }
     235
     236        *count = act_size / sizeof(service_id_t);
     237        *data = ids;
     238        return EOK;
     239}
     240
     241/** Get list of disks as array of service IDs.
     242 *
     243 * @param vbd   Virtual Block Device
     244 * @param data  Place to store pointer to array
     245 * @param count Place to store length of array (number of entries)
     246 *
     247 * @return EOK on success or negative error code
     248 */
     249int vbd_label_get_parts(vbd_t *vbd, service_id_t disk,
     250    service_id_t **data, size_t *count)
     251{
     252        return vbd_get_ids_internal(vbd, VBD_LABEL_GET_PARTS, disk,
     253            data, count);
     254}
     255
     256int vbd_part_get_info(vbd_t *vbd, vbd_part_id_t part, vbd_part_info_t *pinfo)
     257{
     258        async_exch_t *exch;
     259        int retval;
     260
     261        exch = async_exchange_begin(vbd->sess);
     262        retval = async_req_1_0(exch, VBD_PART_GET_INFO, part);
     263        async_exchange_end(exch);
     264
     265        if (retval != EOK)
     266                return EIO;
     267
     268        return EOK;
     269}
     270
     271int vbd_part_create(vbd_t *vbd, service_id_t disk, vbd_part_spec_t *pspec,
     272    vbd_part_id_t *rpart)
     273{
     274        async_exch_t *exch;
     275        sysarg_t part;
     276        int retval;
     277
     278        exch = async_exchange_begin(vbd->sess);
     279        retval = async_req_1_1(exch, VBD_PART_CREATE, disk, &part);
     280        async_exchange_end(exch);
     281
     282        if (retval != EOK)
     283                return EIO;
     284
     285        *rpart = (vbd_part_id_t)part;
     286        return EOK;
     287}
     288
     289int vbd_part_delete(vbd_t *vbd, vbd_part_id_t part)
     290{
     291        async_exch_t *exch;
     292        int retval;
     293
     294        exch = async_exchange_begin(vbd->sess);
     295        retval = async_req_1_0(exch, VBD_PART_DELETE, part);
     296        async_exchange_end(exch);
     297
     298        if (retval != EOK)
     299                return EIO;
     300
     301        return EOK;
     302}
     303
     304void vbd_pspec_init(vbd_part_spec_t *pspec)
     305{
     306        memset(pspec, 0, sizeof(vbd_part_spec_t));
     307}
     308
    155309/** @}
    156310 */
  • uspace/lib/c/include/ipc/vbd.h

    r22fb7ab r28ed0d9  
    4141        VBD_DISK_INFO,
    4242        VBD_LABEL_CREATE,
    43         VBD_LABEL_DELETE
     43        VBD_LABEL_DELETE,
     44        VBD_LABEL_GET_PARTS,
     45        VBD_PART_GET_INFO,
     46        VBD_PART_CREATE,
     47        VBD_PART_DELETE,
    4448} vbd_request_t;
    4549
  • uspace/lib/c/include/vbd.h

    r22fb7ab r28ed0d9  
    5252} vbd_disk_info_t;
    5353
     54typedef struct {
     55} vbd_part_spec_t;
     56
     57typedef struct {
     58} vbd_part_info_t;
     59
     60typedef sysarg_t vbd_part_id_t;
     61
    5462extern int vbd_create(vbd_t **);
    5563extern void vbd_destroy(vbd_t *);
     
    5967extern int vbd_label_create(vbd_t *, service_id_t, label_type_t);
    6068extern int vbd_label_delete(vbd_t *, service_id_t);
     69extern int vbd_label_get_parts(vbd_t *, service_id_t, service_id_t **,
     70    size_t *);
     71extern int vbd_part_get_info(vbd_t *, vbd_part_id_t, vbd_part_info_t *);
     72extern int vbd_part_create(vbd_t *, service_id_t, vbd_part_spec_t *,
     73    vbd_part_id_t *);
     74extern int vbd_part_delete(vbd_t *, vbd_part_id_t);
     75extern void vbd_pspec_init(vbd_part_spec_t *);
    6176
    6277#endif
  • uspace/lib/fdisk/include/types/fdisk.h

    r22fb7ab r28ed0d9  
    4141#include <stdint.h>
    4242#include <types/label.h>
     43#include <vbd.h>
    4344#include <vol.h>
    4445
     
    126127        /** File system type */
    127128        fdisk_fstype_t fstype;
     129        /** Partition ID */
     130        vbd_part_id_t part_id;
    128131} fdisk_part_t;
    129132
     
    147150        /** Volume service */
    148151        vol_t *vol;
     152        /** Virtual Block Device */
     153        vbd_t *vbd;
    149154} fdisk_t;
    150155
  • uspace/lib/fdisk/src/fdisk.c

    r22fb7ab r28ed0d9  
    4343#include <stdlib.h>
    4444#include <str.h>
     45#include <vbd.h>
    4546#include <vol.h>
    4647
     
    7172int fdisk_create(fdisk_t **rfdisk)
    7273{
    73         fdisk_t *fdisk;
     74        fdisk_t *fdisk = NULL;
    7475        int rc;
    7576
    7677        fdisk = calloc(1, sizeof(fdisk_t));
    77         if (fdisk == NULL)
    78                 return ENOMEM;
     78        if (fdisk == NULL) {
     79                rc = ENOMEM;
     80                goto error;
     81        }
    7982
    8083        rc = vol_create(&fdisk->vol);
    8184        if (rc != EOK) {
    82                 free(fdisk);
    83                 return EIO;
     85                rc = EIO;
     86                goto error;
     87        }
     88
     89        rc = vbd_create(&fdisk->vbd);
     90        if (rc != EOK) {
     91                rc = EIO;
     92                goto error;
    8493        }
    8594
    8695        *rfdisk = fdisk;
    8796        return EOK;
     97error:
     98        fdisk_destroy(fdisk);
     99
     100        return rc;
    88101}
    89102
    90103void fdisk_destroy(fdisk_t *fdisk)
    91104{
     105        if (fdisk == NULL)
     106                return;
     107
    92108        vol_destroy(fdisk->vol);
     109        vbd_destroy(fdisk->vbd);
    93110        free(fdisk);
    94111}
     
    368385{
    369386        fdisk_part_t *part;
     387        vbd_part_spec_t vpspec;
     388        vbd_part_id_t partid;
     389        int rc;
    370390
    371391        part = calloc(1, sizeof(fdisk_part_t));
    372392        if (part == NULL)
    373393                return ENOMEM;
     394
     395        rc = vbd_part_create(dev->fdisk->vbd, dev->sid, &vpspec, &partid);
     396        if (rc != EOK) {
     397                free(part);
     398                return EIO;
     399        }
    374400
    375401        part->dev = dev;
     
    377403        part->capacity = pspec->capacity;
    378404        part->fstype = pspec->fstype;
     405        part->part_id = partid;
    379406
    380407        if (rpart != NULL)
     
    385412int fdisk_part_destroy(fdisk_part_t *part)
    386413{
     414        int rc;
     415
     416        rc = vbd_part_delete(part->dev->fdisk->vbd, part->part_id);
     417        if (rc != EOK)
     418                return EIO;
     419
    387420        list_remove(&part->ldev);
    388421        free(part);
  • uspace/lib/label/src/label.c

    r22fb7ab r28ed0d9  
    3434 */
    3535
     36#include <errno.h>
     37#include <label.h>
     38#include <mem.h>
     39#include <stdlib.h>
     40
     41int label_open(service_id_t sid, label_t **rlabel)
     42{
     43        label_t *label;
     44
     45        label = calloc(1, sizeof(label_t));
     46        if (label == NULL)
     47                return ENOMEM;
     48
     49        *rlabel = label;
     50        return EOK;
     51}
     52
     53int label_create(service_id_t sid, label_type_t ltype, label_t **rlabel)
     54{
     55        label_t *label;
     56
     57        label = calloc(1, sizeof(label_t));
     58        if (label == NULL)
     59                return ENOMEM;
     60
     61        *rlabel = label;
     62        return EOK;
     63}
     64
     65void label_close(label_t *label)
     66{
     67        free(label);
     68}
     69
     70int label_destroy(label_t *label)
     71{
     72        free(label);
     73        return EOK;
     74}
     75
     76int label_get_info(label_t *label, label_info_t *linfo)
     77{
     78        memset(linfo, 0, sizeof(label_info_t));
     79        linfo->dcnt = dc_empty;
     80        return EOK;
     81}
     82
     83label_part_t *label_part_first(label_t *label)
     84{
     85        return NULL;
     86}
     87
     88label_part_t *label_part_next(label_part_t *oart)
     89{
     90        return NULL;
     91}
     92
     93
     94int label_part_create(label_t *label, label_part_spec_t *pspec,
     95    label_part_t **rpart)
     96{
     97        return ENOTSUP;
     98}
     99
     100int label_part_destroy(label_part_t *part)
     101{
     102        return EOK;
     103}
     104
     105void label_pspec_init(label_part_spec_t *pspec)
     106{
     107        memset(pspec, 0, sizeof(label_part_spec_t));
     108}
     109
    36110/** @}
    37111 */
  • uspace/srv/bd/vbd/Makefile

    r22fb7ab r28ed0d9  
    2828
    2929USPACE_PREFIX = ../../..
     30
     31LIBS = \
     32        $(LIBLABEL_PREFIX)/liblabel.a \
     33        $(LIBBLOCK_PREFIX)/libblock.a
     34
     35EXTRA_CFLAGS = \
     36        -I$(LIBLABEL_PREFIX)/include
     37
    3038BINARY = vbd
    3139
    3240SOURCES = \
     41        disk.c \
    3342        vbd.c
    3443
  • uspace/srv/bd/vbd/types/vbd.h

    r22fb7ab r28ed0d9  
    3535 */
    3636
    37 #ifndef TYPES_VBD_H_
    38 #define TYPES_VBD_H_
     37#ifndef TYPES_VBDS_H_
     38#define TYPES_VBDS_H_
    3939
     40#include <adt/list.h>
     41#include <label.h>
     42#include <loc.h>
    4043#include <types/label.h>
    4144
    4245/** Disk info */
    4346typedef struct {
     47        /** Label */
     48        label_t *label;
    4449        /** Label type */
    4550        label_type_t ltype;
    46 } vbd_disk_info_t;
     51} vbds_disk_info_t;
     52
     53/** Partition */
     54typedef struct {
     55        /** Disk this partition belongs to */
     56        struct vbds_disk *disk;
     57        /** Link to vbds_disk_t.parts */
     58        link_t ldisk;
     59        /** Label partition */
     60        label_part_t *lpart;
     61} vbds_part_t;
     62
     63/** Disk */
     64typedef struct vbds_disk {
     65        /** Link to vbds_disks */
     66        link_t ldisks;
     67        /** Service ID */
     68        service_id_t svc_id;
     69        /** Label */
     70        label_t *label;
     71        /** Partitions */
     72        list_t parts; /* of vbds_part_t */
     73} vbds_disk_t;
     74
     75typedef struct {
     76} vbds_part_info_t;
     77
     78typedef sysarg_t vbds_part_id_t;
    4779
    4880#endif
  • uspace/srv/bd/vbd/vbd.c

    r22fb7ab r28ed0d9  
    4444#include <task.h>
    4545
     46#include "disk.h"
    4647#include "types/vbd.h"
    4748
    4849#define NAME  "vbd"
    4950
    50 static void vbd_client_conn(ipc_callid_t, ipc_call_t *, void *);
    51 
    52 static int vbd_init(void)
    53 {
    54         int rc;
    55         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_init()");
    56 
    57         async_set_client_connection(vbd_client_conn);
     51static void vbds_client_conn(ipc_callid_t, ipc_call_t *, void *);
     52
     53static int vbds_init(void)
     54{
     55        int rc;
     56        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_init()");
     57
     58        vbds_disks_init();
     59
     60        async_set_client_connection(vbds_client_conn);
    5861
    5962        rc = loc_server_register(NAME);
     
    7376}
    7477
    75 static int vbd_disk_add(service_id_t sid)
    76 {
    77         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_add(%zu)", sid);
    78         return EOK;
    79 }
    80 
    81 static int vbd_disk_remove(service_id_t sid)
    82 {
    83         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_remove(%zu)", sid);
    84         return EOK;
    85 }
    86 
    87 static int vbd_disk_info(service_id_t sid, vbd_disk_info_t *info)
    88 {
    89         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_info(%zu)", sid);
    90         info->ltype = lt_mbr;
    91         return EOK;
    92 }
    93 
    94 static int vbd_label_create(service_id_t sid, label_type_t ltype)
    95 {
    96         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_label_create(%zu, %d)", sid,
    97             ltype);
    98         return EOK;
    99 }
    100 
    101 static int vbd_label_delete(service_id_t sid, label_type_t ltype)
    102 {
    103         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_label_delete(%zu, %d)", sid,
    104             ltype);
    105         return EOK;
    106 }
    107 
    108 static void vbd_disk_add_srv(ipc_callid_t iid, ipc_call_t *icall)
    109 {
    110         service_id_t disk_sid;
    111         int rc;
    112 
    113         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_add_srv()");
    114 
    115         disk_sid = IPC_GET_ARG1(*icall);
    116         rc = vbd_disk_add(disk_sid);
    117         async_answer_0(iid, (sysarg_t) rc);
    118 }
    119 
    120 static void vbd_disk_remove_srv(ipc_callid_t iid, ipc_call_t *icall)
    121 {
    122         service_id_t disk_sid;
    123         int rc;
    124 
    125         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_remove_srv()");
    126 
    127         disk_sid = IPC_GET_ARG1(*icall);
    128         rc = vbd_disk_remove(disk_sid);
    129         async_answer_0(iid, (sysarg_t) rc);
    130 }
    131 
    132 static void vbd_disk_info_srv(ipc_callid_t iid, ipc_call_t *icall)
    133 {
    134         service_id_t disk_sid;
    135         vbd_disk_info_t dinfo;
    136         int rc;
    137 
    138         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_disk_info_srv()");
    139 
    140         disk_sid = IPC_GET_ARG1(*icall);
    141         rc = vbd_disk_info(disk_sid, &dinfo);
     78
     79static void vbds_disk_add_srv(ipc_callid_t iid, ipc_call_t *icall)
     80{
     81        service_id_t disk_sid;
     82        int rc;
     83
     84        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_add_srv()");
     85
     86        disk_sid = IPC_GET_ARG1(*icall);
     87        rc = vbds_disk_add(disk_sid);
     88        async_answer_0(iid, (sysarg_t) rc);
     89}
     90
     91static void vbds_disk_remove_srv(ipc_callid_t iid, ipc_call_t *icall)
     92{
     93        service_id_t disk_sid;
     94        int rc;
     95
     96        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_remove_srv()");
     97
     98        disk_sid = IPC_GET_ARG1(*icall);
     99        rc = vbds_disk_remove(disk_sid);
     100        async_answer_0(iid, (sysarg_t) rc);
     101}
     102
     103static void vbds_disk_info_srv(ipc_callid_t iid, ipc_call_t *icall)
     104{
     105        service_id_t disk_sid;
     106        vbds_disk_info_t dinfo;
     107        int rc;
     108
     109        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_info_srv()");
     110
     111        disk_sid = IPC_GET_ARG1(*icall);
     112        rc = vbds_disk_info(disk_sid, &dinfo);
    142113        async_answer_1(iid, (sysarg_t)rc, (sysarg_t)dinfo.ltype);
    143114}
    144115
    145 static void vbd_label_create_srv(ipc_callid_t iid, ipc_call_t *icall)
     116static void vbds_label_create_srv(ipc_callid_t iid, ipc_call_t *icall)
    146117{
    147118        service_id_t disk_sid;
     
    149120        int rc;
    150121
    151         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_label_create_srv()");
     122        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_label_create_srv()");
    152123
    153124        disk_sid = IPC_GET_ARG1(*icall);
    154125        ltype = IPC_GET_ARG2(*icall);
    155         rc = vbd_label_create(disk_sid, ltype);
    156         async_answer_0(iid, (sysarg_t) rc);
    157 }
    158 
    159 static void vbd_label_delete_srv(ipc_callid_t iid, ipc_call_t *icall)
    160 {
    161         service_id_t disk_sid;
    162         label_type_t ltype;
    163         int rc;
    164 
    165         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_label_delete_srv()");
    166 
    167         disk_sid = IPC_GET_ARG1(*icall);
    168         ltype = IPC_GET_ARG2(*icall);
    169         rc = vbd_label_delete(disk_sid, ltype);
    170         async_answer_0(iid, (sysarg_t) rc);
    171 }
    172 
    173 static void vbd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    174 {
    175         log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_client_conn()");
     126        rc = vbds_label_create(disk_sid, ltype);
     127        async_answer_0(iid, (sysarg_t) rc);
     128}
     129
     130static void vbds_label_delete_srv(ipc_callid_t iid, ipc_call_t *icall)
     131{
     132        service_id_t disk_sid;
     133        int rc;
     134
     135        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_label_delete_srv()");
     136
     137        disk_sid = IPC_GET_ARG1(*icall);
     138        rc = vbds_label_delete(disk_sid);
     139        async_answer_0(iid, (sysarg_t) rc);
     140}
     141
     142static void vbds_label_get_parts_srv(ipc_callid_t iid, ipc_call_t *icall)
     143{
     144//      service_id_t disk_sid;
     145//      int rc;
     146
     147        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_label_get_parts_srv()");
     148
     149//      disk_sid = IPC_GET_ARG1(*icall);
     150//      rc = vbds_label_delete(disk_sid);
     151//      async_answer_0(iid, (sysarg_t) rc);
     152        async_answer_0(iid, ENOTSUP);
     153}
     154
     155static void vbds_part_get_info_srv(ipc_callid_t iid, ipc_call_t *icall)
     156{
     157        vbds_part_id_t part;
     158        vbds_part_info_t pinfo;
     159        int rc;
     160
     161        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_part_get_info_srv()");
     162
     163        part = IPC_GET_ARG1(*icall);
     164        rc = vbds_part_get_info(part, &pinfo);
     165        async_answer_0(iid, (sysarg_t)rc);
     166}
     167
     168static void vbds_part_create_srv(ipc_callid_t iid, ipc_call_t *icall)
     169{
     170        service_id_t disk_sid;
     171        vbds_part_id_t part;
     172        int rc;
     173
     174        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_part_create_srv()");
     175
     176        disk_sid = IPC_GET_ARG1(*icall);
     177        rc = vbds_part_create(disk_sid, &part);
     178        async_answer_1(iid, (sysarg_t)rc, (sysarg_t)part);
     179}
     180
     181static void vbds_part_delete_srv(ipc_callid_t iid, ipc_call_t *icall)
     182{
     183        vbds_part_id_t part;
     184        int rc;
     185
     186        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_part_delete_srv()");
     187
     188        part = IPC_GET_ARG1(*icall);
     189        rc = vbds_part_delete(part);
     190        async_answer_0(iid, (sysarg_t) rc);
     191}
     192
     193static void vbds_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     194{
     195        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_client_conn()");
    176196
    177197        /* Accept the connection */
     
    191211                switch (method) {
    192212                case VBD_DISK_ADD:
    193                         vbd_disk_add_srv(callid, &call);
     213                        vbds_disk_add_srv(callid, &call);
    194214                        break;
    195215                case VBD_DISK_REMOVE:
    196                         vbd_disk_remove_srv(callid, &call);
     216                        vbds_disk_remove_srv(callid, &call);
    197217                        break;
    198218                case VBD_DISK_INFO:
    199                         vbd_disk_info_srv(callid, &call);
     219                        vbds_disk_info_srv(callid, &call);
    200220                        break;
    201221                case VBD_LABEL_CREATE:
    202                         vbd_label_create_srv(callid, &call);
     222                        vbds_label_create_srv(callid, &call);
    203223                        break;
    204224                case VBD_LABEL_DELETE:
    205                         vbd_label_delete_srv(callid, &call);
     225                        vbds_label_delete_srv(callid, &call);
     226                        break;
     227                case VBD_LABEL_GET_PARTS:
     228                        vbds_label_get_parts_srv(callid, &call);
     229                        break;
     230                case VBD_PART_GET_INFO:
     231                        vbds_part_get_info_srv(callid, &call);
     232                        break;
     233                case VBD_PART_CREATE:
     234                        vbds_part_create_srv(callid, &call);
     235                        break;
     236                case VBD_PART_DELETE:
     237                        vbds_part_delete_srv(callid, &call);
    206238                        break;
    207239                default:
     
    222254        }
    223255
    224         rc = vbd_init();
     256        rc = vbds_init();
    225257        if (rc != EOK)
    226258                return 1;
Note: See TracChangeset for help on using the changeset viewer.