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

Changeset 22fb7ab in mainline


Ignore:
Timestamp:
2015-06-26T16:15:31Z (6 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
28ed0d9
Parents:
1356f85a
Message:

Delegate disks to volsrv and labels to vbd.

Location:
uspace
Files:
8 added
10 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/fdisk/fdisk.c

    r1356f85a r22fb7ab  
    4343
    4444static bool quit = false;
     45static fdisk_t *fdisk;
    4546
    4647/** Device menu actions */
     
    8889        }
    8990
    90         rc = fdisk_dev_list_get(&devlist);
     91        rc = fdisk_dev_list_get(fdisk, &devlist);
    9192        if (rc != EOK) {
    9293                printf("Error getting device list.\n");
     
    207208        }
    208209
    209         for (i = FDL_CREATE_LO; i < FDL_CREATE_HI; i++) {
     210        for (i = 0; i < LT_LIMIT; i++) {
    210211                rc = fdisk_ltype_format(i, &sltype);
    211212                if (rc != EOK)
     
    229230        }
    230231
    231         rc = fdisk_label_create(dev, (fdisk_label_type_t)sel);
     232        rc = fdisk_label_create(dev, (label_type_t)sel);
    232233        if (rc != EOK) {
    233234                printf("Error creating label.\n");
     
    505506        }
    506507
    507         rc = fdisk_label_get_info(dev, &linfo);
    508         if (rc != EOK) {
    509                 printf("Error getting label information.\n");
    510                 goto error;
    511         }
    512 
    513         rc = fdisk_ltype_format(linfo.ltype, &sltype);
    514         if (rc != EOK) {
    515                 assert(rc == ENOMEM);
    516                 printf("Out of memory.\n");
    517                 goto error;
    518         }
    519 
    520508        printf("Device: %s, %s\n", sdcap, svcname);
    521         printf("Label type: %s\n", sltype);
    522         free(sltype);
    523         sltype = NULL;
    524509        free(sdcap);
    525510        sdcap = NULL;
     511
     512        rc = fdisk_label_get_info(dev, &linfo);
     513        if (rc != EOK) {
     514                printf("Error getting label information.\n");
     515                goto error;
     516        }
     517
     518        switch (linfo.dcnt) {
     519        case dc_empty:
     520                printf("Disk is empty.\n");
     521                break;
     522        case dc_label:
     523                rc = fdisk_ltype_format(linfo.ltype, &sltype);
     524                if (rc != EOK) {
     525                        assert(rc == ENOMEM);
     526                        printf("Out of memory.\n");
     527                        goto error;
     528                }
     529
     530                printf("Label type: %s\n", sltype);
     531                free(sltype);
     532                sltype = NULL;
     533                break;
     534        case dc_fs:
     535                printf("Disk contains a file system.\n");
     536                break;
     537        case dc_unknown:
     538                printf("Disk contains unknown data.\n");
     539                break;
     540        }
    526541
    527542        part = fdisk_part_first(dev);
     
    563578        }
    564579
    565         if (linfo.ltype != fdl_none) {
     580        if (linfo.dcnt == dc_label) {
    566581                rc = nchoice_add(choice, "Create partition",
    567582                    (void *)devac_create_part);
     
    583598        }
    584599
    585         if (linfo.ltype == fdl_none) {
     600        if (linfo.dcnt == dc_empty) {
    586601                rc = nchoice_add(choice, "Create label",
    587602                    (void *)devac_create_label);
     
    616631        switch ((devac_t)sel) {
    617632        case devac_create_label:
    618                 rc = fdsk_create_label(dev);
    619                 if (rc != EOK)
    620                         goto error;
     633                (void) fdsk_create_label(dev);
    621634                break;
    622635        case devac_delete_label:
    623                 rc = fdsk_delete_label(dev);
    624                 if (rc != EOK)
    625                         goto error;
     636                (void) fdsk_delete_label(dev);
    626637                break;
    627638        case devac_create_part:
    628                 rc = fdsk_create_part(dev);
    629                 if (rc != EOK)
    630                         goto error;
     639                (void) fdsk_create_part(dev);
    631640                break;
    632641        case devac_delete_part:
    633                 rc = fdsk_delete_part(dev);
    634                 if (rc != EOK)
    635                         goto error;
     642                (void) fdsk_delete_part(dev);
    636643                break;
    637644        case devac_exit:
     
    658665        int rc;
    659666
     667        rc = fdisk_create(&fdisk);
     668        if (rc != EOK) {
     669                printf("Error initializing Fdisk.\n");
     670                return 1;
     671        }
     672
    660673        rc = fdsk_dev_sel_choice(&svcid);
    661674        if (rc != EOK)
     
    665678                return 0;
    666679
    667         rc = fdisk_dev_open(svcid, &dev);
     680        rc = fdisk_dev_open(fdisk, svcid, &dev);
    668681        if (rc != EOK) {
    669682                printf("Error opening device.\n");
     
    680693
    681694        fdisk_dev_close(dev);
     695        fdisk_destroy(fdisk);
    682696
    683697        return 0;
  • uspace/lib/c/Makefile

    r1356f85a r22fb7ab  
    153153        generic/stats.c \
    154154        generic/assert.c \
    155         generic/pio_trace.c
     155        generic/pio_trace.c \
     156        generic/vbd.c \
     157        generic/vol.c
    156158
    157159ifeq ($(CONFIG_RTLD),y)
  • uspace/lib/fdisk/include/fdisk.h

    r1356f85a r22fb7ab  
    4040#include <types/fdisk.h>
    4141
    42 extern int fdisk_dev_list_get(fdisk_dev_list_t **);
     42extern int fdisk_create(fdisk_t **);
     43extern void fdisk_destroy(fdisk_t *);
     44extern int fdisk_dev_list_get(fdisk_t *, fdisk_dev_list_t **);
    4345extern void fdisk_dev_list_free(fdisk_dev_list_t *);
    4446extern fdisk_dev_info_t *fdisk_dev_first(fdisk_dev_list_t *);
     
    4850extern int fdisk_dev_info_capacity(fdisk_dev_info_t *, fdisk_cap_t *);
    4951
    50 extern int fdisk_dev_open(service_id_t, fdisk_dev_t **);
     52extern int fdisk_dev_open(fdisk_t *, service_id_t, fdisk_dev_t **);
    5153extern void fdisk_dev_close(fdisk_dev_t *);
    5254extern int fdisk_dev_get_svcname(fdisk_dev_t *, char **);
     
    5456
    5557extern int fdisk_label_get_info(fdisk_dev_t *, fdisk_label_info_t *);
    56 extern int fdisk_label_create(fdisk_dev_t *, fdisk_label_type_t);
     58extern int fdisk_label_create(fdisk_dev_t *, label_type_t);
    5759extern int fdisk_label_destroy(fdisk_dev_t *);
    5860
     
    6870extern int fdisk_cap_format(fdisk_cap_t *, char **);
    6971extern int fdisk_cap_parse(const char *, fdisk_cap_t *);
    70 extern int fdisk_ltype_format(fdisk_label_type_t, char **);
     72extern int fdisk_ltype_format(label_type_t, char **);
    7173extern int fdisk_fstype_format(fdisk_fstype_t, char **);
    7274
  • uspace/lib/fdisk/include/types/fdisk.h

    r1356f85a r22fb7ab  
    4040#include <loc.h>
    4141#include <stdint.h>
     42#include <types/label.h>
     43#include <vol.h>
    4244
    4345typedef enum {
     
    9597} fdisk_dev_info_t;
    9698
    97 /** Fdisk label type */
    98 typedef enum {
    99         /** None */
    100         fdl_none = 0,
    101         /** Unknown */
    102         fdl_unknown,
    103         /** BIOS Master Boot Record */
    104         fdl_mbr,
    105         /** UEFI GUID Partition Table */
    106         fdl_gpt
    107 } fdisk_label_type_t;
    108 
    109 /** Highest label type + 1 */
    110 #define FDL_LIMIT (fdl_gpt + 1)
    111 /** Lowest label type allowed for creation */
    112 #define FDL_CREATE_LO fdl_mbr
    113 /** Highest label type allowed for creation + 1 */
    114 #define FDL_CREATE_HI (fdl_gpt + 1)
    115 
    11699/** Open fdisk device */
    117100typedef struct {
    118         /** Label type */
    119         fdisk_label_type_t ltype;
     101        /** Fdisk instance */
     102        struct fdisk *fdisk;
     103        /** Disk contents */
     104        label_disk_cnt_t dcnt;
     105        /** Service ID */
     106        service_id_t sid;
    120107        /** Partitions */
    121108        list_t parts; /* of fdisk_part_t */
    122         /** Service ID */
    123         service_id_t sid;
    124109} fdisk_dev_t;
    125110
    126111typedef struct {
     112        /** Disk contents */
     113        label_disk_cnt_t dcnt;
    127114        /** Label type */
    128         fdisk_label_type_t ltype;
     115        label_type_t ltype;
    129116} fdisk_label_info_t;
    130117
     
    156143} fdisk_part_info_t;
    157144
     145/** Fdisk instance */
     146typedef struct fdisk {
     147        /** Volume service */
     148        vol_t *vol;
     149} fdisk_t;
     150
    158151#endif
    159152
  • uspace/lib/fdisk/src/fdisk.c

    r1356f85a r22fb7ab  
    4343#include <stdlib.h>
    4444#include <str.h>
     45#include <vol.h>
    4546
    4647static const char *cu_str[] = {
     
    6869}
    6970
    70 int fdisk_dev_list_get(fdisk_dev_list_t **rdevlist)
     71int fdisk_create(fdisk_t **rfdisk)
     72{
     73        fdisk_t *fdisk;
     74        int rc;
     75
     76        fdisk = calloc(1, sizeof(fdisk_t));
     77        if (fdisk == NULL)
     78                return ENOMEM;
     79
     80        rc = vol_create(&fdisk->vol);
     81        if (rc != EOK) {
     82                free(fdisk);
     83                return EIO;
     84        }
     85
     86        *rfdisk = fdisk;
     87        return EOK;
     88}
     89
     90void fdisk_destroy(fdisk_t *fdisk)
     91{
     92        vol_destroy(fdisk->vol);
     93        free(fdisk);
     94}
     95
     96int fdisk_dev_list_get(fdisk_t *fdisk, fdisk_dev_list_t **rdevlist)
    7197{
    7298        fdisk_dev_list_t *devlist = NULL;
    7399        fdisk_dev_info_t *info;
    74         category_id_t disk_cat;
    75100        service_id_t *svcs = NULL;
    76101        size_t count, i;
     
    83108        list_initialize(&devlist->devinfos);
    84109
    85         rc = loc_category_get_id("disk", &disk_cat, 0);
    86         if (rc != EOK) {
    87                 rc = EIO;
    88                 goto error;
    89         }
    90 
    91         rc = loc_category_get_svcs(disk_cat, &svcs, &count);
     110        rc = vol_get_disks(fdisk->vol, &svcs, &count);
    92111        if (rc != EOK) {
    93112                rc = EIO;
     
    210229}
    211230
    212 int fdisk_dev_open(service_id_t sid, fdisk_dev_t **rdev)
     231int fdisk_dev_open(fdisk_t *fdisk, service_id_t sid, fdisk_dev_t **rdev)
    213232{
    214233        fdisk_dev_t *dev;
     
    218237                return ENOMEM;
    219238
    220         dev->ltype = fdl_none;
     239        dev->fdisk = fdisk;
    221240        dev->sid = sid;
    222241        list_initialize(&dev->parts);
     
    271290int fdisk_label_get_info(fdisk_dev_t *dev, fdisk_label_info_t *info)
    272291{
    273         info->ltype = dev->ltype;
    274         return EOK;
    275 }
    276 
    277 int fdisk_label_create(fdisk_dev_t *dev, fdisk_label_type_t ltype)
    278 {
    279         if (dev->ltype != fdl_none)
    280                 return EEXISTS;
    281 
    282         dev->ltype = ltype;
    283         return EOK;
     292        vol_disk_info_t vinfo;
     293        int rc;
     294
     295        rc = vol_disk_info(dev->fdisk->vol, dev->sid, &vinfo);
     296        if (rc != EOK) {
     297                rc = EIO;
     298                goto error;
     299        }
     300
     301        info->dcnt = vinfo.dcnt;
     302        info->ltype = vinfo.ltype;
     303        return EOK;
     304error:
     305        return rc;
     306}
     307
     308int fdisk_label_create(fdisk_dev_t *dev, label_type_t ltype)
     309{
     310        return vol_label_create(dev->fdisk->vol, dev->sid, ltype);
    284311}
    285312
     
    287314{
    288315        fdisk_part_t *part;
    289 
    290         if (dev->ltype == fdl_none)
    291                 return ENOENT;
     316        int rc;
    292317
    293318        part = fdisk_part_first(dev);
     
    297322        }
    298323
    299         dev->ltype = fdl_none;
     324        rc = vol_disk_empty(dev->fdisk->vol, dev->sid);
     325        if (rc != EOK)
     326                return EIO;
     327
     328        dev->dcnt = dc_empty;
    300329        return EOK;
    301330}
     
    419448}
    420449
    421 int fdisk_ltype_format(fdisk_label_type_t ltype, char **rstr)
     450int fdisk_ltype_format(label_type_t ltype, char **rstr)
    422451{
    423452        const char *sltype;
     
    426455        sltype = NULL;
    427456        switch (ltype) {
    428         case fdl_none:
    429                 sltype = "None";
    430                 break;
    431         case fdl_unknown:
    432                 sltype = "Unknown";
    433                 break;
    434         case fdl_mbr:
     457        case lt_mbr:
    435458                sltype = "MBR";
    436459                break;
    437         case fdl_gpt:
     460        case lt_gpt:
    438461                sltype = "GPT";
    439462                break;
  • uspace/srv/bd/vbd/vbd.c

    r1356f85a r22fb7ab  
    2727 */
    2828
    29 /** @addtogroup dnsres
     29/** @addtogroup vbd
    3030 * @{
    3131 */
     
    3838#include <io/log.h>
    3939#include <ipc/services.h>
     40#include <ipc/vbd.h>
    4041#include <loc.h>
    4142#include <stdio.h>
     
    4344#include <task.h>
    4445
     46#include "types/vbd.h"
     47
    4548#define NAME  "vbd"
    4649
     
    5053{
    5154        int rc;
    52         log_msg(LOG_DEFAULT, LVL_DEBUG, "vbd_init()");
     55        log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_init()");
    5356
    5457        async_set_client_connection(vbd_client_conn);
     
    7073}
    7174
     75static 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
     81static 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
     87static 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
     94static 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
     101static 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
     108static 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
     120static 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
     132static 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);
     142        async_answer_1(iid, (sysarg_t)rc, (sysarg_t)dinfo.ltype);
     143}
     144
     145static void vbd_label_create_srv(ipc_callid_t iid, ipc_call_t *icall)
     146{
     147        service_id_t disk_sid;
     148        label_type_t ltype;
     149        int rc;
     150
     151        log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_label_create_srv()");
     152
     153        disk_sid = IPC_GET_ARG1(*icall);
     154        ltype = IPC_GET_ARG2(*icall);
     155        rc = vbd_label_create(disk_sid, ltype);
     156        async_answer_0(iid, (sysarg_t) rc);
     157}
     158
     159static 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}
    72172
    73173static void vbd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    74174{
    75         log_msg(LOG_DEFAULT, LVL_DEBUG, "vbd_client_conn()");
     175        log_msg(LOG_DEFAULT, LVL_NOTE, "vbd_client_conn()");
    76176
    77177        /* Accept the connection */
     
    90190
    91191                switch (method) {
     192                case VBD_DISK_ADD:
     193                        vbd_disk_add_srv(callid, &call);
     194                        break;
     195                case VBD_DISK_REMOVE:
     196                        vbd_disk_remove_srv(callid, &call);
     197                        break;
     198                case VBD_DISK_INFO:
     199                        vbd_disk_info_srv(callid, &call);
     200                        break;
     201                case VBD_LABEL_CREATE:
     202                        vbd_label_create_srv(callid, &call);
     203                        break;
     204                case VBD_LABEL_DELETE:
     205                        vbd_label_delete_srv(callid, &call);
     206                        break;
    92207                default:
    93208                        async_answer_0(callid, EINVAL);
  • uspace/srv/volsrv/disk.c

    r1356f85a r22fb7ab  
    4242#include <stdlib.h>
    4343#include <str.h>
     44#include <vbd.h>
    4445
    4546#include "disk.h"
     
    4849static int vol_disk_add(service_id_t);
    4950
    50 static LIST_INITIALIZE(vol_disks);
     51static LIST_INITIALIZE(vol_disks); /* of vol_disk_t */
    5152static FIBRIL_MUTEX_INITIALIZE(vol_disks_lock);
     53static vbd_t *vbd;
    5254
    5355/** Check for new disk devices */
     
    113115
    114116        link_initialize(&disk->ldisks);
     117        disk->dcnt = dc_empty;
    115118
    116119        return disk;
     
    129132{
    130133        vol_disk_t *disk;
     134        vbd_disk_info_t dinfo;
    131135        int rc;
    132136
     
    147151
    148152        log_msg(LOG_DEFAULT, LVL_NOTE, "Probe disk %s", disk->svc_name);
    149 /*      rc = inetcfg_link_add(sid);
    150         if (rc != EOK) {
    151                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed configuring link "
    152                     "'%s'.\n", nlink->svc_name);
    153                 goto error;
    154         }
    155 */
     153
     154        rc = vbd_disk_add(vbd, sid);
     155        if (rc == EOK) {
     156                log_msg(LOG_DEFAULT, LVL_NOTE, "Disk %s accepted by VBD.",
     157                    disk->svc_name);
     158
     159                rc = vbd_disk_info(vbd, sid, &dinfo);
     160                if (rc != EOK) {
     161                        log_msg(LOG_DEFAULT, LVL_NOTE, "Cannot get disk label "
     162                            "information.");
     163                        rc = EIO;
     164                        goto error;
     165                }
     166
     167                disk->dcnt = dc_label;
     168                disk->ltype = dinfo.ltype;
     169        } else {
     170                log_msg(LOG_DEFAULT, LVL_NOTE, "Disk %s not accepted by VBD.",
     171                    disk->svc_name);
     172                disk->dcnt = dc_unknown;
     173        }
     174
    156175        list_append(&disk->ldisks, &vol_disks);
    157176
     
    168187}
    169188
     189int vol_disk_init(void)
     190{
     191        int rc;
     192
     193        rc = vbd_create(&vbd);
     194        if (rc != EOK) {
     195                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing VBD.");
     196                return EIO;
     197        }
     198
     199        return EOK;
     200}
     201
    170202int vol_disk_discovery_start(void)
    171203{
     
    182214}
    183215
     216/** Get list of disks as array of service IDs. */
     217int vol_disk_get_ids(service_id_t *id_buf, size_t buf_size, size_t *act_size)
     218{
     219        size_t act_cnt;
     220        size_t buf_cnt;
     221
     222        fibril_mutex_lock(&vol_disks_lock);
     223
     224        buf_cnt = buf_size / sizeof(service_id_t);
     225
     226        act_cnt = list_count(&vol_disks);
     227        *act_size = act_cnt * sizeof(service_id_t);
     228
     229        if (buf_size % sizeof(service_id_t) != 0) {
     230                fibril_mutex_unlock(&vol_disks_lock);
     231                return EINVAL;
     232        }
     233
     234        size_t pos = 0;
     235        list_foreach(vol_disks, ldisks, vol_disk_t, disk) {
     236                if (pos < buf_cnt)
     237                        id_buf[pos] = disk->svc_id;
     238                pos++;
     239        }
     240
     241        fibril_mutex_unlock(&vol_disks_lock);
     242        return EOK;
     243}
     244
     245int vol_disk_find_by_id(service_id_t sid, vol_disk_t **rdisk)
     246{
     247        list_foreach(vol_disks, ldisks, vol_disk_t, disk) {
     248                if (disk->svc_id == sid) {
     249                        *rdisk = disk;
     250                        /* XXX Add reference */
     251                        return EOK;
     252                }
     253        }
     254
     255        return ENOENT;
     256}
     257
    184258/** @}
    185259 */
  • uspace/srv/volsrv/disk.h

    r1356f85a r22fb7ab  
    3939
    4040#include <sys/types.h>
     41#include "types/disk.h"
    4142
     43extern int vol_disk_init(void);
    4244extern int vol_disk_discovery_start(void);
     45extern int vol_disk_get_ids(service_id_t *, size_t, size_t *);
     46extern int vol_disk_find_by_id(service_id_t, vol_disk_t **);
    4347
    4448#endif
  • uspace/srv/volsrv/types/disk.h

    r1356f85a r22fb7ab  
    3838#define TYPES_DISK_H_
    3939
     40#include <types/label.h>
     41
    4042/** Disk */
    4143typedef struct {
     
    4648        /** Service name */
    4749        char *svc_name;
     50        /** Disk contents */
     51        label_disk_cnt_t dcnt;
     52        /** Label type */
     53        label_type_t ltype;
    4854} vol_disk_t;
    4955
  • uspace/srv/volsrv/volsrv.c

    r1356f85a r22fb7ab  
    3838#include <io/log.h>
    3939#include <ipc/services.h>
     40#include <ipc/vol.h>
    4041#include <loc.h>
    4142#include <stdio.h>
     
    5455        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_init()");
    5556
     57        rc = vol_disk_init();
     58        if (rc != EOK)
     59                return rc;
     60
    5661        rc = vol_disk_discovery_start();
    5762        if (rc != EOK)
     
    7681}
    7782
     83static void vol_get_disks_srv(ipc_callid_t iid, ipc_call_t *icall)
     84{
     85        ipc_callid_t callid;
     86        size_t size;
     87        size_t act_size;
     88        int rc;
     89
     90        if (!async_data_read_receive(&callid, &size)) {
     91                async_answer_0(callid, EREFUSED);
     92                async_answer_0(iid, EREFUSED);
     93                return;
     94        }
     95
     96        service_id_t *id_buf = (service_id_t *) malloc(size);
     97        if (id_buf == NULL) {
     98                async_answer_0(callid, ENOMEM);
     99                async_answer_0(iid, ENOMEM);
     100                return;
     101        }
     102
     103        rc = vol_disk_get_ids(id_buf, size, &act_size);
     104        if (rc != EOK) {
     105                async_answer_0(callid, rc);
     106                async_answer_0(iid, rc);
     107                return;
     108        }
     109
     110        sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     111        free(id_buf);
     112
     113        async_answer_1(iid, retval, act_size);
     114}
     115
     116static void vol_disk_info_srv(ipc_callid_t iid, ipc_call_t *icall)
     117{
     118        service_id_t sid;
     119        vol_disk_t *disk;
     120        int rc;
     121
     122        sid = IPC_GET_ARG1(*icall);
     123        rc = vol_disk_find_by_id(sid, &disk);
     124        if (rc != EOK) {
     125                async_answer_0(iid, ENOENT);
     126                return;
     127        }
     128
     129        async_answer_2(iid, rc, disk->dcnt, disk->ltype);
     130}
     131
     132static void vol_label_create_srv(ipc_callid_t iid, ipc_call_t *icall)
     133{
     134        service_id_t sid;
     135        vol_disk_t *disk;
     136        label_type_t ltype;
     137        int rc;
     138
     139        sid = IPC_GET_ARG1(*icall);
     140        ltype = IPC_GET_ARG2(*icall);
     141
     142        rc = vol_disk_find_by_id(sid, &disk);
     143        if (rc != EOK) {
     144                async_answer_0(iid, ENOENT);
     145                return;
     146        }
     147
     148        disk->dcnt = dc_label;
     149        disk->ltype = ltype;
     150
     151        async_answer_0(iid, EOK);
     152}
     153
     154static void vol_disk_empty_srv(ipc_callid_t iid, ipc_call_t *icall)
     155{
     156        service_id_t sid;
     157        vol_disk_t *disk;
     158        int rc;
     159
     160        sid = IPC_GET_ARG1(*icall);
     161
     162        rc = vol_disk_find_by_id(sid, &disk);
     163        if (rc != EOK) {
     164                async_answer_0(iid, ENOENT);
     165                return;
     166        }
     167
     168        disk->dcnt = dc_empty;
     169
     170        async_answer_0(iid, EOK);
     171}
    78172
    79173static void vol_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     
    96190
    97191                switch (method) {
     192                case VOL_GET_DISKS:
     193                        vol_get_disks_srv(callid, &call);
     194                        break;
     195                case VOL_DISK_INFO:
     196                        vol_disk_info_srv(callid, &call);
     197                        break;
     198                case VOL_LABEL_CREATE:
     199                        vol_label_create_srv(callid, &call);
     200                        break;
     201                case VOL_DISK_EMPTY:
     202                        vol_disk_empty_srv(callid, &call);
     203                        break;
    98204                default:
    99205                        async_answer_0(callid, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.