Changeset 733564a in mainline


Ignore:
Timestamp:
2024-11-15T16:44:25Z (6 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
b235c67
Parents:
5d96f427
git-author:
Miroslav Cimerman <mc@…> (2024-11-15 16:27:17)
git-committer:
Miroslav Cimerman <mc@…> (2024-11-15 16:44:25)
Message:

hr: add all fcn prototypes in raid implementations

Also restructure the file in order: create(), init(),
public BD ops, internal util functions and io ops.

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

Legend:

Unmodified
Added
Removed

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

    r5d96f427 r733564a  
    5454extern loc_srv_t *hr_srv;
    5555
     56static errno_t hr_raid0_check_vol_status(hr_volume_t *);
     57static errno_t hr_raid0_update_vol_status(hr_volume_t *);
     58static errno_t hr_raid0_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
     59    void *, const void *, size_t);
     60
     61/* bdops */
    5662static errno_t hr_raid0_bd_open(bd_srvs_t *, bd_srv_t *);
    5763static errno_t hr_raid0_bd_close(bd_srv_t *);
    … …  
    7480};
    7581
     82errno_t hr_raid0_create(hr_volume_t *new_volume)
     83{
     84        errno_t rc;
     85
     86        assert(new_volume->level == HR_LVL_0);
     87
     88        if (new_volume->dev_no < 2) {
     89                ERR_PRINTF("RAID 0 array needs at least 2 devices");
     90                return EINVAL;
     91        }
     92
     93        rc = hr_raid0_update_vol_status(new_volume);
     94        if (rc != EOK)
     95                return rc;
     96
     97        bd_srvs_init(&new_volume->hr_bds);
     98        new_volume->hr_bds.ops = &hr_raid0_bd_ops;
     99        new_volume->hr_bds.sarg = new_volume;
     100
     101        rc = hr_register_volume(new_volume);
     102
     103        return rc;
     104}
     105
     106errno_t hr_raid0_init(hr_volume_t *vol)
     107{
     108        errno_t rc;
     109        size_t bsize;
     110        uint64_t total_blkno;
     111
     112        assert(vol->level == HR_LVL_0);
     113
     114        rc = hr_check_devs(vol, &total_blkno, &bsize);
     115        if (rc != EOK)
     116                return rc;
     117
     118        vol->nblocks = total_blkno;
     119        vol->bsize = bsize;
     120        vol->data_offset = HR_DATA_OFF;
     121        vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no);
     122        vol->strip_size = HR_STRIP_SIZE;
     123
     124        return EOK;
     125}
     126
     127static errno_t hr_raid0_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     128{
     129        DPRINTF("hr_bd_open()\n");
     130        return EOK;
     131}
     132
     133static errno_t hr_raid0_bd_close(bd_srv_t *bd)
     134{
     135        DPRINTF("hr_bd_close()\n");
     136        return EOK;
     137}
     138
     139static errno_t hr_raid0_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     140{
     141        return hr_raid0_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     142}
     143
     144static errno_t hr_raid0_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     145    void *buf, size_t size)
     146{
     147        return hr_raid0_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
     148}
     149
     150static errno_t hr_raid0_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     151    const void *data, size_t size)
     152{
     153        return hr_raid0_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
     154}
     155
     156static errno_t hr_raid0_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
     157{
     158        hr_volume_t *vol = bd->srvs->sarg;
     159
     160        *rsize = vol->bsize;
     161        return EOK;
     162}
     163
     164static errno_t hr_raid0_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     165{
     166        hr_volume_t *vol = bd->srvs->sarg;
     167
     168        *rnb = vol->data_blkno;
     169        return EOK;
     170}
     171
    76172static errno_t hr_raid0_check_vol_status(hr_volume_t *vol)
    77173{
    … …  
    98194
    99195        vol->status = HR_VOL_ONLINE;
    100         return EOK;
    101 }
    102 
    103 static errno_t hr_raid0_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    104 {
    105         DPRINTF("hr_bd_open()\n");
    106         return EOK;
    107 }
    108 
    109 static errno_t hr_raid0_bd_close(bd_srv_t *bd)
    110 {
    111         DPRINTF("hr_bd_close()\n");
    112196        return EOK;
    113197}
    … …  
    205289}
    206290
    207 static errno_t hr_raid0_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    208 {
    209         return hr_raid0_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
    210 }
    211 
    212 static errno_t hr_raid0_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    213     void *buf, size_t size)
    214 {
    215         return hr_raid0_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    216 }
    217 
    218 static errno_t hr_raid0_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    219     const void *data, size_t size)
    220 {
    221         return hr_raid0_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    222 }
    223 
    224 static errno_t hr_raid0_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
    225 {
    226         hr_volume_t *vol = bd->srvs->sarg;
    227 
    228         *rsize = vol->bsize;
    229         return EOK;
    230 }
    231 
    232 static errno_t hr_raid0_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
    233 {
    234         hr_volume_t *vol = bd->srvs->sarg;
    235 
    236         *rnb = vol->data_blkno;
    237         return EOK;
    238 }
    239 
    240 errno_t hr_raid0_create(hr_volume_t *new_volume)
    241 {
    242         errno_t rc;
    243 
    244         assert(new_volume->level == HR_LVL_0);
    245 
    246         if (new_volume->dev_no < 2) {
    247                 ERR_PRINTF("RAID 0 array needs at least 2 devices");
    248                 return EINVAL;
    249         }
    250 
    251         rc = hr_raid0_update_vol_status(new_volume);
    252         if (rc != EOK)
    253                 return rc;
    254 
    255         bd_srvs_init(&new_volume->hr_bds);
    256         new_volume->hr_bds.ops = &hr_raid0_bd_ops;
    257         new_volume->hr_bds.sarg = new_volume;
    258 
    259         rc = hr_register_volume(new_volume);
    260 
    261         return rc;
    262 }
    263 
    264 errno_t hr_raid0_init(hr_volume_t *vol)
    265 {
    266         errno_t rc;
    267         size_t bsize;
    268         uint64_t total_blkno;
    269 
    270         assert(vol->level == HR_LVL_0);
    271 
    272         rc = hr_check_devs(vol, &total_blkno, &bsize);
    273         if (rc != EOK)
    274                 return rc;
    275 
    276         vol->nblocks = total_blkno;
    277         vol->bsize = bsize;
    278         vol->data_offset = HR_DATA_OFF;
    279         vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no);
    280         vol->strip_size = HR_STRIP_SIZE;
    281 
    282         return EOK;
    283 }
    284 
    285291/** @}
    286292 */

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

    r5d96f427 r733564a  
    5353extern loc_srv_t *hr_srv;
    5454
     55static errno_t hr_raid1_check_vol_status(hr_volume_t *);
     56static errno_t hr_raid1_update_vol_status(hr_volume_t *);
     57static void handle_extent_error(hr_volume_t *, size_t, errno_t);
     58static errno_t hr_raid1_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
     59    void *, const void *, size_t);
     60
     61/* bdops */
    5562static errno_t hr_raid1_bd_open(bd_srvs_t *, bd_srv_t *);
    5663static errno_t hr_raid1_bd_close(bd_srv_t *);
    … …  
    7380};
    7481
     82errno_t hr_raid1_create(hr_volume_t *new_volume)
     83{
     84        errno_t rc;
     85
     86        assert(new_volume->level == HR_LVL_1);
     87
     88        if (new_volume->dev_no < 2) {
     89                ERR_PRINTF("RAID 1 array needs at least 2 devices\n");
     90                return EINVAL;
     91        }
     92
     93        rc = hr_raid1_update_vol_status(new_volume);
     94        if (rc != EOK)
     95                return rc;
     96
     97        bd_srvs_init(&new_volume->hr_bds);
     98        new_volume->hr_bds.ops = &hr_raid1_bd_ops;
     99        new_volume->hr_bds.sarg = new_volume;
     100
     101        rc = hr_register_volume(new_volume);
     102
     103        return rc;
     104}
     105
     106errno_t hr_raid1_init(hr_volume_t *vol)
     107{
     108        errno_t rc;
     109        size_t bsize;
     110        uint64_t total_blkno;
     111
     112        assert(vol->level == HR_LVL_1);
     113
     114        rc = hr_check_devs(vol, &total_blkno, &bsize);
     115        if (rc != EOK)
     116                return rc;
     117
     118        vol->nblocks = total_blkno / vol->dev_no;
     119        vol->bsize = bsize;
     120        vol->data_offset = HR_DATA_OFF;
     121        vol->data_blkno = vol->nblocks - vol->data_offset;
     122        vol->strip_size = 0;
     123
     124        return EOK;
     125}
     126
     127static errno_t hr_raid1_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     128{
     129        DPRINTF("hr_bd_open()\n");
     130        return EOK;
     131}
     132
     133static errno_t hr_raid1_bd_close(bd_srv_t *bd)
     134{
     135        DPRINTF("hr_bd_close()\n");
     136        return EOK;
     137}
     138
     139static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     140{
     141        return hr_raid1_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     142}
     143
     144static errno_t hr_raid1_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     145    void *buf, size_t size)
     146{
     147        return hr_raid1_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
     148}
     149
     150static errno_t hr_raid1_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     151    const void *data, size_t size)
     152{
     153        return hr_raid1_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
     154}
     155
     156static errno_t hr_raid1_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
     157{
     158        hr_volume_t *vol = bd->srvs->sarg;
     159
     160        *rsize = vol->bsize;
     161        return EOK;
     162}
     163
     164static errno_t hr_raid1_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     165{
     166        hr_volume_t *vol = bd->srvs->sarg;
     167
     168        *rnb = vol->data_blkno;
     169        return EOK;
     170}
     171
    75172static errno_t hr_raid1_check_vol_status(hr_volume_t *vol)
    76173{
    … …  
    118215                return EOK;
    119216        }
    120 }
    121 
    122 static errno_t hr_raid1_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    123 {
    124         DPRINTF("hr_bd_open()\n");
    125         return EOK;
    126 }
    127 
    128 static errno_t hr_raid1_bd_close(bd_srv_t *bd)
    129 {
    130         DPRINTF("hr_bd_close()\n");
    131         return EOK;
    132217}
    133218
    … …  
    217302}
    218303
    219 static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    220 {
    221         return hr_raid1_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
    222 }
    223 
    224 static errno_t hr_raid1_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    225     void *buf, size_t size)
    226 {
    227         return hr_raid1_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    228 }
    229 
    230 static errno_t hr_raid1_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    231     const void *data, size_t size)
    232 {
    233         return hr_raid1_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    234 }
    235 
    236 static errno_t hr_raid1_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
    237 {
    238         hr_volume_t *vol = bd->srvs->sarg;
    239 
    240         *rsize = vol->bsize;
    241         return EOK;
    242 }
    243 
    244 static errno_t hr_raid1_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
    245 {
    246         hr_volume_t *vol = bd->srvs->sarg;
    247 
    248         *rnb = vol->data_blkno;
    249         return EOK;
    250 }
    251 
    252 errno_t hr_raid1_create(hr_volume_t *new_volume)
    253 {
    254         errno_t rc;
    255 
    256         assert(new_volume->level == HR_LVL_1);
    257 
    258         if (new_volume->dev_no < 2) {
    259                 ERR_PRINTF("RAID 1 array needs at least 2 devices\n");
    260                 return EINVAL;
    261         }
    262 
    263         rc = hr_raid1_update_vol_status(new_volume);
    264         if (rc != EOK)
    265                 return rc;
    266 
    267         bd_srvs_init(&new_volume->hr_bds);
    268         new_volume->hr_bds.ops = &hr_raid1_bd_ops;
    269         new_volume->hr_bds.sarg = new_volume;
    270 
    271         rc = hr_register_volume(new_volume);
    272 
    273         return rc;
    274 }
    275 
    276 errno_t hr_raid1_init(hr_volume_t *vol)
    277 {
    278         errno_t rc;
    279         size_t bsize;
    280         uint64_t total_blkno;
    281 
    282         assert(vol->level == HR_LVL_1);
    283 
    284         rc = hr_check_devs(vol, &total_blkno, &bsize);
    285         if (rc != EOK)
    286                 return rc;
    287 
    288         vol->nblocks = total_blkno / vol->dev_no;
    289         vol->bsize = bsize;
    290         vol->data_offset = HR_DATA_OFF;
    291         vol->data_blkno = vol->nblocks - vol->data_offset;
    292         vol->strip_size = 0;
    293 
    294         return EOK;
    295 }
    296 
    297304/** @}
    298305 */

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

    r5d96f427 r733564a  
    5555extern loc_srv_t *hr_srv;
    5656
     57static errno_t hr_raid4_vol_usable(hr_volume_t *);
     58static ssize_t hr_raid4_get_bad_ext(hr_volume_t *);
     59static errno_t hr_raid4_update_vol_status(hr_volume_t *);
     60static void xor(void *, const void *, size_t);
     61static errno_t hr_raid4_read_degraded(hr_volume_t *, uint64_t, uint64_t,
     62    void *, size_t);
     63static errno_t hr_raid4_write(hr_volume_t *, uint64_t, aoff64_t, const void *,
     64    size_t);
     65static errno_t hr_raid4_write_parity(hr_volume_t *, uint64_t, uint64_t,
     66    const void *, size_t);
     67static errno_t hr_raid4_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
     68    void *, const void *, size_t);
     69
     70/* bdops */
    5771static errno_t hr_raid4_bd_open(bd_srvs_t *, bd_srv_t *);
    5872static errno_t hr_raid4_bd_close(bd_srv_t *);
    … …  
    7791        .get_num_blocks = hr_raid4_bd_get_num_blocks
    7892};
     93
     94errno_t hr_raid4_create(hr_volume_t *new_volume)
     95{
     96        errno_t rc;
     97
     98        assert(new_volume->level == HR_LVL_4);
     99
     100        if (new_volume->dev_no < 3) {
     101                ERR_PRINTF("RAID 4 array needs at least 3 devices");
     102                return EINVAL;
     103        }
     104
     105        rc = hr_raid4_update_vol_status(new_volume);
     106        if (rc != EOK)
     107                return rc;
     108
     109        bd_srvs_init(&new_volume->hr_bds);
     110        new_volume->hr_bds.ops = &hr_raid4_bd_ops;
     111        new_volume->hr_bds.sarg = new_volume;
     112
     113        rc = hr_register_volume(new_volume);
     114
     115        return rc;
     116}
     117
     118errno_t hr_raid4_init(hr_volume_t *vol)
     119{
     120        errno_t rc;
     121        size_t bsize;
     122        uint64_t total_blkno;
     123
     124        assert(vol->level == HR_LVL_4);
     125
     126        rc = hr_check_devs(vol, &total_blkno, &bsize);
     127        if (rc != EOK)
     128                return rc;
     129
     130        vol->nblocks = total_blkno;
     131        vol->bsize = bsize;
     132        vol->data_offset = HR_DATA_OFF;
     133        vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no) -
     134            (vol->nblocks / vol->dev_no);
     135        vol->strip_size = HR_STRIP_SIZE;
     136
     137        return EOK;
     138}
     139
     140static errno_t hr_raid4_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     141{
     142        DPRINTF("hr_bd_open()\n");
     143        return EOK;
     144}
     145
     146static errno_t hr_raid4_bd_close(bd_srv_t *bd)
     147{
     148        DPRINTF("hr_bd_close()\n");
     149        return EOK;
     150}
     151
     152static errno_t hr_raid4_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     153{
     154        return hr_raid4_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     155}
     156
     157static errno_t hr_raid4_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     158    void *buf, size_t size)
     159{
     160        return hr_raid4_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
     161}
     162
     163static errno_t hr_raid4_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     164    const void *data, size_t size)
     165{
     166        return hr_raid4_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
     167}
     168
     169static errno_t hr_raid4_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
     170{
     171        hr_volume_t *vol = bd->srvs->sarg;
     172
     173        *rsize = vol->bsize;
     174        return EOK;
     175}
     176
     177static errno_t hr_raid4_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     178{
     179        hr_volume_t *vol = bd->srvs->sarg;
     180
     181        *rnb = vol->data_blkno;
     182        return EOK;
     183}
    79184
    80185static errno_t hr_raid4_vol_usable(hr_volume_t *vol)
    … …  
    317422        free(buf);
    318423        return rc;
    319 }
    320 
    321 static errno_t hr_raid4_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    322 {
    323         DPRINTF("hr_bd_open()\n");
    324         return EOK;
    325 }
    326 
    327 static errno_t hr_raid4_bd_close(bd_srv_t *bd)
    328 {
    329         DPRINTF("hr_bd_close()\n");
    330         return EOK;
    331424}
    332425
    … …  
    452545}
    453546
    454 static errno_t hr_raid4_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    455 {
    456         return hr_raid4_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
    457 }
    458 
    459 static errno_t hr_raid4_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    460     void *buf, size_t size)
    461 {
    462         return hr_raid4_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    463 }
    464 
    465 static errno_t hr_raid4_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    466     const void *data, size_t size)
    467 {
    468         return hr_raid4_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    469 }
    470 
    471 static errno_t hr_raid4_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
    472 {
    473         hr_volume_t *vol = bd->srvs->sarg;
    474 
    475         *rsize = vol->bsize;
    476         return EOK;
    477 }
    478 
    479 static errno_t hr_raid4_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
    480 {
    481         hr_volume_t *vol = bd->srvs->sarg;
    482 
    483         *rnb = vol->data_blkno;
    484         return EOK;
    485 }
    486 
    487 errno_t hr_raid4_create(hr_volume_t *new_volume)
    488 {
    489         errno_t rc;
    490 
    491         assert(new_volume->level == HR_LVL_4);
    492 
    493         if (new_volume->dev_no < 3) {
    494                 ERR_PRINTF("RAID 4 array needs at least 3 devices");
    495                 return EINVAL;
    496         }
    497 
    498         rc = hr_raid4_update_vol_status(new_volume);
    499         if (rc != EOK)
    500                 return rc;
    501 
    502         bd_srvs_init(&new_volume->hr_bds);
    503         new_volume->hr_bds.ops = &hr_raid4_bd_ops;
    504         new_volume->hr_bds.sarg = new_volume;
    505 
    506         rc = hr_register_volume(new_volume);
    507 
    508         return rc;
    509 }
    510 
    511 errno_t hr_raid4_init(hr_volume_t *vol)
    512 {
    513         errno_t rc;
    514         size_t bsize;
    515         uint64_t total_blkno;
    516 
    517         assert(vol->level == HR_LVL_4);
    518 
    519         rc = hr_check_devs(vol, &total_blkno, &bsize);
    520         if (rc != EOK)
    521                 return rc;
    522 
    523         vol->nblocks = total_blkno;
    524         vol->bsize = bsize;
    525         vol->data_offset = HR_DATA_OFF;
    526         vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no) -
    527             (vol->nblocks / vol->dev_no);
    528         vol->strip_size = HR_STRIP_SIZE;
    529 
    530         return EOK;
    531 }
    532 
    533547/** @}
    534548 */

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

    r5d96f427 r733564a  
    5555extern loc_srv_t *hr_srv;
    5656
     57static errno_t hr_raid5_vol_usable(hr_volume_t *);
     58static ssize_t hr_raid5_get_bad_ext(hr_volume_t *);
     59static errno_t hr_raid5_update_vol_status(hr_volume_t *);
     60static void xor(void *, const void *, size_t);
     61static errno_t hr_raid5_read_degraded(hr_volume_t *, uint64_t, uint64_t,
     62    void *, size_t);
     63static errno_t hr_raid5_write(hr_volume_t *, uint64_t, uint64_t, aoff64_t,
     64    const void *, size_t);
     65static errno_t hr_raid5_write_parity(hr_volume_t *, uint64_t, uint64_t,
     66    uint64_t, const void *, size_t);
     67static errno_t hr_raid5_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
     68    void *, const void *, size_t);
     69
     70/* bdops */
    5771static errno_t hr_raid5_bd_open(bd_srvs_t *, bd_srv_t *);
    5872static errno_t hr_raid5_bd_close(bd_srv_t *);
    … …  
    6579static errno_t hr_raid5_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    6680
    67 static errno_t hr_raid5_write_parity(hr_volume_t *, uint64_t, uint64_t,
    68     uint64_t, const void *, size_t);
    69 
    7081static bd_ops_t hr_raid5_bd_ops = {
    7182        .open = hr_raid5_bd_open,
    … …  
    7788        .get_num_blocks = hr_raid5_bd_get_num_blocks
    7889};
     90
     91errno_t hr_raid5_create(hr_volume_t *new_volume)
     92{
     93        errno_t rc;
     94
     95        assert(new_volume->level == HR_LVL_5);
     96
     97        if (new_volume->dev_no < 3) {
     98                ERR_PRINTF("RAID 5 array needs at least 3 devices");
     99                return EINVAL;
     100        }
     101
     102        rc = hr_raid5_update_vol_status(new_volume);
     103        if (rc != EOK)
     104                return rc;
     105
     106        bd_srvs_init(&new_volume->hr_bds);
     107        new_volume->hr_bds.ops = &hr_raid5_bd_ops;
     108        new_volume->hr_bds.sarg = new_volume;
     109
     110        rc = hr_register_volume(new_volume);
     111
     112        return rc;
     113}
     114
     115errno_t hr_raid5_init(hr_volume_t *vol)
     116{
     117        errno_t rc;
     118        size_t bsize;
     119        uint64_t total_blkno;
     120
     121        assert(vol->level == HR_LVL_5);
     122
     123        rc = hr_check_devs(vol, &total_blkno, &bsize);
     124        if (rc != EOK)
     125                return rc;
     126
     127        vol->nblocks = total_blkno;
     128        vol->bsize = bsize;
     129        vol->data_offset = HR_DATA_OFF;
     130        vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no) -
     131            (vol->nblocks / vol->dev_no);
     132        vol->strip_size = HR_STRIP_SIZE;
     133
     134        return EOK;
     135}
     136
     137static errno_t hr_raid5_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     138{
     139        DPRINTF("hr_bd_open()\n");
     140        return EOK;
     141}
     142
     143static errno_t hr_raid5_bd_close(bd_srv_t *bd)
     144{
     145        DPRINTF("hr_bd_close()\n");
     146        return EOK;
     147}
     148
     149static errno_t hr_raid5_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     150{
     151        return hr_raid5_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     152}
     153
     154static errno_t hr_raid5_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     155    void *buf, size_t size)
     156{
     157        return hr_raid5_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
     158}
     159
     160static errno_t hr_raid5_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
     161    const void *data, size_t size)
     162{
     163        return hr_raid5_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
     164}
     165
     166static errno_t hr_raid5_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
     167{
     168        hr_volume_t *vol = bd->srvs->sarg;
     169
     170        *rsize = vol->bsize;
     171        return EOK;
     172}
     173
     174static errno_t hr_raid5_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     175{
     176        hr_volume_t *vol = bd->srvs->sarg;
     177
     178        *rnb = vol->data_blkno;
     179        return EOK;
     180}
    79181
    80182static errno_t hr_raid5_vol_usable(hr_volume_t *vol)
    … …  
    317419        free(buf);
    318420        return rc;
    319 }
    320 
    321 static errno_t hr_raid5_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    322 {
    323         DPRINTF("hr_bd_open()\n");
    324         return EOK;
    325 }
    326 
    327 static errno_t hr_raid5_bd_close(bd_srv_t *bd)
    328 {
    329         DPRINTF("hr_bd_close()\n");
    330         return EOK;
    331421}
    332422
    … …  
    461551}
    462552
    463 static errno_t hr_raid5_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    464 {
    465         return hr_raid5_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
    466 }
    467 
    468 static errno_t hr_raid5_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    469     void *buf, size_t size)
    470 {
    471         return hr_raid5_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    472 }
    473 
    474 static errno_t hr_raid5_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    475     const void *data, size_t size)
    476 {
    477         return hr_raid5_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    478 }
    479 
    480 static errno_t hr_raid5_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
    481 {
    482         hr_volume_t *vol = bd->srvs->sarg;
    483 
    484         *rsize = vol->bsize;
    485         return EOK;
    486 }
    487 
    488 static errno_t hr_raid5_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
    489 {
    490         hr_volume_t *vol = bd->srvs->sarg;
    491 
    492         *rnb = vol->data_blkno;
    493         return EOK;
    494 }
    495 
    496 errno_t hr_raid5_create(hr_volume_t *new_volume)
    497 {
    498         errno_t rc;
    499 
    500         assert(new_volume->level == HR_LVL_5);
    501 
    502         if (new_volume->dev_no < 3) {
    503                 ERR_PRINTF("RAID 5 array needs at least 3 devices");
    504                 return EINVAL;
    505         }
    506 
    507         rc = hr_raid5_update_vol_status(new_volume);
    508         if (rc != EOK)
    509                 return rc;
    510 
    511         bd_srvs_init(&new_volume->hr_bds);
    512         new_volume->hr_bds.ops = &hr_raid5_bd_ops;
    513         new_volume->hr_bds.sarg = new_volume;
    514 
    515         rc = hr_register_volume(new_volume);
    516 
    517         return rc;
    518 }
    519 
    520 errno_t hr_raid5_init(hr_volume_t *vol)
    521 {
    522         errno_t rc;
    523         size_t bsize;
    524         uint64_t total_blkno;
    525 
    526         assert(vol->level == HR_LVL_5);
    527 
    528         rc = hr_check_devs(vol, &total_blkno, &bsize);
    529         if (rc != EOK)
    530                 return rc;
    531 
    532         vol->nblocks = total_blkno;
    533         vol->bsize = bsize;
    534         vol->data_offset = HR_DATA_OFF;
    535         vol->data_blkno = vol->nblocks - (vol->data_offset * vol->dev_no) -
    536             (vol->nblocks / vol->dev_no);
    537         vol->strip_size = HR_STRIP_SIZE;
    538 
    539         return EOK;
    540 }
    541 
    542553/** @}
    543554 */
Note: See TracChangeset for help on using the changeset viewer.