Changeset c997374 in mainline


Ignore:
Timestamp:
2024-10-10T13:31:42Z (7 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
4b759dc
Parents:
2b8901be
Message:

hr: merge assemble and create functions

Location:
uspace
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hrctl/hrctl.c

    r2b8901be rc997374  
    359359
    360360        if (create) {
    361                 rc = hr_create(hr, cfg);
     361                rc = hr_create(hr, cfg, false);
    362362                printf("hrctl: hr_create() rc: %s\n", str_error(rc));
    363363        } else if (assemble) {
    364                 rc = hr_assemble(hr, cfg);
     364                rc = hr_create(hr, cfg, true);
    365365                printf("hrctl: hr_assemble() rc: %s\n", str_error(rc));
    366366        }

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

    r2b8901be rc997374  
    8282extern void hr_sess_destroy(hr_t *);
    8383
    84 extern errno_t hr_create(hr_t *, hr_config_t *);
    85 extern errno_t hr_assemble(hr_t *, hr_config_t *);
     84extern errno_t hr_create(hr_t *, hr_config_t *, bool);
    8685extern errno_t hr_stop(const char *);
    8786extern errno_t hr_print_status(void);

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

    r2b8901be rc997374  
    8787}
    8888
    89 errno_t hr_create(hr_t *hr, hr_config_t *hr_config)
     89errno_t hr_create(hr_t *hr, hr_config_t *hr_config, bool assemble)
    9090{
    9191        errno_t rc, retval;
    … …  
    9797                return EINVAL;
    9898
    99         req = async_send_0(exch, HR_CREATE, NULL);
    100 
    101         rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
    102         if (rc != EOK) {
    103                 async_exchange_end(exch);
    104                 async_forget(req);
    105                 return rc;
    106         }
    107 
    108         async_exchange_end(exch);
    109         async_wait_for(req, &retval);
    110         if (retval != EOK)
    111                 return retval;
    112 
    113         return EOK;
    114 }
    115 
    116 errno_t hr_assemble(hr_t *hr, hr_config_t *hr_config)
    117 {
    118         errno_t rc, retval;
    119         async_exch_t *exch;
    120         aid_t req;
    121 
    122         exch = async_exchange_begin(hr->sess);
    123         if (exch == NULL)
    124                 return EINVAL;
    125 
    126         req = async_send_0(exch, HR_ASSEMBLE, NULL);
     99        req = async_send_0(exch, assemble ? HR_ASSEMBLE : HR_CREATE, NULL);
    127100
    128101        rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));

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

    r2b8901be rc997374  
    9898}
    9999
    100 static void hr_create_srv(ipc_call_t *icall)
     100static void hr_create_srv(ipc_call_t *icall, bool assemble)
    101101{
    102102        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_create_srv()");
    … …  
    147147        new_volume->dev_no = cfg->dev_no;
    148148
     149        if (assemble) {
     150                if (cfg->level != hr_l_empty)
     151                        log_msg(LOG_DEFAULT, LVL_WARN,
     152                            "level manually set when assembling, ingoring");
     153                new_volume->level = hr_l_empty;
     154        }
     155
    149156        rc = hr_init_devs(new_volume);
    150157        if (rc != EOK) {
    … …  
    152159                async_answer_0(icall, rc);
    153160                return;
     161        }
     162
     163        if (assemble) {
     164                /* just bsize needed for reading metadata later */
     165                rc = hr_check_devs(new_volume, NULL, &new_volume->bsize);
     166                if (rc != EOK)
     167                        goto error;
     168
     169                rc = hr_get_vol_from_meta(cfg, new_volume);
     170                if (rc != EOK)
     171                        goto error;
    154172        }
    155173
    … …  
    178196        }
    179197
    180         new_volume->hr_ops.init(new_volume);
    181         if (rc != EOK)
    182                 goto error;
    183 
    184         rc = hr_write_meta_to_vol(new_volume);
    185         if (rc != EOK)
    186                 goto error;
     198        if (!assemble) {
     199                new_volume->hr_ops.init(new_volume);
     200                if (rc != EOK)
     201                        goto error;
     202
     203                rc = hr_write_meta_to_vol(new_volume);
     204                if (rc != EOK)
     205                        goto error;
     206        }
    187207
    188208        rc = new_volume->hr_ops.create(new_volume);
    … …  
    194214        fibril_mutex_unlock(&hr_volumes_lock);
    195215
    196         log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")",
    197             new_volume->devname, new_volume->svc_id);
    198 
    199         free(cfg);
    200         async_answer_0(icall, rc);
    201         return;
    202 error:
    203         free(cfg);
    204         hr_fini_devs(new_volume);
    205         async_answer_0(icall, rc);
    206 }
    207 
    208 static void hr_assemble_srv(ipc_call_t *icall)
    209 {
    210         log_msg(LOG_DEFAULT, LVL_NOTE, "hr_assemble_srv()");
    211 
    212         errno_t rc;
    213         size_t i, size;
    214         hr_config_t *cfg;
    215         hr_volume_t *new_volume;
    216         ipc_call_t call;
    217 
    218         if (!async_data_write_receive(&call, &size)) {
    219                 async_answer_0(&call, EREFUSED);
    220                 async_answer_0(icall, EREFUSED);
    221                 return;
    222         }
    223 
    224         if (size != sizeof(hr_config_t)) {
    225                 async_answer_0(&call, EINVAL);
    226                 async_answer_0(icall, EINVAL);
    227                 return;
    228         }
    229 
    230         cfg = calloc(1, sizeof(hr_config_t));
    231         if (cfg == NULL) {
    232                 async_answer_0(&call, ENOMEM);
    233                 async_answer_0(icall, ENOMEM);
    234                 return;
    235         }
    236 
    237         rc = async_data_write_finalize(&call, cfg, size);
    238         if (rc != EOK) {
    239                 async_answer_0(&call, rc);
    240                 async_answer_0(icall, rc);
    241                 return;
    242         }
    243 
    244         new_volume = calloc(1, sizeof(hr_volume_t));
    245         if (new_volume == NULL) {
    246                 free(cfg);
    247                 async_answer_0(icall, ENOMEM);
    248                 return;
    249         }
    250 
    251         str_cpy(new_volume->devname, 32, cfg->devname);
    252         for (i = 0; i < cfg->dev_no; i++)
    253                 new_volume->extents[i].svc_id = cfg->devs[i];
    254         new_volume->dev_no = cfg->dev_no;
    255 
    256         if (cfg->level != hr_l_empty)
    257                 log_msg(LOG_DEFAULT, LVL_WARN,
    258                     "level manually set when assembling, ingoring");
    259 
    260         new_volume->level = hr_l_empty;
    261 
    262         rc = hr_init_devs(new_volume);
    263         if (rc != EOK) {
    264                 free(cfg);
    265                 async_answer_0(icall, rc);
    266                 return;
    267         }
    268 
    269         /* just bsize needed for reading metadata later */
    270         rc = hr_check_devs(new_volume, NULL, &new_volume->bsize);
    271         if (rc != EOK)
    272                 goto error;
    273 
    274         rc = hr_get_vol_from_meta(cfg, new_volume);
    275         if (rc != EOK)
    276                 goto error;
    277 
    278         switch (new_volume->level) {
    279         case hr_l_1:
    280                 new_volume->hr_ops.create = hr_raid1_create;
    281                 break;
    282         case hr_l_0:
    283                 new_volume->hr_ops.create = hr_raid0_create;
    284                 break;
    285         case hr_l_4:
    286                 new_volume->hr_ops.create = hr_raid4_create;
    287                 break;
    288         case hr_l_5:
    289                 new_volume->hr_ops.create = hr_raid5_create;
    290                 break;
    291         default:
    292                 log_msg(LOG_DEFAULT, LVL_ERROR,
    293                     "level %d not implemented yet", new_volume->level);
    294                 rc = EINVAL;
    295                 goto error;
    296         }
    297 
    298         rc = new_volume->hr_ops.create(new_volume);
    299         if (rc != EOK)
    300                 goto error;
    301 
    302         fibril_mutex_lock(&hr_volumes_lock);
    303         list_append(&new_volume->lvolumes, &hr_volumes);
    304         fibril_mutex_unlock(&hr_volumes_lock);
    305 
    306         log_msg(LOG_DEFAULT, LVL_NOTE, "assembled volume \"%s\" (%" PRIun ")",
    307             new_volume->devname, new_volume->svc_id);
     216        if (assemble) {
     217                log_msg(LOG_DEFAULT, LVL_NOTE,
     218                    "assembled volume \"%s\" (%" PRIun ")",
     219                    new_volume->devname, new_volume->svc_id);
     220        } else {
     221                log_msg(LOG_DEFAULT, LVL_NOTE,
     222                    "created volume \"%s\" (%" PRIun ")",
     223                    new_volume->devname, new_volume->svc_id);
     224        }
    308225
    309226        free(cfg);
    … …  
    424341                switch (method) {
    425342                case HR_CREATE:
    426                         hr_create_srv(&call);
     343                        hr_create_srv(&call, false);
    427344                        break;
    428345                case HR_ASSEMBLE:
    429                         hr_assemble_srv(&call);
     346                        hr_create_srv(&call, true);
    430347                        break;
    431348                case HR_STOP:
Note: See TracChangeset for help on using the changeset viewer.