Changeset 733564a in mainline for uspace/srv/bd/hr/raid4.c


Ignore:
Timestamp:
2024-11-15T16:44:25Z (9 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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 */
Note: See TracChangeset for help on using the changeset viewer.