Changeset 372df8f in mainline for uspace/srv


Ignore:
Timestamp:
2015-10-09T07:00:23Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0ecfc62
Parents:
0bde8523
Message:

Let VBD handle unlabeled devices too. Now volsrv only cares about partitions.

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

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/vbd/disk.c

    r0bde8523 r372df8f  
    4848#include "types/vbd.h"
    4949
     50static fibril_mutex_t vbds_disks_lock;
    5051static list_t vbds_disks; /* of vbds_disk_t */
    5152static list_t vbds_parts; /* of vbds_part_t */
     53
     54static category_id_t part_cid;
    5255
    5356static int vbds_bd_open(bd_srvs_t *, bd_srv_t *);
    … …  
    8386}
    8487
    85 void vbds_disks_init(void)
    86 {
     88int vbds_disks_init(void)
     89{
     90        int rc;
     91
     92        fibril_mutex_initialize(&vbds_disks_lock);
    8793        list_initialize(&vbds_disks);
    8894        list_initialize(&vbds_parts);
    89 }
     95
     96        rc = loc_category_get_id("partition", &part_cid, 0);
     97        if (rc != EOK) {
     98                log_msg(LOG_DEFAULT, LVL_ERROR, "Error looking up partition "
     99                    "category.");
     100                return EIO;
     101        }
     102
     103        return EOK;
     104}
     105
     106/** Check for new disk devices */
     107static int vbds_disks_check_new(void)
     108{
     109        bool already_known;
     110        category_id_t disk_cat;
     111        service_id_t *svcs;
     112        size_t count, i;
     113        int rc;
     114
     115        fibril_mutex_lock(&vbds_disks_lock);
     116
     117        rc = loc_category_get_id("disk", &disk_cat, IPC_FLAG_BLOCKING);
     118        if (rc != EOK) {
     119                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'disk'.");
     120                fibril_mutex_unlock(&vbds_disks_lock);
     121                return ENOENT;
     122        }
     123
     124        rc = loc_category_get_svcs(disk_cat, &svcs, &count);
     125        if (rc != EOK) {
     126                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of disk "
     127                    "devices.");
     128                fibril_mutex_unlock(&vbds_disks_lock);
     129                return EIO;
     130        }
     131
     132        for (i = 0; i < count; i++) {
     133                already_known = false;
     134
     135                list_foreach(vbds_disks, ldisks, vbds_disk_t, disk) {
     136                        if (disk->svc_id == svcs[i]) {
     137                                already_known = true;
     138                                break;
     139                        }
     140                }
     141
     142                if (!already_known) {
     143                        log_msg(LOG_DEFAULT, LVL_NOTE, "Found disk '%lu'",
     144                            (unsigned long) svcs[i]);
     145                        rc = vbds_disk_add(svcs[i]);
     146                        if (rc != EOK) {
     147                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not add "
     148                                    "disk.");
     149                        }
     150                }
     151        }
     152
     153        fibril_mutex_unlock(&vbds_disks_lock);
     154        return EOK;
     155}
     156
    90157
    91158static int vbds_disk_by_svcid(service_id_t sid, vbds_disk_t **rdisk)
    … …  
    210277}
    211278
     279static void vbds_disk_cat_change_cb(void)
     280{
     281        (void) vbds_disks_check_new();
     282}
     283
     284int vbds_disk_discovery_start(void)
     285{
     286        int rc;
     287
     288        rc = loc_register_cat_change_cb(vbds_disk_cat_change_cb);
     289        if (rc != EOK) {
     290                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback "
     291                    "for disk discovery (%d).", rc);
     292                return rc;
     293        }
     294
     295        return vbds_disks_check_new();
     296}
     297
    212298int vbds_disk_add(service_id_t sid)
    213299{
    … …  
    277363                rc = vbds_part_add(disk, part, NULL);
    278364                if (rc != EOK) {
    279                         log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding partitio "
     365                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding partition "
    280366                            "(disk %s)", disk->svc_name);
    281367                }
    … …  
    313399        block_fini(sid);
    314400        free(disk);
     401        return EOK;
     402}
     403
     404/** Get list of disks as array of service IDs. */
     405int vbds_disk_get_ids(service_id_t *id_buf, size_t buf_size, size_t *act_size)
     406{
     407        size_t act_cnt;
     408        size_t buf_cnt;
     409
     410        fibril_mutex_lock(&vbds_disks_lock);
     411
     412        buf_cnt = buf_size / sizeof(service_id_t);
     413
     414        act_cnt = list_count(&vbds_disks);
     415        *act_size = act_cnt * sizeof(service_id_t);
     416
     417        if (buf_size % sizeof(service_id_t) != 0) {
     418                fibril_mutex_unlock(&vbds_disks_lock);
     419                return EINVAL;
     420        }
     421
     422        size_t pos = 0;
     423        list_foreach(vbds_disks, ldisks, vbds_disk_t, disk) {
     424                if (pos < buf_cnt)
     425                        id_buf[pos] = disk->svc_id;
     426                pos++;
     427        }
     428
     429        fibril_mutex_unlock(&vbds_disks_lock);
    315430        return EOK;
    316431}
    … …  
    751866        if (rc != EOK) {
    752867                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering "
    753                     "service %s.", name);
     868                    "service %s (%d).", name, rc);
    754869                free(name);
    755870                free(part);
     871                return EIO;
     872        }
     873
     874        rc = loc_service_add_to_cat(psid, part_cid);
     875        if (rc != EOK) {
     876                log_msg(LOG_DEFAULT, LVL_ERROR, "Failled adding partition "
     877                    "service %s to partition category.", name);
     878                free(name);
     879                free(part);
     880
     881                rc = loc_service_unregister(psid);
     882                if (rc != EOK) {
     883                        log_msg(LOG_DEFAULT, LVL_ERROR, "Error unregistering "
     884                            "service. Rollback failed.");
     885                }
    756886                return EIO;
    757887        }

  • uspace/srv/bd/vbd/disk.h

    r0bde8523 r372df8f  
    4242#include <vbd.h>
    4343
    44 extern void vbds_disks_init(void);
     44extern int vbds_disks_init(void);
     45extern int vbds_disk_discovery_start(void);
    4546extern int vbds_disk_add(service_id_t);
    4647extern int vbds_disk_remove(service_id_t);
     48extern int vbds_disk_get_ids(service_id_t *, size_t, size_t *);
    4749extern int vbds_disk_info(service_id_t, vbd_disk_info_t *);
    4850extern int vbds_get_parts(service_id_t, service_id_t *, size_t, size_t *);

  • uspace/srv/bd/vbd/vbd.c

    r0bde8523 r372df8f  
    6060        log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_init()");
    6161
    62         vbds_disks_init();
     62        rc = vbds_disks_init();
     63        if (rc != EOK)
     64                return rc;
     65
     66        rc = vbds_disk_discovery_start();
     67        if (rc != EOK)
     68                return rc;
    6369
    6470        async_set_client_connection(vbds_client_conn);
    … …  
    7985}
    8086
    81 
    82 static void vbds_disk_add_srv(ipc_callid_t iid, ipc_call_t *icall)
    83 {
    84         service_id_t disk_sid;
    85         int rc;
    86 
    87         log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_add_srv()");
    88 
    89         disk_sid = IPC_GET_ARG1(*icall);
    90         rc = vbds_disk_add(disk_sid);
    91         async_answer_0(iid, (sysarg_t) rc);
    92 }
    93 
    94 static void vbds_disk_remove_srv(ipc_callid_t iid, ipc_call_t *icall)
    95 {
    96         service_id_t disk_sid;
    97         int rc;
    98 
    99         log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_disk_remove_srv()");
    100 
    101         disk_sid = IPC_GET_ARG1(*icall);
    102         rc = vbds_disk_remove(disk_sid);
    103         async_answer_0(iid, (sysarg_t) rc);
     87static void vbds_get_disks_srv(ipc_callid_t iid, ipc_call_t *icall)
     88{
     89        ipc_callid_t callid;
     90        size_t size;
     91        size_t act_size;
     92        int rc;
     93
     94        if (!async_data_read_receive(&callid, &size)) {
     95                async_answer_0(callid, EREFUSED);
     96                async_answer_0(iid, EREFUSED);
     97                return;
     98        }
     99
     100        service_id_t *id_buf = (service_id_t *) malloc(size);
     101        if (id_buf == NULL) {
     102                async_answer_0(callid, ENOMEM);
     103                async_answer_0(iid, ENOMEM);
     104                return;
     105        }
     106
     107        rc = vbds_disk_get_ids(id_buf, size, &act_size);
     108        if (rc != EOK) {
     109                async_answer_0(callid, rc);
     110                async_answer_0(iid, rc);
     111                return;
     112        }
     113
     114        sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     115        free(id_buf);
     116
     117        async_answer_1(iid, retval, act_size);
    104118}
    105119
    … …  
    362376
    363377                switch (method) {
    364                 case VBD_DISK_ADD:
    365                         vbds_disk_add_srv(callid, &call);
    366                         break;
    367                 case VBD_DISK_REMOVE:
    368                         vbds_disk_remove_srv(callid, &call);
     378                case VBD_GET_DISKS:
     379                        vbds_get_disks_srv(callid, &call);
    369380                        break;
    370381                case VBD_DISK_INFO:

  • uspace/srv/locsrv/locsrv.c

    r0bde8523 r372df8f  
    13281328        categ_dir_add_cat(&cdir, cat);
    13291329
     1330        cat = category_new("partition");
     1331        categ_dir_add_cat(&cdir, cat);
     1332
    13301333        cat = category_new("iplink");
    13311334        categ_dir_add_cat(&cdir, cat);

  • uspace/srv/volsrv/Makefile

    r0bde8523 r372df8f  
    3131
    3232SOURCES = \
    33         disk.c \
     33        part.c \
    3434        volsrv.c
    3535

  • uspace/srv/volsrv/part.h

    r0bde8523 r372df8f  
    3535 */
    3636
    37 #ifndef DISK_H_
    38 #define DISK_H_
     37#ifndef PART_H_
     38#define pART_H_
    3939
    4040#include <sys/types.h>
    4141#include <vol.h>
    42 #include "types/disk.h"
     42#include "types/part.h"
    4343
    44 extern int vol_disk_init(void);
    45 extern int vol_disk_discovery_start(void);
    46 extern int vol_disk_get_ids(service_id_t *, size_t, size_t *);
    47 extern int vol_disk_find_by_id(service_id_t, vol_disk_t **);
    48 extern int vol_disk_label_create(vol_disk_t *, label_type_t);
    49 extern int vol_disk_empty_disk(vol_disk_t *);
    50 extern int vol_disk_get_info(vol_disk_t *, vol_disk_info_t *);
     44extern int vol_part_init(void);
     45extern int vol_part_discovery_start(void);
     46extern int vol_part_get_ids(service_id_t *, size_t, size_t *);
     47extern int vol_part_find_by_id(service_id_t, vol_part_t **);
     48extern int vol_part_empty_part(vol_part_t *);
     49extern int vol_part_get_info(vol_part_t *, vol_part_info_t *);
    5150
    5251#endif

  • uspace/srv/volsrv/types/part.h

    r0bde8523 r372df8f  
    3535 */
    3636
    37 #ifndef TYPES_DISK_H_
    38 #define TYPES_DISK_H_
     37#ifndef TYPES_PART_H_
     38#define TYPES_PART_H_
    3939
    4040#include <types/label.h>
    4141
    42 /** Disk */
     42/** Partition */
    4343typedef struct {
    44         /** Link to vol_disks */
    45         link_t ldisks;
     44        /** Link to vol_parts */
     45        link_t lparts;
    4646        /** Service ID */
    4747        service_id_t svc_id;
    … …  
    5252        /** Label type */
    5353        label_type_t ltype;
    54 } vol_disk_t;
     54} vol_part_t;
    5555
    5656#endif

  • uspace/srv/volsrv/volsrv.c

    r0bde8523 r372df8f  
    4545#include <vol.h>
    4646
    47 #include "disk.h"
     47#include "part.h"
    4848
    4949#define NAME  "volsrv"
    … …  
    5656        log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_init()");
    5757
    58         rc = vol_disk_init();
     58        rc = vol_part_init();
    5959        if (rc != EOK)
    6060                return rc;
    6161
    62         rc = vol_disk_discovery_start();
     62        rc = vol_part_discovery_start();
    6363        if (rc != EOK)
    6464                return rc;
    … …  
    8282}
    8383
    84 static void vol_get_disks_srv(ipc_callid_t iid, ipc_call_t *icall)
     84static void vol_get_parts_srv(ipc_callid_t iid, ipc_call_t *icall)
    8585{
    8686        ipc_callid_t callid;
    … …  
    102102        }
    103103
    104         rc = vol_disk_get_ids(id_buf, size, &act_size);
     104        rc = vol_part_get_ids(id_buf, size, &act_size);
    105105        if (rc != EOK) {
    106106                async_answer_0(callid, rc);
    … …  
    115115}
    116116
    117 static void vol_disk_info_srv(ipc_callid_t iid, ipc_call_t *icall)
     117static void vol_part_info_srv(ipc_callid_t iid, ipc_call_t *icall)
    118118{
    119119        service_id_t sid;
    120         vol_disk_t *disk;
    121         vol_disk_info_t dinfo;
     120        vol_part_t *part;
     121        vol_part_info_t pinfo;
    122122        int rc;
    123123
    124124        sid = IPC_GET_ARG1(*icall);
    125         rc = vol_disk_find_by_id(sid, &disk);
     125        rc = vol_part_find_by_id(sid, &part);
    126126        if (rc != EOK) {
    127127                async_answer_0(iid, ENOENT);
    … …  
    129129        }
    130130
    131         rc = vol_disk_get_info(disk, &dinfo);
     131        rc = vol_part_get_info(part, &pinfo);
    132132        if (rc != EOK) {
    133133                async_answer_0(iid, EIO);
    … …  
    135135        }
    136136
    137         async_answer_3(iid, rc, dinfo.dcnt, dinfo.ltype, dinfo.flags);
    138 }
    139 
    140 static void vol_label_create_srv(ipc_callid_t iid, ipc_call_t *icall)
     137        async_answer_3(iid, rc, pinfo.dcnt, pinfo.ltype, pinfo.flags);
     138}
     139
     140static void vol_part_empty_srv(ipc_callid_t iid, ipc_call_t *icall)
    141141{
    142142        service_id_t sid;
    143         vol_disk_t *disk;
    144         label_type_t ltype;
     143        vol_part_t *part;
    145144        int rc;
    146145
    147146        sid = IPC_GET_ARG1(*icall);
    148         ltype = IPC_GET_ARG2(*icall);
    149 
    150         rc = vol_disk_find_by_id(sid, &disk);
     147
     148        rc = vol_part_find_by_id(sid, &part);
    151149        if (rc != EOK) {
    152150                async_answer_0(iid, ENOENT);
    … …  
    154152        }
    155153
    156         rc = vol_disk_label_create(disk, ltype);
    157         if (rc != EOK) {
    158                 async_answer_0(iid, EIO);
    159                 return;
    160         }
    161 
    162         async_answer_0(iid, EOK);
    163 }
    164 
    165 static void vol_disk_empty_srv(ipc_callid_t iid, ipc_call_t *icall)
    166 {
    167         service_id_t sid;
    168         vol_disk_t *disk;
    169         int rc;
    170 
    171         sid = IPC_GET_ARG1(*icall);
    172 
    173         rc = vol_disk_find_by_id(sid, &disk);
    174         if (rc != EOK) {
    175                 async_answer_0(iid, ENOENT);
    176                 return;
    177         }
    178 
    179         rc = vol_disk_empty_disk(disk);
     154        rc = vol_part_empty_part(part);
    180155        if (rc != EOK) {
    181156                async_answer_0(iid, EIO);
    … …  
    205180
    206181                switch (method) {
    207                 case VOL_GET_DISKS:
    208                         vol_get_disks_srv(callid, &call);
     182                case VOL_GET_PARTS:
     183                        vol_get_parts_srv(callid, &call);
    209184                        break;
    210                 case VOL_DISK_INFO:
    211                         vol_disk_info_srv(callid, &call);
     185                case VOL_PART_INFO:
     186                        vol_part_info_srv(callid, &call);
    212187                        break;
    213                 case VOL_LABEL_CREATE:
    214                         vol_label_create_srv(callid, &call);
    215                         break;
    216                 case VOL_DISK_EMPTY:
    217                         vol_disk_empty_srv(callid, &call);
     188                case VOL_PART_EMPTY:
     189                        vol_part_empty_srv(callid, &call);
    218190                        break;
    219191                default:
Note: See TracChangeset for help on using the changeset viewer.