Changeset b0f1366 in mainline for uspace/srv/bd/hr


Ignore:
Timestamp:
2024-09-06T11:37:54Z (13 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
9c1cf34c
Parents:
ee83e9c
Message:

hr: write persistent metadata, assemble array from metadata

Location:
uspace/srv/bd/hr
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed

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

    ree83e9c rb0f1366  
    4949#include <str_error.h>
    5050
     51#include "superblock.h"
     52#include "util.h"
    5153#include "var.h"
    5254
    … …  
    5860
    5961static service_id_t ctl_sid;
     62
    6063
    6164static void hr_create_srv(ipc_call_t *icall)
    … …  
    9295                async_answer_0(&call, rc);
    9396                async_answer_0(icall, rc);
     97                return;
    9498        }
    9599
    96100        new_volume = calloc(1, sizeof(hr_volume_t));
    97101        if (new_volume == NULL) {
    98                 rc = ENOMEM;
    99                 goto end;
     102                free(cfg);
     103                async_answer_0(icall, ENOMEM);
     104                return;
    100105        }
    101106
    … …  
    104109        new_volume->level = cfg->level;
    105110        new_volume->dev_no = cfg->dev_no;
     111
     112        rc = hr_init_devs(new_volume);
     113        if (rc != EOK) {
     114                free(cfg);
     115                async_answer_0(icall, rc);
     116                return;
     117        }
     118
     119        rc = hr_check_devs(new_volume);
     120        if (rc != EOK)
     121                goto error;
     122
     123        rc = hr_write_meta_to_vol(new_volume);
     124        if (rc != EOK)
     125                goto error;
    106126
    107127        switch (new_volume->level) {
    … …  
    113133                break;
    114134        default:
    115                 log_msg(LOG_DEFAULT, LVL_NOTE,
    116                     "level %d not implemented yet\n", new_volume->level);
     135                log_msg(LOG_DEFAULT, LVL_ERROR,
     136                    "level %d not implemented yet", new_volume->level);
    117137                rc = EINVAL;
    118                 goto end;
     138                goto error;
    119139        }
    120140
    121141        rc = new_volume->hr_ops.create(new_volume);
    122         if (rc != EOK) {
    123                 goto end;
    124         }
     142        if (rc != EOK)
     143                goto error;
    125144
    126145        fibril_mutex_lock(&hr_volumes_lock);
    … …  
    128147        fibril_mutex_unlock(&hr_volumes_lock);
    129148
    130         log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")\n",
     149        log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")",
    131150            new_volume->devname, new_volume->svc_id);
    132151
    133 end:
    134152        free(cfg);
     153        async_answer_0(icall, rc);
     154        return;
     155error:
     156        free(cfg);
     157        hr_fini_devs(new_volume);
     158        async_answer_0(icall, rc);
     159}
     160
     161static void hr_assemble_srv(ipc_call_t *icall)
     162{
     163        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_assemble_srv()");
     164
     165        errno_t rc;
     166        size_t size;
     167        hr_config_t *cfg;
     168        hr_volume_t *new_volume;
     169        ipc_call_t call;
     170
     171        if (!async_data_write_receive(&call, &size)) {
     172                async_answer_0(&call, EREFUSED);
     173                async_answer_0(icall, EREFUSED);
     174                return;
     175        }
     176
     177        if (size != sizeof(hr_config_t)) {
     178                async_answer_0(&call, EINVAL);
     179                async_answer_0(icall, EINVAL);
     180                return;
     181        }
     182
     183        cfg = calloc(1, sizeof(hr_config_t));
     184        if (cfg == NULL) {
     185                async_answer_0(&call, ENOMEM);
     186                async_answer_0(icall, ENOMEM);
     187                return;
     188        }
     189
     190        rc = async_data_write_finalize(&call, cfg, size);
     191        if (rc != EOK) {
     192                async_answer_0(&call, rc);
     193                async_answer_0(icall, rc);
     194                return;
     195        }
     196
     197        new_volume = calloc(1, sizeof(hr_volume_t));
     198        if (new_volume == NULL) {
     199                free(cfg);
     200                async_answer_0(icall, ENOMEM);
     201                return;
     202        }
     203
     204        str_cpy(new_volume->devname, 32, cfg->devname);
     205        memcpy(new_volume->devs, cfg->devs, sizeof(service_id_t) * HR_MAXDEVS);
     206        new_volume->dev_no = cfg->dev_no;
     207
     208        if (cfg->level != hr_l_empty)
     209                log_msg(LOG_DEFAULT, LVL_WARN,
     210                    "level manually set when assembling, ingoring");
     211
     212        new_volume->level = hr_l_empty;
     213
     214        rc = hr_init_devs(new_volume);
     215        if (rc != EOK) {
     216                free(cfg);
     217                async_answer_0(icall, rc);
     218                return;
     219        }
     220
     221        rc = hr_check_devs(new_volume);
     222        if (rc != EOK)
     223                goto error;
     224
     225        rc = hr_get_vol_from_meta(cfg, new_volume);
     226        if (rc != EOK)
     227                goto error;
     228
     229        switch (new_volume->level) {
     230        case hr_l_1:
     231                new_volume->hr_ops.create = hr_raid1_create;
     232                break;
     233        case hr_l_0:
     234                new_volume->hr_ops.create = hr_raid0_create;
     235                break;
     236        default:
     237                log_msg(LOG_DEFAULT, LVL_ERROR,
     238                    "level %d not implemented yet", new_volume->level);
     239                rc = EINVAL;
     240                goto error;
     241        }
     242
     243        rc = new_volume->hr_ops.create(new_volume);
     244        if (rc != EOK)
     245                goto error;
     246
     247        fibril_mutex_lock(&hr_volumes_lock);
     248        list_append(&new_volume->lvolumes, &hr_volumes);
     249        fibril_mutex_unlock(&hr_volumes_lock);
     250
     251        log_msg(LOG_DEFAULT, LVL_NOTE, "assembled volume \"%s\" (%" PRIun ")",
     252            new_volume->devname, new_volume->svc_id);
     253
     254        free(cfg);
     255        async_answer_0(icall, rc);
     256        return;
     257error:
     258        free(cfg);
     259        hr_fini_devs(new_volume);
    135260        async_answer_0(icall, rc);
    136261}
    … …  
    170295                info.extent_no = volume->dev_no;
    171296                info.level = volume->level;
    172                 info.nblocks = volume->nblocks;
     297                /* print usable number of blocks */
     298                info.nblocks = volume->data_blkno;
    173299                info.bsize = volume->bsize;
    174300
    … …  
    219345                case HR_STATUS:
    220346                        hr_print_status_srv(&call);
     347                        break;
     348                case HR_ASSEMBLE:
     349                        hr_assemble_srv(&call);
    221350                        break;
    222351                default:

  • uspace/srv/bd/hr/meson.build

    ree83e9c rb0f1366  
    2828
    2929deps = [ 'block', 'device' ]
    30 src = files('hr.c', 'raid0.c', 'raid1.c', 'util.c')
     30src = files('hr.c', 'raid0.c', 'raid1.c', 'superblock.c', 'util.c')

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

    ree83e9c rb0f1366  
    4848#include <str_error.h>
    4949
     50#include "util.h"
    5051#include "var.h"
    51 #include "util.h"
    5252
    5353extern fibril_mutex_t big_lock;
    … …  
    6464static errno_t hr_raid0_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    6565
    66 #define strip_size DATA_XFER_LIMIT
    67 
    6866static bd_ops_t hr_raid0_bd_ops = {
    6967        .open = hr_raid0_bd_open,
    … …  
    8078{
    8179        uint64_t N = vol->dev_no; /* extents */
    82         uint64_t L = strip_size / vol->bsize; /* size of strip in blocks */
     80        uint64_t L = HR_STRIP_SIZE / vol->bsize; /* size of strip in blocks */
    8381
    8482        uint64_t i = (x / L) % N; /* extent */
    … …  
    114112        while (left != 0) {
    115113                raid0_geometry(ba++, vol, &extent, &phys_block);
     114                rc = hr_calc_ba(vol, cnt, &ba);
     115                if (rc != EOK)
     116                        break;
    116117                rc = block_sync_cache(vol->devs[extent], phys_block, 1);
    117118                if (rc != EOK)
    … …  
    140141        while (left != 0) {
    141142                raid0_geometry(ba++, vol, &extent, &phys_block);
     143                rc = hr_calc_ba(vol, cnt, &ba);
     144                if (rc != EOK)
     145                        break;
    142146                rc = block_read_direct(vol->devs[extent], phys_block, 1, buf);
    143147                buf = buf + vol->bsize;
    … …  
    167171        while (left != 0) {
    168172                raid0_geometry(ba++, vol, &extent, &phys_block);
     173                rc = hr_calc_ba(vol, cnt, &phys_block);
     174                if (rc != EOK)
     175                        break;
    169176                rc = block_write_direct(vol->devs[extent], phys_block, 1, data);
    170177                data = data + vol->bsize;
    … …  
    190197        hr_volume_t *vol = bd->srvs->sarg;
    191198
    192         *rnb = vol->nblocks;
     199        *rnb = vol->data_blkno;
    193200        return EOK;
    194201}
    … …  
    196203errno_t hr_raid0_create(hr_volume_t *new_volume)
    197204{
     205        errno_t rc;
     206
    198207        assert(new_volume->level == hr_l_0);
    199208
    … …  
    204213        }
    205214
    206         errno_t rc;
    207         size_t i, bsize, last_bsize;
    208         uint64_t nblocks, last_nblocks;
    209         uint64_t total_blocks = 0;
    210 
    211         rc = hr_init_devs(new_volume);
    212         if (rc != EOK)
    213                 return rc;
    214 
    215         for (i = 0; i < new_volume->dev_no; i++) {
    216                 rc = block_get_nblocks(new_volume->devs[i], &nblocks);
    217                 if (rc != EOK)
    218                         goto error;
    219                 if (i != 0 && nblocks != last_nblocks) {
    220                         log_msg(LOG_DEFAULT, LVL_ERROR,
    221                             "number of blocks differs");
    222                         rc = EINVAL;
    223                         goto error;
    224                 }
    225                 total_blocks += nblocks;
    226                 last_nblocks = nblocks;
    227         }
    228 
    229         for (i = 0; i < new_volume->dev_no; i++) {
    230                 rc = block_get_bsize(new_volume->devs[i], &bsize);
    231                 if (rc != EOK)
    232                         goto error;
    233                 if (i != 0 && bsize != last_bsize) {
    234                         log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
    235                         rc = EINVAL;
    236                         goto error;
    237                 }
    238                 last_bsize = bsize;
    239         }
    240 
    241215        bd_srvs_init(&new_volume->hr_bds);
    242216        new_volume->hr_bds.ops = &hr_raid0_bd_ops;
    243217        new_volume->hr_bds.sarg = new_volume;
    244         new_volume->nblocks = total_blocks;
    245         new_volume->bsize = bsize;
    246218
    247219        rc = hr_register_volume(new_volume);
    248220        if (rc != EOK)
    249                 goto error;
    250 
    251         return EOK;
    252 error:
    253         hr_fini_devs(new_volume);
    254         return rc;
     221                return rc;
     222
     223        return EOK;
    255224}
    256225

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

    ree83e9c rb0f1366  
    4747#include <str_error.h>
    4848
     49#include "util.h"
    4950#include "var.h"
    50 #include "util.h"
    5151
    5252extern fibril_mutex_t big_lock;
    … …  
    8585}
    8686
    87 static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t size)
     87static errno_t hr_raid1_bd_sync_cache(bd_srv_t *bd, aoff64_t ba, size_t cnt)
    8888{
    8989        fibril_mutex_lock(&big_lock);
    … …  
    9393        size_t i;
    9494
     95        rc = hr_calc_ba(vol, cnt, &ba);
     96        if (rc != EOK) {
     97                fibril_mutex_unlock(&big_lock);
     98                return rc;
     99        }
     100
    95101        for (i = 0; i < vol->dev_no; i++) {
    96                 rc = block_sync_cache(vol->devs[i], ba, size);
     102                rc = block_sync_cache(vol->devs[i], ba, cnt);
    97103                if (rc != EOK)
    98104                        break;
    … …  
    111117        errno_t rc;
    112118        size_t i;
     119
     120        rc = hr_calc_ba(vol, cnt, &ba);
     121        if (rc != EOK) {
     122                fibril_mutex_unlock(&big_lock);
     123                return rc;
     124        }
    113125
    114126        for (i = 0; i < vol->dev_no; i++) {
    … …  
    131143        size_t i;
    132144
     145        rc = hr_calc_ba(vol, cnt, &ba);
     146        if (rc != EOK) {
     147                fibril_mutex_unlock(&big_lock);
     148                return rc;
     149        }
     150
    133151        for (i = 0; i < vol->dev_no; i++) {
    134152                rc = block_write_direct(vol->devs[i], ba, cnt, data);
    … …  
    153171        hr_volume_t *vol = bd->srvs->sarg;
    154172
    155         *rnb = vol->nblocks;
     173        *rnb = vol->data_blkno;
    156174        return EOK;
    157175}
    … …  
    159177errno_t hr_raid1_create(hr_volume_t *new_volume)
    160178{
     179        errno_t rc;
     180
    161181        assert(new_volume->level == hr_l_1);
    162182
    … …  
    167187        }
    168188
    169         errno_t rc;
    170         size_t i, bsize, last_bsize;
    171         uint64_t nblocks, last_nblocks;
    172         uint64_t total_blocks = 0;
    173 
    174         rc = hr_init_devs(new_volume);
    175         if (rc != EOK)
    176                 return rc;
    177 
    178         for (i = 0; i < new_volume->dev_no; i++) {
    179                 rc = block_get_nblocks(new_volume->devs[i], &nblocks);
    180                 if (rc != EOK)
    181                         goto error;
    182                 if (i != 0 && nblocks != last_nblocks) {
    183                         log_msg(LOG_DEFAULT, LVL_ERROR,
    184                             "number of blocks differs");
    185                         rc = EINVAL;
    186                         goto error;
    187                 }
    188                 total_blocks += nblocks;
    189                 last_nblocks = nblocks;
    190         }
    191 
    192         for (i = 0; i < new_volume->dev_no; i++) {
    193                 rc = block_get_bsize(new_volume->devs[i], &bsize);
    194                 if (rc != EOK)
    195                         goto error;
    196                 if (i != 0 && bsize != last_bsize) {
    197                         log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
    198                         rc = EINVAL;
    199                         goto error;
    200                 }
    201                 last_bsize = bsize;
    202         }
    203 
    204189        bd_srvs_init(&new_volume->hr_bds);
    205190        new_volume->hr_bds.ops = &hr_raid1_bd_ops;
    206191        new_volume->hr_bds.sarg = new_volume;
    207         new_volume->nblocks = total_blocks / new_volume->dev_no;
    208         new_volume->bsize = bsize;
    209192
    210193        rc = hr_register_volume(new_volume);
    211194        if (rc != EOK)
    212                 goto error;
    213 
    214         return EOK;
    215 error:
    216         hr_fini_devs(new_volume);
    217         return rc;
     195                return rc;
     196
     197        return EOK;
    218198}
    219199

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

    ree83e9c rb0f1366  
    4343#include <str_error.h>
    4444
     45#include "util.h"
    4546#include "var.h"
    46 #include "util.h"
    4747
    4848extern loc_srv_t *hr_srv;
    … …  
    8282errno_t hr_register_volume(hr_volume_t *new_volume)
    8383{
     84        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_register_volume()");
     85
    8486        errno_t rc;
    8587        service_id_t new_id;
    … …  
    120122}
    121123
     124errno_t hr_check_devs(hr_volume_t *vol)
     125{
     126        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_check_devs()");
     127
     128        errno_t rc;
     129        size_t i, bsize, last_bsize;
     130        uint64_t nblocks, last_nblocks;
     131        uint64_t total_blocks = 0;
     132
     133        for (i = 0; i < vol->dev_no; i++) {
     134                rc = block_get_nblocks(vol->devs[i], &nblocks);
     135                if (rc != EOK)
     136                        goto error;
     137                if (i != 0 && nblocks != last_nblocks) {
     138                        log_msg(LOG_DEFAULT, LVL_ERROR,
     139                            "number of blocks differs");
     140                        rc = EINVAL;
     141                        goto error;
     142                }
     143                total_blocks += nblocks;
     144                last_nblocks = nblocks;
     145        }
     146
     147        for (i = 0; i < vol->dev_no; i++) {
     148                rc = block_get_bsize(vol->devs[i], &bsize);
     149                if (rc != EOK)
     150                        goto error;
     151                if (i != 0 && bsize != last_bsize) {
     152                        log_msg(LOG_DEFAULT, LVL_ERROR, "block sizes differ");
     153                        rc = EINVAL;
     154                        goto error;
     155                }
     156                last_bsize = bsize;
     157        }
     158
     159        if (vol->level == hr_l_1) {
     160                vol->nblocks = total_blocks / vol->dev_no;
     161        } else if (vol->level == hr_l_0) {
     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
     170error:
     171        return rc;
     172}
     173
     174errno_t hr_calc_ba(hr_volume_t *vol, size_t cnt, uint64_t *ba)
     175{
     176        if (*ba + cnt > vol->data_blkno)
     177                return ERANGE;
     178
     179        *ba = *ba + vol->data_offset;
     180        return EOK;
     181}
     182
    122183/** @}
    123184 */

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

    ree83e9c rb0f1366  
    4444extern void hr_fini_devs(hr_volume_t *);
    4545extern errno_t hr_register_volume(hr_volume_t *);
     46extern errno_t hr_check_devs(hr_volume_t *vol);
     47errno_t hr_calc_ba(hr_volume_t *vol, size_t cnt, uint64_t *ba);
    4648
    4749#endif

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

    ree83e9c rb0f1366  
    4343#define NAME "hr"
    4444
     45#define HR_STRIP_SIZE DATA_XFER_LIMIT
     46
    4547typedef struct hr_volume hr_volume_t;
    4648
    … …  
    5658        service_id_t devs[HR_MAXDEVS];
    5759        uint64_t nblocks;
     60        uint64_t data_blkno;
     61        uint32_t data_offset;
     62        service_id_t svc_id;
    5863        size_t bsize;
    59         service_id_t svc_id;
    6064        size_t dev_no;
    6165        hr_level_t level;
Note: See TracChangeset for help on using the changeset viewer.