Changeset d082801 in mainline


Ignore:
Timestamp:
2025-03-29T14:04:37Z (2 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
746e636
Parents:
1a28518
Message:

hr: refactor manual assembly

Location:
uspace
Files:
6 edited

Legend:

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

    r1a28518 rd082801  
    6262    "  -F, --fail-extent         fail an extent, use with -D and set it before\n"
    6363    "  -c, --create=NAME         create new array\n"
    64     "  -a, --assemble=NAME      assemble from specified extents\n"
     64    "  -a, --assemble            try to assemble from specified extents\n"
    6565    "  -n                        non-zero number of devices\n"
    6666    "  -l, --level=LEVEL         set the RAID level,\n"
     
    7878    "    - creates new mirroring RAID device named /hr0 consisting\n"
    7979    "      of 2 drives\n"
    80     "  hrctl --assemble hr0 -n 2 devices/\\hw\\0 devices/\\hw\\1\n"
    81     "    - assembles RAID device named /hr0 consisting of 2 drives,\n"
    82     "      that were previously in an array\n"
     80    "  hrctl --assemble -n 2 devices/\\hw\\0 devices/\\hw\\1\n"
     81    "    - assembles RAID devices from specified extents,\n"
     82    "      that were previously in an (active) array\n"
    8383    "  hrctl devices/hr0 --hotspare=devices/disk10\n"
    8484    "    - adds \"devices/disk10\" as hotspare extent\n"
     
    9191        { "help", no_argument, 0, 'h' },
    9292        { "status", no_argument, 0, 's' },
    93         { "assemble", required_argument, 0, 'a' },
     93        { "assemble", no_argument, 0, 'a' },
    9494        { "create", required_argument, 0, 'c' },
    9595        { "level", required_argument, 0, 'l' },
     
    253253
    254254        while (c != -1) {
    255                 c = getopt_long(argc, argv, "hsC:c:Aa:l:0145Ln:D:F:H:",
     255                c = getopt_long(argc, argv, "hsC:c:Aal:0145Ln:D:F:H:",
    256256                    long_options, NULL);
    257257                switch (c) {
     
    294294                        return rc;
    295295                case 'a':
    296                         if (str_size(optarg) > sizeof(cfg->devname) - 1) {
    297                                 printf("hrctl: device name too long\n");
    298                                 free(cfg);
    299                                 return 1;
    300                         }
    301                         str_cpy(cfg->devname, sizeof(cfg->devname), optarg);
     296                        /*
     297                         * XXX: redo this, no devname, only svc ids...
     298                         *
     299                         * find some other way to rename the arrays...,
     300                         *
     301                         * some metadata editation tool... something like
     302                         * fdisk but can only change devnames on inactive
     303                         * extents...
     304                         */
     305
     306                        /*
     307                         * XXX: remake whole parsing, don't allow -a
     308                         * to have any levels set or anything
     309                         */
    302310                        assemble = true;
    303311                        break;
     
    414422
    415423        if (create) {
    416                 rc = hr_create(hr, cfg, false);
     424                rc = hr_create(hr, cfg);
    417425                printf("hrctl: hr_create() rc: %s\n", str_error(rc));
    418426        } else if (assemble) {
    419                 rc = hr_create(hr, cfg, true);
    420                 printf("hrctl: hr_assemble() rc: %s\n", str_error(rc));
     427                size_t assembled_cnt = 0;
     428                rc = hr_assemble(hr, cfg, &assembled_cnt);
     429                if (rc != EOK) {
     430                        /* XXX: here have own error codes */
     431                        printf("hrctl: auto assemble rc: %s\n", str_error(rc));
     432                } else {
     433                        printf("hrctl: auto assembled %lu volumes\n",
     434                            assembled_cnt);
     435                }
     436
    421437        }
    422438
  • uspace/lib/device/include/hr.h

    r1a28518 rd082801  
    117117extern errno_t           hr_sess_init(hr_t **);
    118118extern void              hr_sess_destroy(hr_t *);
    119 extern errno_t           hr_create(hr_t *, hr_config_t *, bool);
     119extern errno_t           hr_create(hr_t *, hr_config_t *);
     120extern errno_t           hr_assemble(hr_t *, hr_config_t *, size_t *);
    120121extern errno_t           hr_auto_assemble(size_t *);
    121122extern errno_t           hr_stop(const char *, long);
  • uspace/lib/device/src/hr.c

    r1a28518 rd082801  
    11/*
    2  * Copyright (c) 2024 Miroslav Cimerman
     2 * Copyright (c) 2025 Miroslav Cimerman
    33 * All rights reserved.
    44 *
     
    8888}
    8989
    90 errno_t hr_create(hr_t *hr, hr_config_t *hr_config, bool assemble)
     90errno_t hr_create(hr_t *hr, hr_config_t *hr_config)
    9191{
    9292        errno_t rc, retval;
     
    9898                return EINVAL;
    9999
    100         req = async_send_0(exch, assemble ? HR_ASSEMBLE : HR_CREATE, NULL);
     100        req = async_send_0(exch, HR_CREATE, NULL);
    101101
    102102        rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
     
    113113
    114114        return EOK;
     115}
     116
     117errno_t hr_assemble(hr_t *hr, hr_config_t *hr_config, size_t *rassembled_cnt)
     118{
     119        errno_t rc;
     120        async_exch_t *exch;
     121        aid_t req;
     122        size_t assembled_cnt;
     123
     124        exch = async_exchange_begin(hr->sess);
     125        if (exch == NULL)
     126                return EINVAL;
     127
     128        req = async_send_0(exch, HR_ASSEMBLE, NULL);
     129
     130        rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
     131        if (rc != EOK) {
     132                async_exchange_end(exch);
     133                async_forget(req);
     134                return rc;
     135        }
     136
     137        rc = async_data_read_start(exch, &assembled_cnt, sizeof(size_t));
     138        if (rc != EOK) {
     139                async_exchange_end(exch);
     140                async_forget(req);
     141                return rc;
     142        }
     143
     144        async_exchange_end(exch);
     145        async_wait_for(req, &rc);
     146
     147        if (rassembled_cnt != NULL)
     148                *rassembled_cnt = assembled_cnt;
     149
     150        return rc;
    115151}
    116152
  • uspace/srv/bd/hr/hr.c

    r1a28518 rd082801  
    7979
    8080        if (size != sizeof(size_t)) {
     81                async_answer_0(&call, EINVAL);
    8182                async_answer_0(icall, EINVAL);
    8283                return;
    8384        }
    8485
    85         rc = hr_util_try_auto_assemble(&assembled_cnt);
    86         if (rc != EOK) {
    87                 async_answer_0(&call, rc);
    88                 async_answer_0(icall, rc);
    89                 return;
    90         }
     86        rc = hr_util_try_assemble(NULL, &assembled_cnt);
     87        if (rc != EOK)
     88                goto error;
    9189
    9290        rc = async_data_read_finalize(&call, &assembled_cnt, size);
    93         if (rc != EOK) {
    94                 async_answer_0(&call, rc);
    95                 async_answer_0(icall, rc);
    96                 return;
    97         }
     91        if (rc != EOK)
     92                goto error;
    9893
    9994        async_answer_0(icall, EOK);
    100 }
    101 
    102 static void hr_create_srv(ipc_call_t *icall, bool assemble)
     95        return;
     96error:
     97        async_answer_0(&call, rc);
     98        async_answer_0(icall, rc);
     99}
     100
     101static void hr_assemble_srv(ipc_call_t *icall)
     102{
     103        HR_DEBUG("%s()", __func__);
     104
     105        errno_t rc;
     106        size_t size, assembled_cnt;
     107        hr_config_t *cfg;
     108        ipc_call_t call;
     109
     110        if (!async_data_write_receive(&call, &size)) {
     111                async_answer_0(&call, EREFUSED);
     112                async_answer_0(icall, EREFUSED);
     113                return;
     114        }
     115
     116        if (size != sizeof(hr_config_t)) {
     117                async_answer_0(&call, EINVAL);
     118                async_answer_0(icall, EINVAL);
     119                return;
     120        }
     121
     122        cfg = calloc(1, sizeof(hr_config_t));
     123        if (cfg == NULL) {
     124                async_answer_0(&call, ENOMEM);
     125                async_answer_0(icall, ENOMEM);
     126                return;
     127        }
     128
     129        rc = async_data_write_finalize(&call, cfg, size);
     130        if (rc != EOK)
     131                goto error;
     132
     133        if (!async_data_read_receive(&call, &size)) {
     134                async_answer_0(icall, EREFUSED);
     135                return;
     136        }
     137
     138        if (size != sizeof(size_t)) {
     139                async_answer_0(icall, EINVAL);
     140                return;
     141        }
     142
     143        rc = hr_util_try_assemble(cfg, &assembled_cnt);
     144        if (rc != EOK)
     145                goto error;
     146
     147        rc = async_data_read_finalize(&call, &assembled_cnt, size);
     148        if (rc != EOK)
     149                goto error;
     150
     151        free(cfg);
     152        async_answer_0(icall, EOK);
     153        return;
     154error:
     155        free(cfg);
     156        async_answer_0(&call, rc);
     157        async_answer_0(icall, rc);
     158}
     159
     160static void hr_create_srv(ipc_call_t *icall)
    103161{
    104162        HR_DEBUG("%s()", __func__);
     
    141199         * for creation of a new array, abort
    142200         */
    143         if (!assemble) {
    144                 for (i = 0; i < cfg->dev_no; i++) {
    145                         if (cfg->devs[i] == 0) {
    146                                 /*
    147                                  * XXX: own error codes, no need to log this...
    148                                  * its user error not service error
    149                                  */
    150                                 HR_ERROR("missing device provided for array "
    151                                     "creation, aborting");
    152                                 free(cfg);
    153                                 async_answer_0(icall, EINVAL);
    154                                 return;
    155                         }
     201        for (i = 0; i < cfg->dev_no; i++) {
     202                if (cfg->devs[i] == 0) {
     203                        /*
     204                         * XXX: own error codes, no need to log this...
     205                         * its user error not service error
     206                         */
     207                        HR_ERROR("missing device provided for array "
     208                            "creation, aborting");
     209                        free(cfg);
     210                        async_answer_0(icall, EINVAL);
     211                        return;
    156212                }
    157213        }
     
    170226        new_volume->extent_no = cfg->dev_no;
    171227
     228        /* XXX: do proper initing ... */
    172229        rc = hr_init_devs(new_volume);
    173230        if (rc != EOK) {
     
    178235        }
    179236
    180         if (assemble) {
    181                 if (cfg->level != HR_LVL_UNKNOWN)
    182                         HR_DEBUG("level manually set when assembling, ingoring");
    183                 new_volume->level = HR_LVL_UNKNOWN;
    184         }
    185 
    186         if (assemble) {
    187                 /* just bsize needed for reading metadata later */
    188                 rc = hr_check_devs(new_volume, NULL, &new_volume->bsize);
    189                 if (rc != EOK)
    190                         goto error;
    191 
    192                 rc = hr_fill_vol_from_meta(new_volume);
    193                 if (rc != EOK)
    194                         goto error;
    195         }
    196 
    197         if (!assemble) {
    198                 new_volume->hr_ops.init(new_volume);
    199                 if (rc != EOK)
    200                         goto error;
    201 
    202                 rc = hr_write_meta_to_vol(new_volume);
    203                 if (rc != EOK)
    204                         goto error;
    205         }
     237        new_volume->hr_ops.init(new_volume);
     238        if (rc != EOK)
     239                goto error;
     240
     241        rc = hr_write_meta_to_vol(new_volume);
     242        if (rc != EOK)
     243                goto error;
    206244
    207245        rc = new_volume->hr_ops.create(new_volume);
     
    217255        fibril_rwlock_write_unlock(&hr_volumes_lock);
    218256
    219         if (assemble) {
    220                 HR_DEBUG("assembled volume \"%s\" (%" PRIun ")\n",
    221                     new_volume->devname, new_volume->svc_id);
    222         } else {
    223                 HR_DEBUG("created volume \"%s\" (%" PRIun ")\n",
    224                     new_volume->devname, new_volume->svc_id);
    225         }
     257        HR_DEBUG("created volume \"%s\" (%" PRIun ")\n", new_volume->devname,
     258            new_volume->svc_id);
    226259
    227260        free(cfg);
     
    390423                switch (method) {
    391424                case HR_CREATE:
    392                         hr_create_srv(&call, false);
     425                        hr_create_srv(&call);
    393426                        break;
    394427                case HR_ASSEMBLE:
    395                         hr_create_srv(&call, true);
     428                        hr_assemble_srv(&call);
    396429                        break;
    397430                case HR_AUTO_ASSEMBLE:
  • uspace/srv/bd/hr/util.c

    r1a28518 rd082801  
    875875}
    876876
    877 errno_t hr_util_try_auto_assemble(size_t *rassembled_cnt)
     877static errno_t hr_fill_svcs_list_from_cfg(hr_config_t *cfg, list_t *list)
     878{
     879        errno_t rc = EOK;
     880        for (size_t i = 0; i < cfg->dev_no; ++i) {
     881                rc = hr_add_svc_linked_to_list(list, cfg->devs[i], false, NULL);
     882                if (rc != EOK)
     883                        goto error;
     884        }
     885
     886        return EOK;
     887error:
     888        free_svc_id_list(list);
     889        return rc;
     890}
     891
     892errno_t hr_util_try_assemble(hr_config_t *cfg, size_t *rassembled_cnt)
    878893{
    879894        HR_DEBUG("%s()", __func__);
     
    897912
    898913        list_initialize(&dev_id_list);
    899         rc = hr_fill_disk_part_svcs_list(&dev_id_list);
     914
     915        if (cfg == NULL)
     916                rc = hr_fill_disk_part_svcs_list(&dev_id_list);
     917        else
     918                rc = hr_fill_svcs_list_from_cfg(cfg, &dev_id_list);
     919
    900920        if (rc != EOK)
    901921                goto error;
  • uspace/srv/bd/hr/util.h

    r1a28518 rd082801  
    3838
    3939#include <errno.h>
     40#include <hr.h>
    4041#include <io/log.h>
    4142
     
    7778extern hr_range_lock_t  *hr_range_lock_acquire(hr_volume_t *, uint64_t,
    7879    uint64_t);
    79 extern errno_t           hr_util_try_auto_assemble(size_t *);
     80extern errno_t           hr_util_try_assemble(hr_config_t *, size_t *);
    8081extern errno_t           hr_util_add_hotspare(hr_volume_t *, service_id_t);
    8182
Note: See TracChangeset for help on using the changeset viewer.