Changeset 6b8e89b0 in mainline


Ignore:
Timestamp:
2024-10-05T13:11:11Z (8 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
dceb6e7
Parents:
dbd91da
git-author:
Miroslav Cimerman <mc@…> (2024-10-05 12:39:13)
git-committer:
Miroslav Cimerman <mc@…> (2024-10-05 13:11:11)
Message:

hr: init fuction for each RAID level

Compute total blocks, data blocks and set block size, data offset, strip
size there.

Location:
uspace/srv/bd/hr
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    rdbd91da r6b8e89b0  
    154154        }
    155155
    156         rc = hr_check_devs(new_volume);
    157         if (rc != EOK)
    158                 goto error;
    159 
    160156        switch (new_volume->level) {
    161157        case hr_l_1:
    162158                new_volume->hr_ops.create = hr_raid1_create;
    163                 new_volume->strip_size = 0;
     159                new_volume->hr_ops.init = hr_raid1_init;
    164160                break;
    165161        case hr_l_0:
    166162                new_volume->hr_ops.create = hr_raid0_create;
    167                 new_volume->strip_size = HR_STRIP_SIZE;
     163                new_volume->hr_ops.init = hr_raid0_init;
    168164                break;
    169165        case hr_l_4:
    170166                new_volume->hr_ops.create = hr_raid4_create;
    171                 new_volume->strip_size = HR_STRIP_SIZE;
     167                new_volume->hr_ops.init = hr_raid4_init;
    172168                break;
    173169        default:
    … …  
    177173                goto error;
    178174        }
     175
     176        new_volume->hr_ops.init(new_volume);
     177        if (rc != EOK)
     178                goto error;
    179179
    180180        rc = hr_write_meta_to_vol(new_volume);
    … …  
    263263        }
    264264
    265         rc = hr_check_devs(new_volume);
     265        /* just bsize needed for reading metadata later */
     266        rc = hr_check_devs(new_volume, NULL, &new_volume->bsize);
    266267        if (rc != EOK)
    267268                goto error;

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

    rdbd91da r6b8e89b0  
    4848#include <str_error.h>
    4949
     50#include "superblock.h"
    5051#include "util.h"
    5152#include "var.h"
    … …  
    233234}
    234235
     236errno_t hr_raid0_init(hr_volume_t *vol)
     237{
     238        errno_t rc;
     239        size_t bsize;
     240        uint64_t total_blkno;
     241
     242        assert(vol->level == hr_l_0);
     243
     244        rc = hr_check_devs(vol, &total_blkno, &bsize);
     245        if (rc != EOK)
     246                return rc;
     247
     248        vol->nblocks = total_blkno;
     249        vol->bsize = bsize;
     250        vol->data_offset = HR_DATA_OFF;
     251        vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no);
     252        vol->strip_size = HR_STRIP_SIZE;
     253
     254        return EOK;
     255}
     256
    235257/** @}
    236258 */

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

    rdbd91da r6b8e89b0  
    4747#include <str_error.h>
    4848
     49#include "superblock.h"
    4950#include "util.h"
    5051#include "var.h"
    … …  
    201202}
    202203
     204errno_t hr_raid1_init(hr_volume_t *vol)
     205{
     206        errno_t rc;
     207        size_t bsize;
     208        uint64_t total_blkno;
     209
     210        assert(vol->level == hr_l_1);
     211
     212        rc = hr_check_devs(vol, &total_blkno, &bsize);
     213        if (rc != EOK)
     214                return rc;
     215
     216        vol->nblocks = total_blkno / vol->dev_no;
     217        vol->bsize = bsize;
     218        vol->data_offset = HR_DATA_OFF;
     219        vol->data_blkno = vol->nblocks - vol->data_offset;
     220        vol->strip_size = 0;
     221
     222        return EOK;
     223}
     224
    203225/** @}
    204226 */

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

    rdbd91da r6b8e89b0  
    4848#include <str_error.h>
    4949
     50#include "superblock.h"
    5051#include "util.h"
    5152#include "var.h"
    … …  
    281282}
    282283
     284errno_t hr_raid4_init(hr_volume_t *vol)
     285{
     286        errno_t rc;
     287        size_t bsize;
     288        uint64_t total_blkno;
     289
     290        assert(vol->level == hr_l_4);
     291
     292        rc = hr_check_devs(vol, &total_blkno, &bsize);
     293        if (rc != EOK)
     294                return rc;
     295
     296        vol->nblocks = total_blkno;
     297        vol->bsize = bsize;
     298        vol->data_offset = HR_DATA_OFF;
     299        vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no) -
     300            (vol->nblocks / vol->dev_no);
     301        vol->strip_size = HR_STRIP_SIZE;
     302
     303        return EOK;
     304}
     305
    283306/** @}
    284307 */

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

    rdbd91da r6b8e89b0  
    5757
    5858        errno_t rc;
    59         size_t i, data_offset;
    60         uint64_t data_blkno;
     59        size_t i;
     60        size_t meta_blkno; /* blocks needed to write metadata */
    6161        hr_metadata_t *metadata;
    6262        uuid_t uuid;
    … …  
    6666                return ENOMEM;
    6767
    68         if (vol->nblocks <= HR_META_OFF + HR_META_SIZE) {
     68        meta_blkno = (HR_META_OFF + HR_META_SIZE);
     69        if (vol->level != hr_l_1)
     70                meta_blkno *= vol->dev_no;
     71
     72        if (vol->nblocks < meta_blkno) {
    6973                log_msg(LOG_DEFAULT, LVL_ERROR,
    70                     "not enough blocks");
     74                    "not enough blocks to write metadata");
    7175                rc = EINVAL;
    7276                goto error;
    73         }
    74 
    75         data_offset = HR_META_OFF + HR_META_SIZE;
    76         if (vol->level == hr_l_1) {
    77                 data_blkno = vol->nblocks - data_offset;
    78         } else if (vol->level == hr_l_0) {
    79                 data_blkno = vol->nblocks - (data_offset * vol->dev_no);
    80         } else if (vol->level == hr_l_4) {
    81                 data_blkno = vol->nblocks - (data_offset * vol->dev_no) - (vol->nblocks / vol->dev_no);
    82         } else {
     77        } else if (vol->nblocks == meta_blkno) {
    8378                log_msg(LOG_DEFAULT, LVL_ERROR,
    84                     "level %d not implemented yet", vol->level);
    85                 return EINVAL;
     79                    "there would be zero data blocks after writing metadata, aborting");
     80                rc = EINVAL;
     81                goto error;
    8682        }
    8783
    … …  
    9086        metadata->level = host2uint32_t_le(vol->level);
    9187        metadata->nblocks = host2uint64_t_le(vol->nblocks);
    92         metadata->data_blkno = host2uint64_t_le(data_blkno);
    93         metadata->data_offset = host2uint32_t_le(data_offset);
     88        metadata->data_blkno = host2uint64_t_le(vol->data_blkno);
     89        metadata->data_offset = host2uint32_t_le(vol->data_offset);
    9490        metadata->strip_size = host2uint32_t_le(vol->strip_size);
    9591        for (i = 0; i < vol->dev_no; i++) {
    … …  
    10399                str_cpy(metadata->devname, 32, vol->devname);
    104100
    105                 rc = block_write_direct(vol->extents[i].svc_id, HR_META_OFF, HR_META_SIZE,
    106                     metadata);
     101                rc = block_write_direct(vol->extents[i].svc_id, HR_META_OFF,
     102                    HR_META_SIZE, metadata);
    107103                if (rc != EOK)
    108104                        goto error;
    109105        }
    110 
    111         /* fill in new members */
    112         vol->data_offset = data_offset;
    113         vol->data_blkno = data_blkno;
    114 
    115106error:
    116107        free(metadata);

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

    rdbd91da r6b8e89b0  
    4141#define HR_META_SIZE 1  /* in blocks */
    4242#define HR_META_OFF 7   /* in blocks */
     43#define HR_DATA_OFF (HR_META_SIZE + HR_META_OFF)
    4344
    4445#define HR_MAGIC 0x4420492041205248LLU

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

    rdbd91da r6b8e89b0  
    122122}
    123123
    124 errno_t hr_check_devs(hr_volume_t *vol)
     124errno_t hr_check_devs(hr_volume_t *vol, uint64_t *rblkno, size_t *rbsize)
    125125{
    126126        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_check_devs()");
    … …  
    157157        }
    158158
    159         if (vol->level == hr_l_1) {
    160                 vol->nblocks = total_blocks / vol->dev_no;
    161         } else if (vol->level == hr_l_0 || vol->level == hr_l_4) {
    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 
     159        if (rblkno != NULL)
     160                *rblkno = total_blocks;
     161        if (rbsize != NULL)
     162                *rbsize = bsize;
    170163error:
    171164        return rc;

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

    rdbd91da r6b8e89b0  
    4444extern void hr_fini_devs(hr_volume_t *);
    4545extern errno_t hr_register_volume(hr_volume_t *);
    46 extern errno_t hr_check_devs(hr_volume_t *vol);
    47 errno_t hr_check_ba_range(hr_volume_t *vol, size_t cnt, uint64_t ba);
    48 void hr_add_ba_offset(hr_volume_t *vol, uint64_t *ba);
     46errno_t hr_check_devs(hr_volume_t *, uint64_t *, size_t *);
     47errno_t hr_check_ba_range(hr_volume_t *, size_t, uint64_t);
     48void hr_add_ba_offset(hr_volume_t *, uint64_t *);
    4949
    5050#endif

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

    rdbd91da r6b8e89b0  
    4949typedef struct hr_ops {
    5050        errno_t (*create)(hr_volume_t *);
     51        errno_t (*init)(hr_volume_t *);
    5152} hr_ops_t;
    5253
    … …  
    5960        uint64_t nblocks;
    6061        uint64_t data_blkno;
    61         uint32_t data_offset;
     62        uint32_t data_offset; /* in blocks */
    6263        uint32_t strip_size;
    6364        service_id_t svc_id;
    … …  
    7475extern errno_t hr_raid4_create(hr_volume_t *);
    7576
     77extern errno_t hr_raid0_init(hr_volume_t *);
     78extern errno_t hr_raid1_init(hr_volume_t *);
     79extern errno_t hr_raid4_init(hr_volume_t *);
     80
    7681#endif
    7782
Note: See TracChangeset for help on using the changeset viewer.