Changeset b0f1366 in mainline


Ignore:
Timestamp:
2024-09-06T11:37:54Z (8 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
9c1cf34c
Parents:
ee83e9c
Message:

hr: write persistent metadata, assemble array from metadata

Location:
uspace
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hrctl/hrctl.c

    ree83e9c rb0f1366  
    5353    "\n"
    5454    "Options:\n"
    55     "  -h, --help              display this help and exit\n"
    56     "  -C, --config-file=path  create an array from file,\n"
    57     "                          sample file at: " HRCTL_SAMPLE_CONFIG_PATH "\n"
    58     "  -s, --status            display status of active arrays\n"
    59     "  -a, --assemble=NAME     assemble an existing array\n"
    60     "  -c, --create=NAME       create new array\n"
    61     "  -n                      non-zero number of devices\n"
    62     "  -l, --level=LEVEL       set the RAID level,\n"
    63     "                          valid values: 0, 1, 5, linear\n"
    64     "  -0                      striping\n"
    65     "  -1                      mirroring\n"
    66     "  -5                      distributed parity\n"
    67     "  -L                      linear concatenation\n"
     55    "  -h, --help                display this help and exit\n"
     56    "  -C, --create-file=path    create an array from file,\n"
     57    "                            sample file at: " HRCTL_SAMPLE_CONFIG_PATH "\n"
     58    "  -A, --assemble-file=path  create an array from file\n"
     59    "  -s, --status              display status of active arrays\n"
     60    "  -c, --create=NAME         create new array\n"
     61    "  -a, --assemble=NAME       assemble an existing array\n"
     62    "  -n                        non-zero number of devices\n"
     63    "  -l, --level=LEVEL         set the RAID level,\n"
     64    "                            valid values: 0, 1, 5, linear\n"
     65    "  -0                        striping\n"
     66    "  -1                        mirroring\n"
     67    "  -5                        distributed parity\n"
     68    "  -L                        linear concatenation\n"
    6869    "\n"
    6970    "Example usage:\n"
    … …  
    8384        { "create", required_argument, 0, 'c' },
    8485        { "level", required_argument, 0, 'l' },
    85         { "config-file", required_argument, 0, 'C' },
     86        { "create-file", required_argument, 0, 'C' },
     87        { "assemble-file", required_argument, 0, 'A' },
    8688        { 0, 0, 0, 0 }
    8789};
    … …  
    154156
    155157        level_str = sif_node_get_attr(narray, "level");
    156         if (level_str == NULL) {
    157                 rc = EIO;
    158                 goto error;
    159         }
    160         cfg->level = strtol(level_str, NULL, 10);
     158        if (level_str == NULL)
     159                cfg->level = hr_l_empty;
     160        else if (str_cmp(level_str, "linear") == 0)
     161                cfg->level = hr_l_linear;
     162        else
     163                cfg->level = strtol(level_str, NULL, 10);
    161164
    162165        dev_no_str = sif_node_get_attr(narray, "n");
    … …  
    228231
    229232        while (c != -1) {
    230                 c = getopt_long(argc, argv, "hsC:c:a:l:015Ln:",
     233                c = getopt_long(argc, argv, "hsC:c:A:a:l:015Ln:",
    231234                    long_options, NULL);
    232235                switch (c) {
    … …  
    239242                                return 1;
    240243                        return 0;
    241                 case 'a':
    242                         if (str_size(optarg) > sizeof(cfg->devname) - 1) {
    243                                 printf("hrctl: device name too long\n");
    244                                 return 1;
    245                         }
    246                         str_cpy(cfg->devname, sizeof(cfg->devname), optarg);
    247                         assemble = true;
    248                         break;
    249244                case 'C':
    250245                        /* only support 1 array inside config for now XXX */
    … …  
    264259                        create = true;
    265260                        break;
     261                case 'A':
     262                        rc = load_config(optarg, cfg);
     263                        if (rc != EOK) {
     264                                printf("hrctl: failed to load config\n");
     265                                return 1;
     266                        }
     267                        assemble = true;
     268                        goto skip;
     269                case 'a':
     270                        if (str_size(optarg) > sizeof(cfg->devname) - 1) {
     271                                printf("hrctl: device name too long\n");
     272                                return 1;
     273                        }
     274                        str_cpy(cfg->devname, sizeof(cfg->devname), optarg);
     275                        assemble = true;
     276                        break;
    266277                case 'l':
    267278                        if (cfg->level != hr_l_empty)
    … …  
    296307                        if ((int) cfg->dev_no + optind != argc)
    297308                                goto bad;
    298                         if (cfg->dev_no > HR_MAXDEVS) {
    299                                 printf("hrctl: too many devices\n");
    300                                 return 1;
    301                         }
    302309                        rc = fill_config_devs(argc, argv, optind, cfg);
    303310                        if (rc != EOK)
    … …  
    308315
    309316skip:
    310         if ((create && assemble) ||
    311             (!create && !assemble) ||
    312             (create && cfg->level == hr_l_empty) ||
    313             (assemble && cfg->level != hr_l_empty) ||
    314             (cfg->dev_no == 0)) {
     317        if ((create && assemble) || (!create && !assemble))
    315318                goto bad;
     319
     320        if (create && cfg->level == hr_l_empty) {
     321                printf("hrctl: invalid level, exiting\n");
     322                return 1;
     323        }
     324
     325        if (cfg->dev_no > HR_MAXDEVS) {
     326                printf("hrctl: too many devices, exiting\n");
     327                return 1;
     328        }
     329
     330        if (cfg->dev_no == 0) {
     331                printf("hrctl: invalid number of devices, exiting\n");
     332                return 1;
    316333        }
    317334
    … …  
    327344                printf("hrctl: hr_create() rc: %s\n", str_error(rc));
    328345        } else if (assemble) {
    329                 printf("hrctl: assemble not implemented yet\n");
     346                rc = hr_assemble(hr, cfg);
     347                printf("hrctl: hr_assemble() rc: %s\n", str_error(rc));
    330348        }
    331349

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

    ree83e9c rb0f1366  
    7676
    7777extern errno_t hr_create(hr_t *, hr_config_t *);
     78extern errno_t hr_assemble(hr_t *, hr_config_t *);
    7879extern errno_t hr_print_status(void);
    7980

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

    ree83e9c rb0f1366  
    4040typedef enum {
    4141        HR_CREATE = IPC_FIRST_USER_METHOD,
     42        HR_ASSEMBLE,
    4243        HR_STATUS
    4344} hr_request_t;

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

    ree83e9c rb0f1366  
    114114}
    115115
     116errno_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);
     127
     128        rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
     129        if (rc != EOK) {
     130                async_exchange_end(exch);
     131                async_forget(req);
     132                return rc;
     133        }
     134
     135        async_exchange_end(exch);
     136        async_wait_for(req, &retval);
     137        if (retval != EOK)
     138                return retval;
     139
     140        return EOK;
     141}
     142
    116143static errno_t print_vol_info(size_t index, hr_vol_info_t *vol_info)
    117144{

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

    ree83e9c rb0f1366  
    4949#include <str_error.h>
    5050
     51#include "superblock.h"
     52#include "util.h"
    5153#include "var.h"
    5254
    … …  
    5860
    5961static service_id_t ctl_sid;
     62
    6063
    6164static void hr_create_srv(ipc_call_t *icall)
    … …  
    9295                async_answer_0(&call, rc);
    9396                async_answer_0(icall, rc);
     97                return;
    9498        }
    9599
    96100        new_volume = calloc(1, sizeof(hr_volume_t));
    97101        if (new_volume == NULL) {
    98                 rc = ENOMEM;
    99                 goto end;
     102                free(cfg);
     103                async_answer_0(icall, ENOMEM);
     104                return;
    100105        }
    101106
    … …  
    104109        new_volume->level = cfg->level;
    105110        new_volume->dev_no = cfg->dev_no;
     111
     112        rc = hr_init_devs(new_volume);
     113        if (rc != EOK) {
     114                free(cfg);
     115                async_answer_0(icall, rc);
     116                return;
     117        }
     118
     119        rc = hr_check_devs(new_volume);
     120        if (rc != EOK)
     121                goto error;
     122
     123        rc = hr_write_meta_to_vol(new_volume);
     124        if (rc != EOK)
     125                goto error;
    106126
    107127        switch (new_volume->level) {
    … …  
    113133                break;
    114134        default:
    115                 log_msg(LOG_DEFAULT, LVL_NOTE,
    116                     "level %d not implemented yet\n", new_volume->level);
     135                log_msg(LOG_DEFAULT, LVL_ERROR,
     136                    "level %d not implemented yet", new_volume->level);
    117137                rc = EINVAL;
    118                 goto end;
     138                goto error;
    119139        }
    120140
    121141        rc = new_volume->hr_ops.create(new_volume);
    122         if (rc != EOK) {
    123                 goto end;
    124         }
     142        if (rc != EOK)
     143                goto error;
    125144
    126145        fibril_mutex_lock(&hr_volumes_lock);
    … …  
    128147        fibril_mutex_unlock(&hr_volumes_lock);
    129148
    130         log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")\n",
     149        log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")",
    131150            new_volume->devname, new_volume->svc_id);
    132151
    133 end:
    134152        free(cfg);
     153        async_answer_0(icall, rc);
     154        return;
     155error:
     156        free(cfg);
     157        hr_fini_devs(new_volume);
     158        async_answer_0(icall, rc);
     159}
     160
     161static void hr_assemble_srv(ipc_call_t *icall)
     162{
     163        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_assemble_srv()");
     164
     165        errno_t rc;
     166        size_t size;
     167        hr_config_t *cfg;
     168        hr_volume_t *new_volume;
     169        ipc_call_t call;
     170
     171        if (!async_data_write_receive(&call, &size)) {
     172                async_answer_0(&call, EREFUSED);
     173                async_answer_0(icall, EREFUSED);
     174                return;
     175        }
     176
     177        if (size != sizeof(hr_config_t)) {
     178                async_answer_0(&call, EINVAL);
     179                async_answer_0(icall, EINVAL);
     180                return;
     181        }
     182
     183        cfg = calloc(1, sizeof(hr_config_t));
     184        if (cfg == NULL) {
     185                async_answer_0(&call, ENOMEM);
     186                async_answer_0(icall, ENOMEM);
     187                return;
     188        }
     189
     190        rc = async_data_write_finalize(&call, cfg, size);
     191        if (rc != EOK) {
     192                async_answer_0(&call, rc);
     193                async_answer_0(icall, rc);
     194                return;
     195        }
     196
     197        new_volume = calloc(1, sizeof(hr_volume_t));
     198        if (new_volume == NULL) {
     199                free(cfg);
     200                async_answer_0(icall, ENOMEM);
     201                return;
     202        }
     203
     204        str_cpy(new_volume->devname, 32, cfg->devname);
     205        memcpy(new_volume->devs, cfg->devs, sizeof(service_id_t) * HR_MAXDEVS);
     206        new_volume->dev_no = cfg->dev_no;
     207
     208        if (cfg->level != hr_l_empty)
     209                log_msg(LOG_DEFAULT, LVL_WARN,
     210                    "level manually set when assembling, ingoring");
     211
     212        new_volume->level = hr_l_empty;
     213
     214        rc = hr_init_devs(new_volume);
     215        if (rc != EOK) {
     216                free(cfg);
     217                async_answer_0(icall, rc);
     218                return;
     219        }
     220
     221        rc = hr_check_devs(new_volume);
     222        if (rc != EOK)
     223                goto error;
     224
     225        rc = hr_get_vol_from_meta(cfg, new_volume);
     226        if (rc != EOK)
     227                goto error;
     228
     229        switch (new_volume->level) {
     230        case hr_l_1:
     231                new_volume->hr_ops.create = hr_raid1_create;
     232                break;
     233        case hr_l_0:
     234                new_volume->hr_ops.create = hr_raid0_create;
     235                break;
     236        default:
     237                log_msg(LOG_DEFAULT, LVL_ERROR,
     238                    "level %d not implemented yet", new_volume->level);
     239                rc = EINVAL;
     240                goto error;
     241        }
     242
     243        rc = new_volume->hr_ops.create(new_volume);
     244        if (rc != EOK)
     245                goto error;
     246
     247        fibril_mutex_lock(&hr_volumes_lock);
     248        list_append(&new_volume->lvolumes, &hr_volumes);
     249        fibril_mutex_unlock(&hr_volumes_lock);
     250
     251        log_msg(LOG_DEFAULT, LVL_NOTE, "assembled volume \"%s\" (%" PRIun ")",
     252            new_volume->devname, new_volume->svc_id);
     253
     254        free(cfg);
     255        async_answer_0(icall, rc);
     256        return;
     257error:
     258        free(cfg);
     259        hr_fini_devs(new_volume);
    135260        async_answer_0(icall, rc);
    136261}
    … …  
    170295                info.extent_no = volume->dev_no;
    171296                info.level = volume->level;
    172                 info.nblocks = volume->nblocks;
     297                /* print usable number of blocks */
     298                info.nblocks = volume->data_blkno;
    173299                info.bsize = volume->bsize;
    174300
    … …  
    219345                case HR_STATUS:
    220346                        hr_print_status_srv(&call);
     347                        break;
     348                case HR_ASSEMBLE:
     349                        hr_assemble_srv(&call);
    221350                        break;
    222351                default:

  • uspace/srv/bd/hr/meson.build

    ree83e9c rb0f1366  
    2828
    2929deps = [ 'block', 'device' ]
    30 src = files('hr.c', 'raid0.c', 'raid1.c', 'util.c')
     30src = files('hr.c', 'raid0.c', 'raid1.c', 'superblock.c', 'util.c')

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

    ree83e9c rb0f1366  
    4848#include <str_error.h>
    4949
     50#include "util.h"
    5051#include "var.h"
    51 #include "util.h"
    5252
    5353extern fibril_mutex_t big_lock;
    … …  
    6464static errno_t hr_raid0_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    6565
    66 #define strip_size DATA_XFER_LIMIT
    67 
    6866static bd_ops_t hr_raid0_bd_ops = {
    6967        .open = hr_raid0_bd_open,
    … …  
    8078{
    8179        uint64_t N = vol->dev_no; /* extents */
    82         uint64_t L = strip_size / vol->bsize; /* size of strip in blocks */
     80        uint64_t L = HR_STRIP_SIZE / vol->bsize; /* size of strip in blocks */
    8381
    8482        uint64_t i = (x / L) % N; /* extent */
    … …  
    114112        while (left != 0) {
    115113                raid0_geometry(ba++, vol, &extent, &phys_block);
     114                rc = hr_calc_ba(vol, cnt, &ba);
     115                if (rc != EOK)
     116                        break;
    116117                rc = block_sync_cache(vol->devs[extent], phys_block, 1);
    117118                if (rc != EOK)
    … …  
    140141        while (left != 0) {
    141142                raid0_geometry(ba++, vol, &extent, &phys_block);
     143                rc = hr_calc_ba(vol, cnt, &ba);
     144                if (rc != EOK)
     145                        break;
    142146                rc = block_read_direct(vol->devs[extent], phys_block, 1, buf);
    143147                buf = buf + vol->bsize;
    … …  
    167171        while (left != 0) {
    168172                raid0_geometry(ba++, vol, &extent, &phys_block);
     173                rc = hr_calc_ba(vol, cnt, &phys_block);
     174                if (rc != EOK)
     175                        break;
    169176                rc = block_write_direct(vol->devs[extent], phys_block, 1, data);
    170177                data = data + vol->bsize;
    … …  
    190197        hr_volume_t *vol = bd->srvs->sarg;
    191198
    192         *rnb = vol->nblocks;
     199        *rnb = vol->data_blkno;
    193200        return EOK;
    194201}
    … …  
    196203errno_t hr_raid0_create(hr_volume_t *new_volume)
    197204{
     205        errno_t rc;
     206
    198207        assert(new_volume->level == hr_l_0);
    199208
    … …  
    204213        }
    205214
    206         errno_t rc;
    207         size_t i, bsize, last_bsize;
    208         uint64_t nblocks, last_nblocks;
    209         uint64_t total_blocks = 0;
    210 
    211         rc = hr_init_devs(new_volume);
    212         if (rc != EOK)
    213                 return rc;
    214 
    215         for (i = 0; i < new_volume->dev_no; i++) {
    216                 rc = block_get_nblocks(new_volume->devs[i], &nblocks);
    217                 if (rc != EOK)
    218                         goto error;
    219                 if (i != 0 && nblocks != last_nblocks) {
    220                         log_msg(LOG_DEFAULT, LVL_ERROR,
    221                             "number of blocks differs");
    222                         rc = EINVAL;
    223                         goto error;
    224                 }
    225                 total_blocks += nblocks;
    226                 last_nblocks = nblocks;
    227         }
    228 
    229         for (i = 0; i < new_volume->dev_no; i++) {
    230                 rc = block_get_bsize(new_volume->devs[i], &bsize);
    231                 if (rc != EOK)
    232                         goto error;
    233                 if (i != 0 && bsize != last_bsize) {
    234                         log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
    235                         rc = EINVAL;
    236                         goto error;
    237                 }
    238                 last_bsize = bsize;
    239         }
    240 
    241215        bd_srvs_init(&new_volume->hr_bds);
    242216        new_volume->hr_bds.ops = &hr_raid0_bd_ops;
    243217        new_volume->hr_bds.sarg = new_volume;
    244         new_volume->nblocks = total_blocks;
    245         new_volume->bsize = bsize;
    246218
    247219        rc = hr_register_volume(new_volume);
    248220        if (rc != EOK)
    249                 goto error;
    250 
    251         return EOK;
    252 error:
    253         hr_fini_devs(new_volume);
    254         return rc;
     221                return rc;
     222
     223        return EOK;
    255224}
    256225

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

    ree83e9c rb0f1366  
    4747#include <str_error.h>
    4848
     49#include "util.h"
    4950#include "var.h"
    50 #include "util.h"
    5151
    5252extern fibril_mutex_t big_lock;
    … …  
    8585}
    8686
    87 static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t size)
     87static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    8888{
    8989        fibril_mutex_lock(&big_lock);
    … …  
    9393        size_t i;
    9494
     95        rc = hr_calc_ba(vol, cnt, &ba);
     96        if (rc != EOK) {
     97                fibril_mutex_unlock(&big_lock);
     98                return rc;
     99        }
     100
    95101        for (i = 0; i < vol->dev_no; i++) {
    96                 rc = block_sync_cache(vol->devs[i], ba, size);
     102                rc = block_sync_cache(vol->devs[i], ba, cnt);
    97103                if (rc != EOK)
    98104                        break;
    … …  
    111117        errno_t rc;
    112118        size_t i;
     119
     120        rc = hr_calc_ba(vol, cnt, &ba);
     121        if (rc != EOK) {
     122                fibril_mutex_unlock(&big_lock);
     123                return rc;
     124        }
    113125
    114126        for (i = 0; i < vol->dev_no; i++) {
    … …  
    131143        size_t i;
    132144
     145        rc = hr_calc_ba(vol, cnt, &ba);
     146        if (rc != EOK) {
     147                fibril_mutex_unlock(&big_lock);
     148                return rc;
     149        }
     150
    133151        for (i = 0; i < vol->dev_no; i++) {
    134152                rc = block_write_direct(vol->devs[i], ba, cnt, data);
    … …  
    153171        hr_volume_t *vol = bd->srvs->sarg;
    154172
    155         *rnb = vol->nblocks;
     173        *rnb = vol->data_blkno;
    156174        return EOK;
    157175}
    … …  
    159177errno_t hr_raid1_create(hr_volume_t *new_volume)
    160178{
     179        errno_t rc;
     180
    161181        assert(new_volume->level == hr_l_1);
    162182
    … …  
    167187        }
    168188
    169         errno_t rc;
    170         size_t i, bsize, last_bsize;
    171         uint64_t nblocks, last_nblocks;
    172         uint64_t total_blocks = 0;
    173 
    174         rc = hr_init_devs(new_volume);
    175         if (rc != EOK)
    176                 return rc;
    177 
    178         for (i = 0; i < new_volume->dev_no; i++) {
    179                 rc = block_get_nblocks(new_volume->devs[i], &nblocks);
    180                 if (rc != EOK)
    181                         goto error;
    182                 if (i != 0 && nblocks != last_nblocks) {
    183                         log_msg(LOG_DEFAULT, LVL_ERROR,
    184                             "number of blocks differs");
    185                         rc = EINVAL;
    186                         goto error;
    187                 }
    188                 total_blocks += nblocks;
    189                 last_nblocks = nblocks;
    190         }
    191 
    192         for (i = 0; i < new_volume->dev_no; i++) {
    193                 rc = block_get_bsize(new_volume->devs[i], &bsize);
    194                 if (rc != EOK)
    195                         goto error;
    196                 if (i != 0 && bsize != last_bsize) {
    197                         log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
    198                         rc = EINVAL;
    199                         goto error;
    200                 }
    201                 last_bsize = bsize;
    202         }
    203 
    204189        bd_srvs_init(&new_volume->hr_bds);
    205190        new_volume->hr_bds.ops = &hr_raid1_bd_ops;
    206191        new_volume->hr_bds.sarg = new_volume;
    207         new_volume->nblocks = total_blocks / new_volume->dev_no;
    208         new_volume->bsize = bsize;
    209192
    210193        rc = hr_register_volume(new_volume);
    211194        if (rc != EOK)
    212                 goto error;
    213 
    214         return EOK;
    215 error:
    216         hr_fini_devs(new_volume);
    217         return rc;
     195                return rc;
     196
     197        return EOK;
    218198}
    219199

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

    ree83e9c rb0f1366  
    4343#include <str_error.h>
    4444
     45#include "util.h"
    4546#include "var.h"
    46 #include "util.h"
    4747
    4848extern loc_srv_t *hr_srv;
    … …  
    8282errno_t hr_register_volume(hr_volume_t *new_volume)
    8383{
     84        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_register_volume()");
     85
    8486        errno_t rc;
    8587        service_id_t new_id;
    … …  
    120122}
    121123
     124errno_t hr_check_devs(hr_volume_t *vol)
     125{
     126        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_check_devs()");
     127
     128        errno_t rc;
     129        size_t i, bsize, last_bsize;
     130        uint64_t nblocks, last_nblocks;
     131        uint64_t total_blocks = 0;
     132
     133        for (i = 0; i < vol->dev_no; i++) {
     134                rc = block_get_nblocks(vol->devs[i], &nblocks);
     135                if (rc != EOK)
     136                        goto error;
     137                if (i != 0 && nblocks != last_nblocks) {
     138                        log_msg(LOG_DEFAULT, LVL_ERROR,
     139                            "number of blocks differs");
     140                        rc = EINVAL;
     141                        goto error;
     142                }
     143                total_blocks += nblocks;
     144                last_nblocks = nblocks;
     145        }
     146
     147        for (i = 0; i < vol->dev_no; i++) {
     148                rc = block_get_bsize(vol->devs[i], &bsize);
     149                if (rc != EOK)
     150                        goto error;
     151                if (i != 0 && bsize != last_bsize) {
     152                        log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
     153                        rc = EINVAL;
     154                        goto error;
     155                }
     156                last_bsize = bsize;
     157        }
     158
     159        if (vol->level == hr_l_1) {
     160                vol->nblocks = total_blocks / vol->dev_no;
     161        } else if (vol->level == hr_l_0) {
     162                vol->nblocks = total_blocks;
     163        } else {
     164                log_msg(LOG_DEFAULT, LVL_DEBUG, "unkown level, ok when assembling");
     165                vol->nblocks = 0;
     166        }
     167
     168        vol->bsize = bsize;
     169
     170error:
     171        return rc;
     172}
     173
     174errno_t hr_calc_ba(hr_volume_t *vol, size_t cnt, uint64_t *ba)
     175{
     176        if (*ba + cnt > vol->data_blkno)
     177                return ERANGE;
     178
     179        *ba = *ba + vol->data_offset;
     180        return EOK;
     181}
     182
    122183/** @}
    123184 */

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

    ree83e9c rb0f1366  
    4444extern void hr_fini_devs(hr_volume_t *);
    4545extern errno_t hr_register_volume(hr_volume_t *);
     46extern errno_t hr_check_devs(hr_volume_t *vol);
     47errno_t hr_calc_ba(hr_volume_t *vol, size_t cnt, uint64_t *ba);
    4648
    4749#endif

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

    ree83e9c rb0f1366  
    4343#define NAME "hr"
    4444
     45#define HR_STRIP_SIZE DATA_XFER_LIMIT
     46
    4547typedef struct hr_volume hr_volume_t;
    4648
    … …  
    5658        service_id_t devs[HR_MAXDEVS];
    5759        uint64_t nblocks;
     60        uint64_t data_blkno;
     61        uint32_t data_offset;
     62        service_id_t svc_id;
    5863        size_t bsize;
    59         service_id_t svc_id;
    6064        size_t dev_no;
    6165        hr_level_t level;
Note: See TracChangeset for help on using the changeset viewer.