Changeset 68e357e in mainline


Ignore:
Timestamp:
2024-09-05T20:54:51Z (8 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
44ea48e
Parents:
680e8c8
Message:

hr: use array for devname and devices for now

Location:
uspace
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hrctl/hrctl.c

    r680e8c8 r68e357e  
    8282}
    8383
    84 static errno_t get_dev_svc_ids(int argc, char **argv, int optind, int dev_no,
    85     service_id_t **rdevs)
     84static errno_t fill_config_devs(int argc, char **argv, int optind,
     85    hr_config_t *cfg)
    8686{
    8787        errno_t rc;
    88         int i;
    89         size_t k;
    90         service_id_t *devs;
    91 
    92         devs = calloc(dev_no, sizeof(service_id_t));
    93         if (devs == NULL)
    94                 return ENOMEM;
    95 
    96         for (i = optind, k = 0; i < argc; i++, k++) {
    97                 rc = loc_service_get_id(argv[i], &devs[k], 0);
     88        size_t i;
     89
     90        for (i = 0; i < cfg->dev_no; i++) {
     91                rc = loc_service_get_id(argv[optind++], &cfg->devs[i], 0);
    9892                if (rc != EOK) {
    9993                        printf("hrctl: error resolving device \"%s\"\n", argv[i]);
    100                         free(devs);
    10194                        return EINVAL;
    10295                }
    10396        }
    104 
    105         *rdevs = devs;
    10697
    10798        return EOK;
    … …  
    111102{
    112103        errno_t rc;
    113         int retval, c, dev_no;
     104        int retval, c;
    114105        bool create, assemble;
    115         char *name = NULL;
    116         service_id_t *devs = NULL;
    117106        hr_t *hr;
    118         hr_config_t hr_config;
    119         hr_level_t level;
     107        hr_config_t *cfg;
     108
     109        cfg = calloc(1, sizeof(hr_config_t));
     110        if (cfg == NULL)
     111                return 1;
    120112
    121113        retval = 0;
    122         level = hr_l_empty;
    123         dev_no = 0;
     114        cfg->level = hr_l_empty;
     115        cfg->dev_no = 0;
    124116        create = assemble = false;
    125117
    … …  
    143135                        return 0;
    144136                case 'a':
    145                         name = optarg;
     137                        if (str_size(optarg) > 31) {
     138                                printf("hrctl: device name longer than 31 bytes\n");
     139                                return 1;
     140                        }
     141                        str_cpy(cfg->devname, 32, optarg);
    146142                        assemble = true;
    147143                        break;
    148144                case 'c':
    149                         name = optarg;
     145                        if (str_size(optarg) > 31) {
     146                                printf("hrctl: device name longer than 31 bytes\n");
     147                                return 1;
     148                        }
     149                        str_cpy(cfg->devname, 32, optarg);
    150150                        create = true;
    151151                        break;
    152152                case 'l':
    153                         if (level != hr_l_empty)
     153                        if (cfg->level != hr_l_empty)
    154154                                goto bad;
    155155                        if (str_cmp(optarg, "linear") == 0)
    156                                 level = hr_l_linear;
     156                                cfg->level = hr_l_linear;
    157157                        else
    158                                 level = strtol(optarg, NULL, 10);
     158                                cfg->level = strtol(optarg, NULL, 10);
    159159                        break;
    160160                case '0':
    161                         if (level != hr_l_empty)
    162                                 goto bad;
    163                         level = hr_l_0;
     161                        if (cfg->level != hr_l_empty)
     162                                goto bad;
     163                        cfg->level = hr_l_0;
    164164                        break;
    165165                case '1':
    166                         if (level != hr_l_empty)
    167                                 goto bad;
    168                         level = hr_l_1;
     166                        if (cfg->level != hr_l_empty)
     167                                goto bad;
     168                        cfg->level = hr_l_1;
    169169                        break;
    170170                case '5':
    171                         if (level != hr_l_empty)
    172                                 goto bad;
    173                         level = hr_l_5;
     171                        if (cfg->level != hr_l_empty)
     172                                goto bad;
     173                        cfg->level = hr_l_5;
    174174                        break;
    175175                case 'L':
    176                         if (level != hr_l_empty)
    177                                 goto bad;
    178                         level = hr_l_linear;
     176                        if (cfg->level != hr_l_empty)
     177                                goto bad;
     178                        cfg->level = hr_l_linear;
    179179                        break;
    180180                case 'n':
    181                         dev_no = strtol(optarg, NULL, 10);
    182                         if (dev_no + optind != argc)
    183                                 goto bad;
    184                         rc = get_dev_svc_ids(argc, argv, optind, dev_no, &devs);
     181                        cfg->dev_no = strtol(optarg, NULL, 10);
     182                        if ((int) cfg->dev_no + optind != argc)
     183                                goto bad;
     184                        if (cfg->dev_no > HR_MAXDEVS) {
     185                                printf("hrctl: too many devices\n");
     186                                return 1;
     187                        }
     188                        rc = fill_config_devs(argc, argv, optind, cfg);
    185189                        if (rc != EOK)
    186190                                return 1;
    … …  
    191195        if ((create && assemble) ||
    192196            (!create && !assemble) ||
    193             (create && level == hr_l_empty) ||
    194             (assemble && level != hr_l_empty) ||
    195             (dev_no == 0)) {
    196                 free(devs);
     197            (create && cfg->level == hr_l_empty) ||
     198            (assemble && cfg->level != hr_l_empty) ||
     199            (cfg->dev_no == 0)) {
    197200                goto bad;
    198201        }
    199 
    200         hr_config.level = level;
    201         hr_config.dev_no = dev_no;
    202         hr_config.name = name;
    203         hr_config.devs = devs;
    204202
    205203        rc = hr_sess_init(&hr);
    … …  
    211209
    212210        if (create) {
    213                 rc = hr_create(hr, &hr_config);
     211                rc = hr_create(hr, cfg);
    214212                printf("hrctl: hr_create() rc: %s\n", str_error(rc));
    215213        } else if (assemble) {
    … …  
    218216
    219217end:
    220         free(devs);
     218        free(cfg);
    221219        hr_sess_destroy(hr);
    222220        return retval;
    223221bad:
     222        free(cfg);
    224223        printf("hrctl: bad usage, try hrctl --help\n");
    225224        return 1;

  • uspace/lib/device/include/hr.h

    r680e8c8 r68e357e  
    4141#include <loc.h>
    4242
     43/* for now */
     44#define HR_MAXDEVS 4
     45
    4346typedef struct hr {
    4447        async_sess_t *sess;
    … …  
    5457
    5558typedef struct hr_config {
    56         char *name;
    57         service_id_t *devs;
     59        char devname[32];
     60        service_id_t devs[HR_MAXDEVS];
    5861        size_t dev_no;
    5962        hr_level_t level;

  • uspace/lib/device/src/hr.c

    r680e8c8 r68e357e  
    9494
    9595        exch = async_exchange_begin(hr->sess);
    96         if (exch == NULL) {
     96        if (exch == NULL)
    9797                return EINVAL;
    98         }
    9998
    100         req = async_send_1(exch, HR_CREATE, hr_config->level, NULL);
     99        req = async_send_0(exch, HR_CREATE, NULL);
    101100
    102         rc = async_data_write_start(exch, hr_config->name,
    103             str_size(hr_config->name));
    104         if (rc != EOK) {
    105                 async_exchange_end(exch);
    106                 async_forget(req);
    107                 return rc;
    108         }
    109 
    110         rc = async_data_write_start(exch, hr_config->devs,
    111             sizeof(service_id_t) * hr_config->dev_no);
     101        rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
    112102        if (rc != EOK) {
    113103                async_exchange_end(exch);

  • uspace/srv/bd/hr/hr.c

    r680e8c8 r68e357e  
    4646#include <stdio.h>
    4747#include <stdlib.h>
     48#include <str.h>
    4849#include <str_error.h>
    4950
    … …  
    6465        errno_t rc;
    6566        size_t size;
    66         hr_config_t *hr_config;
    67 
    68         hr_config = calloc(1, sizeof(hr_config_t));
    69         if (hr_config == NULL) {
     67        hr_config_t *cfg;
     68        hr_volume_t *new_volume;
     69        ipc_call_t call;
     70
     71        if (!async_data_write_receive(&call, &size)) {
     72                async_answer_0(&call, EREFUSED);
     73                async_answer_0(icall, EREFUSED);
     74                return;
     75        }
     76
     77        if (size != sizeof(hr_config_t)) {
     78                async_answer_0(&call, EINVAL);
     79                async_answer_0(icall, EINVAL);
     80                return;
     81        }
     82
     83        cfg = calloc(1, sizeof(hr_config_t));
     84        if (cfg == NULL) {
     85                async_answer_0(&call, ENOMEM);
    7086                async_answer_0(icall, ENOMEM);
    7187                return;
    7288        }
    7389
    74         hr_config->level = ipc_get_arg1(icall);
    75 
    76         rc = async_data_write_accept((void **) &hr_config->name, true, 0, 0, 0,
    77             NULL);
    78         if (rc != EOK) {
    79                 async_answer_0(icall, EREFUSED);
    80                 return;
    81         }
    82 
    83         rc = async_data_write_accept((void **) &hr_config->devs, false,
    84             sizeof(service_id_t), 0, 0, &size);
    85         if (rc != EOK) {
    86                 async_answer_0(icall, EREFUSED);
    87                 return;
    88         }
    89 
    90         hr_config->dev_no = size / sizeof(service_id_t);
    91 
    92         hr_volume_t *new_volume = calloc(1, sizeof(hr_volume_t));
     90        rc = async_data_write_finalize(&call, cfg, size);
     91        if (rc != EOK) {
     92                async_answer_0(&call, rc);
     93                async_answer_0(icall, rc);
     94        }
     95
     96        new_volume = calloc(1, sizeof(hr_volume_t));
    9397        if (new_volume == NULL) {
    9498                rc = ENOMEM;
    9599                goto end;
    96100        }
    97         new_volume->devname = hr_config->name;
    98         new_volume->level = hr_config->level;
    99         new_volume->dev_no = hr_config->dev_no;
    100         new_volume->devs = hr_config->devs;
    101 
    102         switch (hr_config->level) {
     101
     102        str_cpy(new_volume->devname, 32, cfg->devname);
     103        memcpy(new_volume->devs, cfg->devs, sizeof(service_id_t) * HR_MAXDEVS);
     104        new_volume->level = cfg->level;
     105        new_volume->dev_no = cfg->dev_no;
     106
     107        switch (new_volume->level) {
    103108        case hr_l_1:
    104109                new_volume->hr_ops.create = hr_raid1_create;
    … …  
    115120
    116121        rc = new_volume->hr_ops.create(new_volume);
    117         if (rc != EOK)
     122        if (rc != EOK) {
    118123                goto end;
     124        }
    119125
    120126        fibril_mutex_lock(&hr_volumes_lock);
    … …  
    126132
    127133end:
    128         free(hr_config);
     134        free(cfg);
    129135        async_answer_0(icall, rc);
    130136}

  • uspace/srv/bd/hr/var.h

    r680e8c8 r68e357e  
    5353        bd_srvs_t hr_bds;
    5454        link_t lvolumes;
    55         char *devname;
    56         service_id_t *devs;
     55        char devname[32];
     56        service_id_t devs[HR_MAXDEVS];
    5757        uint64_t nblocks;
    5858        size_t bsize;
Note: See TracChangeset for help on using the changeset viewer.