Changeset fad91b9 in mainline for uspace/srv/bd/hr/raid0.c


Ignore:
Timestamp:
2024-10-27T23:04:58Z (9 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
76cd345
Parents:
50bed55d
git-author:
Miroslav Cimerman <mc@…> (2024-10-27 22:51:08)
git-committer:
Miroslav Cimerman <mc@…> (2024-10-27 23:04:58)
Message:

hr: make bd op functions more compact

A single function now handles all bd ops, just the type of IO reuqest
is specified in bd op caller. Besides this design being more compact,
it can be seen as preparation for workers and parallelization.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r50bed55d rfad91b9  
    100100}
    101101
    102 static errno_t hr_raid0_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     102static errno_t hr_raid0_bd_op(hr_bd_op_type_t type, bd_srv_t *bd, aoff64_t ba,
     103    size_t cnt, void *data_read, const void *data_write, size_t size)
    103104{
    104105        hr_volume_t *vol = bd->srvs->sarg;
    … …  
    107108        size_t extent, left;
    108109
     110        if (type == HR_BD_READ || type == HR_BD_WRITE)
     111                if (size < cnt * vol->bsize)
     112                        return EINVAL;
     113
    109114        rc = hr_check_ba_range(vol, cnt, ba);
    110115        if (rc != EOK)
    … …  
    117122                raid0_geometry(ba, vol, &extent, &phys_block);
    118123                hr_add_ba_offset(vol, &phys_block);
    119                 rc = block_sync_cache(vol->extents[extent].svc_id, phys_block, 1);
     124                switch (type) {
     125                case HR_BD_SYNC:
     126                        rc = block_sync_cache(vol->extents[extent].svc_id,
     127                            phys_block, 1);
     128                        break;
     129                case HR_BD_READ:
     130                        rc = block_read_direct(vol->extents[extent].svc_id,
     131                            phys_block, 1, data_read);
     132                        data_read = data_read + vol->bsize;
     133                        break;
     134                case HR_BD_WRITE:
     135                        rc = block_write_direct(vol->extents[extent].svc_id,
     136                            phys_block, 1, data_write);
     137                        data_write = data_write + vol->bsize;
     138                        break;
     139                default:
     140                        rc = EINVAL;
     141                }
     142
    120143                if (rc != EOK)
    121                         break;
     144                        goto error;
     145
    122146                left--;
    123147                ba++;
    124148        }
    125149
     150error:
    126151        fibril_mutex_unlock(&vol->lock);
    127152        return rc;
    128153}
    129154
     155static errno_t hr_raid0_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     156{
     157        return hr_raid0_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     158}
     159
    130160static errno_t hr_raid0_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    131161    void *buf, size_t size)
    132162{
    133         hr_volume_t *vol = bd->srvs->sarg;
    134         errno_t rc;
    135         uint64_t phys_block;
    136         size_t extent, left;
    137 
    138         if (size < cnt * vol->bsize)
    139                 return EINVAL;
    140 
    141         rc = hr_check_ba_range(vol, cnt, ba);
    142         if (rc != EOK)
    143                 return rc;
    144 
    145         fibril_mutex_lock(&vol->lock);
    146 
    147         left = cnt;
    148         while (left != 0) {
    149                 raid0_geometry(ba, vol, &extent, &phys_block);
    150                 hr_add_ba_offset(vol, &phys_block);
    151                 rc = block_read_direct(vol->extents[extent].svc_id, phys_block, 1, buf);
    152                 buf = buf + vol->bsize;
    153                 if (rc != EOK)
    154                         break;
    155                 left--;
    156                 ba++;
    157         }
    158 
    159         fibril_mutex_unlock(&vol->lock);
    160         return rc;
     163        return hr_raid0_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    161164}
    162165
    … …  
    164167    const void *data, size_t size)
    165168{
    166         hr_volume_t *vol = bd->srvs->sarg;
    167         errno_t rc;
    168         uint64_t phys_block;
    169         size_t extent, left;
    170 
    171         if (size < cnt * vol->bsize)
    172                 return EINVAL;
    173 
    174         rc = hr_check_ba_range(vol, cnt, ba);
    175         if (rc != EOK)
    176                 return rc;
    177 
    178         fibril_mutex_lock(&vol->lock);
    179 
    180         left = cnt;
    181         while (left != 0) {
    182                 raid0_geometry(ba, vol, &extent, &phys_block);
    183                 hr_add_ba_offset(vol, &phys_block);
    184                 rc = block_write_direct(vol->extents[extent].svc_id, phys_block, 1, data);
    185                 data = data + vol->bsize;
    186                 if (rc != EOK)
    187                         break;
    188                 left--;
    189                 ba++;
    190         }
    191 
    192         fibril_mutex_unlock(&vol->lock);
    193         return rc;
     169        return hr_raid0_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    194170}
    195171
Note: See TracChangeset for help on using the changeset viewer.