Changeset fad91b9 in mainline


Ignore:
Timestamp:
2024-10-27T23:04:58Z (7 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.

Location:
uspace/srv/bd/hr
Files:
5 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

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

    r50bed55d rfad91b9  
    8585}
    8686
    87 static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     87static errno_t hr_raid1_bd_op(hr_bd_op_type_t type, bd_srv_t *bd, aoff64_t ba,
     88    size_t cnt, void *data_read, const void *data_write, size_t size)
    8889{
    8990        hr_volume_t *vol = bd->srvs->sarg;
    90 
    9191        errno_t rc;
    9292        size_t i;
     93
     94        if (type == HR_BD_READ || type == HR_BD_WRITE)
     95                if (size < cnt * vol->bsize)
     96                        return EINVAL;
    9397
    9498        rc = hr_check_ba_range(vol, cnt, ba);
    … …  
    100104        fibril_mutex_lock(&vol->lock);
    101105
    102         for (i = 0; i < vol->dev_no; i++) {
    103                 rc = block_sync_cache(vol->extents[i].svc_id, ba, cnt);
    104                 if (rc != EOK)
    105                         break;
     106        switch (type) {
     107        case HR_BD_SYNC:
     108                for (i = 0; i < vol->dev_no; i++) {
     109                        rc = block_sync_cache(vol->extents[i].svc_id, ba, cnt);
     110                        if (rc != EOK)
     111                                goto error;
     112                }
     113                break;
     114        case HR_BD_READ:
     115                for (i = 0; i < vol->dev_no; i++) {
     116                        rc = block_read_direct(vol->extents[i].svc_id, ba, cnt,
     117                            data_read);
     118                        if (rc != EOK)
     119                                goto error;
     120                }
     121                break;
     122        case HR_BD_WRITE:
     123                for (i = 0; i < vol->dev_no; i++) {
     124                        rc = block_write_direct(vol->extents[i].svc_id, ba, cnt,
     125                            data_write);
     126                        if (rc != EOK)
     127                                goto error;
     128                }
     129                break;
     130        default:
     131                rc = EINVAL;
    106132        }
    107133
     134error:
    108135        fibril_mutex_unlock(&vol->lock);
    109136        return rc;
    110137}
    111138
     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
    112144static errno_t hr_raid1_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    113145    void *buf, size_t size)
    114146{
    115         hr_volume_t *vol = bd->srvs->sarg;
    116 
    117         errno_t rc;
    118         size_t i;
    119 
    120         rc = hr_check_ba_range(vol, cnt, ba);
    121         if (rc != EOK)
    122                 return rc;
    123 
    124         hr_add_ba_offset(vol, &ba);
    125 
    126         fibril_mutex_lock(&vol->lock);
    127 
    128         for (i = 0; i < vol->dev_no; i++) {
    129                 rc = block_read_direct(vol->extents[i].svc_id, ba, cnt, buf);
    130                 if (rc != EOK)
    131                         break;
    132         }
    133 
    134         fibril_mutex_unlock(&vol->lock);
    135         return rc;
     147        return hr_raid1_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    136148}
    137149
    … …  
    139151    const void *data, size_t size)
    140152{
    141         hr_volume_t *vol = bd->srvs->sarg;
    142 
    143         errno_t rc;
    144         size_t i;
    145 
    146         rc = hr_check_ba_range(vol, cnt, ba);
    147         if (rc != EOK)
    148                 return rc;
    149 
    150         hr_add_ba_offset(vol, &ba);
    151 
    152         fibril_mutex_lock(&vol->lock);
    153 
    154         for (i = 0; i < vol->dev_no; i++) {
    155                 rc = block_write_direct(vol->extents[i].svc_id, ba, cnt, data);
    156                 if (rc != EOK)
    157                         break;
    158         }
    159 
    160         fibril_mutex_unlock(&vol->lock);
    161         return rc;
     153        return hr_raid1_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    162154}
    163155

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

    r50bed55d rfad91b9  
    106106                        xor(xorbuf, data, vol->bsize);
    107107                } else {
    108                         rc = block_read_direct(vol->extents[i].svc_id, block, 1, buf);
     108                        rc = block_read_direct(vol->extents[i].svc_id, block, 1,
     109                            buf);
    109110                        if (rc != EOK)
    110111                                goto end;
    … …  
    147148}
    148149
    149 static errno_t hr_raid4_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     150static errno_t hr_raid4_bd_op(hr_bd_op_type_t type, bd_srv_t *bd, aoff64_t ba,
     151    size_t cnt, void *data_read, const void *data_write, size_t size)
    150152{
    151153        hr_volume_t *vol = bd->srvs->sarg;
    152154        errno_t rc;
    153155        uint64_t phys_block;
    154         size_t extent;
     156        size_t extent, left;
     157
     158        if (type == HR_BD_READ || type == HR_BD_WRITE)
     159                if (size < cnt * vol->bsize)
     160                        return EINVAL;
    155161
    156162        rc = hr_check_ba_range(vol, cnt, ba);
    … …  
    160166        fibril_mutex_lock(&vol->lock);
    161167
    162         size_t left = cnt;
     168        left = cnt;
    163169        while (left != 0) {
    164170                raid4_geometry(ba, vol, &extent, &phys_block);
    165171                hr_add_ba_offset(vol, &phys_block);
    166                 rc = block_sync_cache(vol->extents[extent].svc_id, phys_block, 1);
     172                switch (type) {
     173                case HR_BD_SYNC:
     174                        rc = block_sync_cache(vol->extents[extent].svc_id,
     175                            phys_block, 1);
     176                        break;
     177                case HR_BD_READ:
     178                        rc = block_read_direct(vol->extents[extent].svc_id,
     179                            phys_block, 1, data_read);
     180                        data_read = data_read + vol->bsize;
     181                        break;
     182                case HR_BD_WRITE:
     183                        rc = block_write_direct(vol->extents[extent].svc_id,
     184                            phys_block, 1, data_write);
     185                        if (rc != EOK)
     186                                goto error;
     187                        rc = write_parity(vol, extent, phys_block, data_write);
     188                        if (rc != EOK)
     189                                goto error;
     190                        data_write = data_write + vol->bsize;
     191                        break;
     192                default:
     193                        rc = EINVAL;
     194                }
     195
    167196                if (rc != EOK)
    168                         break;
     197                        goto error;
     198
    169199                left--;
    170200                ba++;
    171201        }
    172202
     203error:
    173204        fibril_mutex_unlock(&vol->lock);
    174205        return rc;
    175206}
    176207
     208static errno_t hr_raid4_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     209{
     210        return hr_raid4_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     211}
     212
    177213static errno_t hr_raid4_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    178214    void *buf, size_t size)
    179215{
    180         hr_volume_t *vol = bd->srvs->sarg;
    181         errno_t rc;
    182         uint64_t phys_block;
    183         size_t extent;
    184 
    185         if (size < cnt * vol->bsize)
    186                 return EINVAL;
    187 
    188         rc = hr_check_ba_range(vol, cnt, ba);
    189         if (rc != EOK)
    190                 return rc;
    191 
    192         fibril_mutex_lock(&vol->lock);
    193 
    194         size_t left = cnt;
    195         while (left != 0) {
    196                 raid4_geometry(ba, vol, &extent, &phys_block);
    197                 hr_add_ba_offset(vol, &phys_block);
    198                 rc = block_read_direct(vol->extents[extent].svc_id, phys_block, 1, buf);
    199                 buf = buf + vol->bsize;
    200                 if (rc != EOK)
    201                         break;
    202                 left--;
    203                 ba++;
    204         }
    205 
    206         fibril_mutex_unlock(&vol->lock);
    207         return rc;
     216        return hr_raid4_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    208217}
    209218
    … …  
    211220    const void *data, size_t size)
    212221{
    213         hr_volume_t *vol = bd->srvs->sarg;
    214         errno_t rc;
    215         uint64_t phys_block;
    216         size_t extent;
    217 
    218         if (size < cnt * vol->bsize)
    219                 return EINVAL;
    220 
    221         rc = hr_check_ba_range(vol, cnt, ba);
    222         if (rc != EOK)
    223                 return rc;
    224 
    225         fibril_mutex_lock(&vol->lock);
    226 
    227         size_t left = cnt;
    228         while (left != 0) {
    229                 raid4_geometry(ba, vol, &extent, &phys_block);
    230                 hr_add_ba_offset(vol, &phys_block);
    231                 rc = block_write_direct(vol->extents[extent].svc_id, phys_block, 1, data);
    232                 if (rc != EOK)
    233                         break;
    234                 rc = write_parity(vol, extent, phys_block, data);
    235                 if (rc != EOK)
    236                         break;
    237                 data = data + vol->bsize;
    238                 left--;
    239                 ba++;
    240         }
    241 
    242         fibril_mutex_unlock(&vol->lock);
    243         return rc;
     222        return hr_raid4_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    244223}
    245224

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

    r50bed55d rfad91b9  
    109109                        xor(xorbuf, data, vol->bsize);
    110110                } else {
    111                         rc = block_read_direct(vol->extents[i].svc_id, block, 1, buf);
     111                        rc = block_read_direct(vol->extents[i].svc_id, block, 1,
     112                            buf);
    112113                        if (rc != EOK)
    113114                                goto end;
    … …  
    116117        }
    117118
    118         rc = block_write_direct(vol->extents[p_extent].svc_id, block, 1, xorbuf);
     119        rc = block_write_direct(vol->extents[p_extent].svc_id, block, 1,
     120            xorbuf);
    119121
    120122end:
    … …  
    159161}
    160162
    161 static errno_t hr_raid5_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     163static errno_t hr_raid5_bd_op(hr_bd_op_type_t type, bd_srv_t *bd, aoff64_t ba,
     164    size_t cnt, void *data_read, const void *data_write, size_t size)
    162165{
    163166        hr_volume_t *vol = bd->srvs->sarg;
    164167        errno_t rc;
    165         uint64_t phys_block;
    166         size_t extent;
     168        uint64_t phys_block, p_extent;
     169        size_t extent, left;
     170
     171        if (type == HR_BD_READ || type == HR_BD_WRITE)
     172                if (size < cnt * vol->bsize)
     173                        return EINVAL;
    167174
    168175        rc = hr_check_ba_range(vol, cnt, ba);
    … …  
    172179        fibril_mutex_lock(&vol->lock);
    173180
    174         size_t left = cnt;
     181        left = cnt;
    175182        while (left != 0) {
    176                 raid5_geometry(ba, vol, &extent, &phys_block, NULL);
    177                 hr_add_ba_offset(vol, &phys_block);
    178                 rc = block_sync_cache(vol->extents[extent].svc_id, phys_block, 1);
     183                switch (type) {
     184                case HR_BD_SYNC:
     185                        raid5_geometry(ba, vol, &extent, &phys_block, NULL);
     186                        hr_add_ba_offset(vol, &phys_block);
     187                        rc = block_sync_cache(vol->extents[extent].svc_id,
     188                            phys_block, 1);
     189                        break;
     190                case HR_BD_READ:
     191                        raid5_geometry(ba, vol, &extent, &phys_block, NULL);
     192                        hr_add_ba_offset(vol, &phys_block);
     193                        rc = block_read_direct(vol->extents[extent].svc_id,
     194                            phys_block, 1, data_read);
     195                        data_read = data_read + vol->bsize;
     196                        break;
     197                case HR_BD_WRITE:
     198                        raid5_geometry(ba, vol, &extent, &phys_block,
     199                            &p_extent);
     200                        hr_add_ba_offset(vol, &phys_block);
     201                        rc = block_write_direct(vol->extents[extent].svc_id,
     202                            phys_block, 1, data_write);
     203                        if (rc != EOK)
     204                                goto error;
     205                        rc = write_parity(vol, p_extent, extent, phys_block,
     206                            data_write);
     207                        if (rc != EOK)
     208                                goto error;
     209                        data_write = data_write + vol->bsize;
     210                        break;
     211                default:
     212                        rc = EINVAL;
     213                }
     214
    179215                if (rc != EOK)
    180                         break;
     216                        goto error;
     217
    181218                left--;
    182219                ba++;
    183220        }
    184221
     222error:
    185223        fibril_mutex_unlock(&vol->lock);
    186224        return rc;
    187225}
    188226
     227static errno_t hr_raid5_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
     228{
     229        return hr_raid5_bd_op(HR_BD_SYNC, bd, ba, cnt, NULL, NULL, 0);
     230}
     231
    189232static errno_t hr_raid5_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
    190233    void *buf, size_t size)
    191234{
    192         hr_volume_t *vol = bd->srvs->sarg;
    193         errno_t rc;
    194         uint64_t phys_block;
    195         size_t extent;
    196 
    197         if (size < cnt * vol->bsize)
    198                 return EINVAL;
    199 
    200         rc = hr_check_ba_range(vol, cnt, ba);
    201         if (rc != EOK)
    202                 return rc;
    203 
    204         fibril_mutex_lock(&vol->lock);
    205 
    206         size_t left = cnt;
    207         while (left != 0) {
    208                 raid5_geometry(ba, vol, &extent, &phys_block, NULL);
    209                 hr_add_ba_offset(vol, &phys_block);
    210                 rc = block_read_direct(vol->extents[extent].svc_id, phys_block, 1, buf);
    211                 buf = buf + vol->bsize;
    212                 if (rc != EOK)
    213                         break;
    214                 left--;
    215                 ba++;
    216         }
    217 
    218         fibril_mutex_unlock(&vol->lock);
    219         return rc;
     235        return hr_raid5_bd_op(HR_BD_READ, bd, ba, cnt, buf, NULL, size);
    220236}
    221237
    … …  
    223239    const void *data, size_t size)
    224240{
    225         hr_volume_t *vol = bd->srvs->sarg;
    226         errno_t rc;
    227         uint64_t phys_block, p_extent;
    228         size_t extent;
    229 
    230         if (size < cnt * vol->bsize)
    231                 return EINVAL;
    232 
    233         rc = hr_check_ba_range(vol, cnt, ba);
    234         if (rc != EOK)
    235                 return rc;
    236 
    237         fibril_mutex_lock(&vol->lock);
    238 
    239         size_t left = cnt;
    240         while (left != 0) {
    241                 raid5_geometry(ba, vol, &extent, &phys_block, &p_extent);
    242                 hr_add_ba_offset(vol, &phys_block);
    243                 rc = block_write_direct(vol->extents[extent].svc_id, phys_block, 1, data);
    244                 if (rc != EOK)
    245                         break;
    246                 rc = write_parity(vol, p_extent, extent, phys_block, data);
    247                 if (rc != EOK)
    248                         break;
    249                 data = data + vol->bsize;
    250                 left--;
    251                 ba++;
    252         }
    253 
    254         fibril_mutex_unlock(&vol->lock);
    255         return rc;
     241        return hr_raid5_bd_op(HR_BD_WRITE, bd, ba, cnt, NULL, data, size);
    256242}
    257243

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

    r50bed55d rfad91b9  
    6969} hr_volume_t;
    7070
     71typedef enum {
     72        HR_BD_SYNC,
     73        HR_BD_READ,
     74        HR_BD_WRITE
     75} hr_bd_op_type_t;
     76
    7177extern errno_t hr_init_devs(hr_volume_t *);
    7278extern void hr_fini_devs(hr_volume_t *);
Note: See TracChangeset for help on using the changeset viewer.