Changeset aa9bad8 in mainline for uspace/srv/bd/hr/metadata/native.c


Ignore:
Timestamp:
2025-06-27T22:21:05Z (10 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
2de7c1f
Parents:
78433bb
git-author:
Miroslav Cimerman <mc@…> (2025-06-27 22:14:37)
git-committer:
Miroslav Cimerman <mc@…> (2025-06-27 22:21:05)
Message:

hr: let each format implement own probe

This will allow metadata to have superblocks in
different locations accross versions.

This also greatly reduces the format handling interface,
because now, functions used by the probing done
publicly in superblock.c are now used just
inside specific metadata format code.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r78433bb raa9bad8  
    5454#include "native.h"
    5555
     56/* not exposed */
    5657static void *meta_native_alloc_struct(void);
    57 static errno_t meta_native_init_vol2meta(hr_volume_t *);
    58 static errno_t meta_native_init_meta2vol(const list_t *, hr_volume_t *);
    5958static void meta_native_encode(void *, void *);
    6059static errno_t meta_native_decode(const void *, void *);
    6160static errno_t meta_native_get_block(service_id_t, void **);
    6261static errno_t meta_native_write_block(service_id_t, const void *);
     62static bool meta_native_has_valid_magic(const void *);
     63
     64static errno_t meta_native_probe(service_id_t, void **);
     65static errno_t meta_native_init_vol2meta(hr_volume_t *);
     66static errno_t meta_native_init_meta2vol(const list_t *, hr_volume_t *);
    6367static errno_t meta_native_erase_block(service_id_t);
    64 static bool meta_native_has_valid_magic(const void *);
    6568static bool meta_native_compare_uuids(const void *, const void *);
    6669static void meta_native_inc_counter(hr_volume_t *);
    … …  
    7679
    7780hr_superblock_ops_t metadata_native_ops = {
    78         .alloc_struct = meta_native_alloc_struct,
     81        .probe = meta_native_probe,
    7982        .init_vol2meta = meta_native_init_vol2meta,
    8083        .init_meta2vol = meta_native_init_meta2vol,
    81         .encode = meta_native_encode,
    82         .decode = meta_native_decode,
    83         .get_block = meta_native_get_block,
    84         .write_block = meta_native_write_block,
    8584        .erase_block = meta_native_erase_block,
    86         .has_valid_magic = meta_native_has_valid_magic,
    8785        .compare_uuids = meta_native_compare_uuids,
    8886        .inc_counter = meta_native_inc_counter,
    … …  
    9896};
    9997
    100 static void *meta_native_alloc_struct(void)
    101 {
    102         return calloc(1, sizeof(hr_metadata_t));
     98static errno_t meta_native_probe(service_id_t svc_id, void **rmd)
     99{
     100        errno_t rc;
     101        void *meta_block;
     102
     103        void *metadata_struct = meta_native_alloc_struct();
     104        if (metadata_struct == NULL)
     105                return ENOMEM;
     106
     107        rc = meta_native_get_block(svc_id, &meta_block);
     108        if (rc != EOK)
     109                goto error;
     110
     111        rc = meta_native_decode(meta_block, metadata_struct);
     112
     113        free(meta_block);
     114
     115        if (rc != EOK)
     116                goto error;
     117
     118        if (!meta_native_has_valid_magic(metadata_struct)) {
     119                rc = ENOFS;
     120                goto error;
     121        }
     122
     123        *rmd = metadata_struct;
     124        return EOK;
     125
     126error:
     127        free(metadata_struct);
     128        return ENOFS;
    103129}
    104130
    … …  
    200226
    201227        return EOK;
     228}
     229
     230static errno_t meta_native_erase_block(service_id_t dev)
     231{
     232        HR_DEBUG("%s()", __func__);
     233
     234        errno_t rc;
     235        size_t bsize;
     236
     237        rc = block_get_bsize(dev, &bsize);
     238        if (rc != EOK)
     239                return rc;
     240
     241        void *zero_block = calloc(1, bsize);
     242        if (zero_block == NULL)
     243                return ENOMEM;
     244
     245        rc = meta_native_write_block(dev, zero_block);
     246        return rc;
     247}
     248
     249static bool meta_native_compare_uuids(const void *m1p, const void *m2p)
     250{
     251        const hr_metadata_t *m1 = m1p;
     252        const hr_metadata_t *m2 = m2p;
     253        if (memcmp(m1->uuid, m2->uuid, HR_NATIVE_UUID_LEN) == 0)
     254                return true;
     255
     256        return false;
     257}
     258
     259static void meta_native_inc_counter(hr_volume_t *vol)
     260{
     261        fibril_mutex_lock(&vol->md_lock);
     262
     263        hr_metadata_t *md = vol->in_mem_md;
     264
     265        md->counter++;
     266
     267        fibril_mutex_unlock(&vol->md_lock);
     268}
     269
     270static errno_t meta_native_save(hr_volume_t *vol, bool with_state_callback)
     271{
     272        HR_DEBUG("%s()", __func__);
     273
     274        fibril_rwlock_read_lock(&vol->extents_lock);
     275
     276        for (size_t i = 0; i < vol->extent_no; i++)
     277                meta_native_save_ext(vol, i, with_state_callback);
     278
     279        fibril_rwlock_read_unlock(&vol->extents_lock);
     280
     281        return EOK;
     282}
     283
     284static errno_t meta_native_save_ext(hr_volume_t *vol, size_t ext_idx,
     285    bool with_state_callback)
     286{
     287        HR_DEBUG("%s()", __func__);
     288
     289        assert(fibril_rwlock_is_locked(&vol->extents_lock));
     290
     291        void *md_block = hr_calloc_waitok(1, vol->bsize);
     292
     293        hr_metadata_t *md = (hr_metadata_t *)vol->in_mem_md;
     294
     295        hr_extent_t *ext = &vol->extents[ext_idx];
     296
     297        fibril_rwlock_read_lock(&vol->states_lock);
     298        hr_ext_state_t s = ext->state;
     299        fibril_rwlock_read_unlock(&vol->states_lock);
     300
     301        if (s != HR_EXT_ONLINE && s != HR_EXT_REBUILD) {
     302                return EINVAL;
     303        }
     304
     305        fibril_mutex_lock(&vol->md_lock);
     306
     307        md->index = ext_idx;
     308        if (s == HR_EXT_REBUILD)
     309                md->rebuild_pos = vol->rebuild_blk;
     310        else
     311                md->rebuild_pos = 0;
     312        meta_native_encode(md, md_block);
     313        errno_t rc = meta_native_write_block(ext->svc_id, md_block);
     314        if (rc != EOK && with_state_callback)
     315                vol->hr_ops.ext_state_cb(vol, ext_idx, rc);
     316
     317        fibril_mutex_unlock(&vol->md_lock);
     318
     319        if (with_state_callback)
     320                vol->hr_ops.vol_state_eval(vol);
     321
     322        free(md_block);
     323        return EOK;
     324}
     325
     326static const char *meta_native_get_devname(const void *md_v)
     327{
     328        const hr_metadata_t *md = md_v;
     329
     330        return md->devname;
     331}
     332
     333static hr_level_t meta_native_get_level(const void *md_v)
     334{
     335        const hr_metadata_t *md = md_v;
     336
     337        return md->level;
     338}
     339
     340static uint64_t meta_native_get_data_offset(void)
     341{
     342        return HR_NATIVE_DATA_OFF;
     343}
     344
     345static size_t meta_native_get_size(void)
     346{
     347        return HR_NATIVE_META_SIZE;
     348}
     349
     350static uint8_t meta_native_get_flags(void)
     351{
     352        uint8_t flags = 0;
     353
     354        flags |= HR_METADATA_HOTSPARE_SUPPORT;
     355
     356        return flags;
     357}
     358
     359static hr_metadata_type_t meta_native_get_type(void)
     360{
     361        return HR_METADATA_NATIVE;
     362}
     363
     364static void meta_native_dump(const void *md_v)
     365{
     366        HR_DEBUG("%s()", __func__);
     367
     368        const hr_metadata_t *metadata = md_v;
     369
     370        printf("\tmagic: %s\n", metadata->magic);
     371        printf("\tUUID: ");
     372        for (size_t i = 0; i < HR_NATIVE_UUID_LEN; ++i) {
     373                printf("%.2X", metadata->uuid[i]);
     374                if (i + 1 < HR_NATIVE_UUID_LEN)
     375                        printf(" ");
     376        }
     377        printf("\n");
     378        printf("\tdata_blkno: %" PRIu64 "\n", metadata->data_blkno);
     379        printf("\ttruncated_blkno: %" PRIu64 "\n", metadata->truncated_blkno);
     380        printf("\tcounter: %" PRIu64 "\n", metadata->counter);
     381        printf("\tversion: %" PRIu32 "\n", metadata->version);
     382        printf("\textent_no: %" PRIu32 "\n", metadata->extent_no);
     383        printf("\tindex: %" PRIu32 "\n", metadata->index);
     384        printf("\tlevel: %" PRIu32 "\n", metadata->level);
     385        printf("\tlayout: %" PRIu32 "\n", metadata->layout);
     386        printf("\tstrip_size: %" PRIu32 "\n", metadata->strip_size);
     387        printf("\tbsize: %" PRIu32 "\n", metadata->bsize);
     388        printf("\tdevname: %s\n", metadata->devname);
     389}
     390
     391static void *meta_native_alloc_struct(void)
     392{
     393        return calloc(1, sizeof(hr_metadata_t));
    202394}
    203395
    … …  
    342534}
    343535
    344 static errno_t meta_native_erase_block(service_id_t dev)
    345 {
    346         HR_DEBUG("%s()", __func__);
    347 
    348         errno_t rc;
    349         size_t bsize;
    350 
    351         rc = block_get_bsize(dev, &bsize);
    352         if (rc != EOK)
    353                 return rc;
    354 
    355         void *zero_block = calloc(1, bsize);
    356         if (zero_block == NULL)
    357                 return ENOMEM;
    358 
    359         rc = meta_native_write_block(dev, zero_block);
    360         return rc;
    361 }
    362 
    363536static bool meta_native_has_valid_magic(const void *md_v)
    364537{
    … …  
    373546}
    374547
    375 static bool meta_native_compare_uuids(const void *m1p, const void *m2p)
    376 {
    377         const hr_metadata_t *m1 = m1p;
    378         const hr_metadata_t *m2 = m2p;
    379         if (memcmp(m1->uuid, m2->uuid, HR_NATIVE_UUID_LEN) == 0)
    380                 return true;
    381 
    382         return false;
    383 }
    384 
    385 static void meta_native_inc_counter(hr_volume_t *vol)
    386 {
    387         fibril_mutex_lock(&vol->md_lock);
    388 
    389         hr_metadata_t *md = vol->in_mem_md;
    390 
    391         md->counter++;
    392 
    393         fibril_mutex_unlock(&vol->md_lock);
    394 }
    395 
    396 static errno_t meta_native_save(hr_volume_t *vol, bool with_state_callback)
    397 {
    398         HR_DEBUG("%s()", __func__);
    399 
    400         fibril_rwlock_read_lock(&vol->extents_lock);
    401 
    402         for (size_t i = 0; i < vol->extent_no; i++)
    403                 meta_native_save_ext(vol, i, with_state_callback);
    404 
    405         fibril_rwlock_read_unlock(&vol->extents_lock);
    406 
    407         return EOK;
    408 }
    409 
    410 static errno_t meta_native_save_ext(hr_volume_t *vol, size_t ext_idx,
    411     bool with_state_callback)
    412 {
    413         HR_DEBUG("%s()", __func__);
    414 
    415         assert(fibril_rwlock_is_locked(&vol->extents_lock));
    416 
    417         void *md_block = hr_calloc_waitok(1, vol->bsize);
    418 
    419         hr_metadata_t *md = (hr_metadata_t *)vol->in_mem_md;
    420 
    421         hr_extent_t *ext = &vol->extents[ext_idx];
    422 
    423         fibril_rwlock_read_lock(&vol->states_lock);
    424         hr_ext_state_t s = ext->state;
    425         fibril_rwlock_read_unlock(&vol->states_lock);
    426 
    427         if (s != HR_EXT_ONLINE && s != HR_EXT_REBUILD) {
    428                 return EINVAL;
    429         }
    430 
    431         fibril_mutex_lock(&vol->md_lock);
    432 
    433         md->index = ext_idx;
    434         if (s == HR_EXT_REBUILD)
    435                 md->rebuild_pos = vol->rebuild_blk;
    436         else
    437                 md->rebuild_pos = 0;
    438         meta_native_encode(md, md_block);
    439         errno_t rc = meta_native_write_block(ext->svc_id, md_block);
    440         if (rc != EOK && with_state_callback)
    441                 vol->hr_ops.ext_state_cb(vol, ext_idx, rc);
    442 
    443         fibril_mutex_unlock(&vol->md_lock);
    444 
    445         if (with_state_callback)
    446                 vol->hr_ops.vol_state_eval(vol);
    447 
    448         free(md_block);
    449         return EOK;
    450 }
    451 
    452 static const char *meta_native_get_devname(const void *md_v)
    453 {
    454         const hr_metadata_t *md = md_v;
    455 
    456         return md->devname;
    457 }
    458 
    459 static hr_level_t meta_native_get_level(const void *md_v)
    460 {
    461         const hr_metadata_t *md = md_v;
    462 
    463         return md->level;
    464 }
    465 
    466 static uint64_t meta_native_get_data_offset(void)
    467 {
    468         return HR_NATIVE_DATA_OFF;
    469 }
    470 
    471 static size_t meta_native_get_size(void)
    472 {
    473         return HR_NATIVE_META_SIZE;
    474 }
    475 
    476 static uint8_t meta_native_get_flags(void)
    477 {
    478         uint8_t flags = 0;
    479 
    480         flags |= HR_METADATA_HOTSPARE_SUPPORT;
    481 
    482         return flags;
    483 }
    484 
    485 static hr_metadata_type_t meta_native_get_type(void)
    486 {
    487         return HR_METADATA_NATIVE;
    488 }
    489 
    490 static void meta_native_dump(const void *md_v)
    491 {
    492         HR_DEBUG("%s()", __func__);
    493 
    494         const hr_metadata_t *metadata = md_v;
    495 
    496         printf("\tmagic: %s\n", metadata->magic);
    497         printf("\tUUID: ");
    498         for (size_t i = 0; i < HR_NATIVE_UUID_LEN; ++i) {
    499                 printf("%.2X", metadata->uuid[i]);
    500                 if (i + 1 < HR_NATIVE_UUID_LEN)
    501                         printf(" ");
    502         }
    503         printf("\n");
    504         printf("\tdata_blkno: %" PRIu64 "\n", metadata->data_blkno);
    505         printf("\ttruncated_blkno: %" PRIu64 "\n", metadata->truncated_blkno);
    506         printf("\tcounter: %" PRIu64 "\n", metadata->counter);
    507         printf("\tversion: %" PRIu32 "\n", metadata->version);
    508         printf("\textent_no: %" PRIu32 "\n", metadata->extent_no);
    509         printf("\tindex: %" PRIu32 "\n", metadata->index);
    510         printf("\tlevel: %" PRIu32 "\n", metadata->level);
    511         printf("\tlayout: %" PRIu32 "\n", metadata->layout);
    512         printf("\tstrip_size: %" PRIu32 "\n", metadata->strip_size);
    513         printf("\tbsize: %" PRIu32 "\n", metadata->bsize);
    514         printf("\tdevname: %s\n", metadata->devname);
    515 }
    516 
    517548/** @}
    518549 */
Note: See TracChangeset for help on using the changeset viewer.