Changeset 9c1cf34c in mainline


Ignore:
Timestamp:
2024-09-06T12:14:09Z (8 months ago)
Author:
Miroslav Cimerman <mc@…>
Children:
24968b5
Parents:
b0f1366
Message:

hr: add strip size to metadata and hr_volume_t

Location:
uspace
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/device/include/hr.h

    rb0f1366 r9c1cf34c  
    6969        hr_level_t level;
    7070        uint64_t nblocks;
     71        uint32_t strip_size;
    7172        size_t bsize;
    7273} hr_vol_info_t;

  • uspace/lib/device/src/hr.c

    rb0f1366 r9c1cf34c  
    157157
    158158        printf("level: %d\n", vol_info->level);
    159         printf("nblocks: %lu\n", vol_info->nblocks);
    160         printf("bsize: %zu\n", vol_info->bsize);
     159        if (vol_info->level == hr_l_0) {
     160                if (vol_info->strip_size / 1024 < 1)
     161                        printf("strip size in bytes: %u\n",
     162                            vol_info->strip_size);
     163                else
     164                        printf("strip size: %uK\n",
     165                            vol_info->strip_size / 1024);
     166        }
     167        printf("size in bytes: %luMiB\n",
     168            vol_info->nblocks * vol_info->bsize / 1024 / 1024);
     169        printf("size in blocks: %lu\n", vol_info->nblocks);
     170        printf("block size: %zu\n", vol_info->bsize);
     171
    161172
    162173        printf("extents: [index] [devname]\n");

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

    rb0f1366 r9c1cf34c  
    6161static service_id_t ctl_sid;
    6262
    63 
    6463static void hr_create_srv(ipc_call_t *icall)
    6564{
    … …  
    121120                goto error;
    122121
     122        switch (new_volume->level) {
     123        case hr_l_1:
     124                new_volume->hr_ops.create = hr_raid1_create;
     125                new_volume->strip_size = 0;
     126                break;
     127        case hr_l_0:
     128                new_volume->hr_ops.create = hr_raid0_create;
     129                new_volume->strip_size = HR_STRIP_SIZE;
     130                break;
     131        default:
     132                log_msg(LOG_DEFAULT, LVL_ERROR,
     133                    "level %d not implemented yet", new_volume->level);
     134                rc = EINVAL;
     135                goto error;
     136        }
     137
    123138        rc = hr_write_meta_to_vol(new_volume);
     139        if (rc != EOK)
     140                goto error;
     141
     142        rc = new_volume->hr_ops.create(new_volume);
     143        if (rc != EOK)
     144                goto error;
     145
     146        fibril_mutex_lock(&hr_volumes_lock);
     147        list_append(&new_volume->lvolumes, &hr_volumes);
     148        fibril_mutex_unlock(&hr_volumes_lock);
     149
     150        log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")",
     151            new_volume->devname, new_volume->svc_id);
     152
     153        free(cfg);
     154        async_answer_0(icall, rc);
     155        return;
     156error:
     157        free(cfg);
     158        hr_fini_devs(new_volume);
     159        async_answer_0(icall, rc);
     160}
     161
     162static void hr_assemble_srv(ipc_call_t *icall)
     163{
     164        log_msg(LOG_DEFAULT, LVL_NOTE, "hr_assemble_srv()");
     165
     166        errno_t rc;
     167        size_t size;
     168        hr_config_t *cfg;
     169        hr_volume_t *new_volume;
     170        ipc_call_t call;
     171
     172        if (!async_data_write_receive(&call, &size)) {
     173                async_answer_0(&call, EREFUSED);
     174                async_answer_0(icall, EREFUSED);
     175                return;
     176        }
     177
     178        if (size != sizeof(hr_config_t)) {
     179                async_answer_0(&call, EINVAL);
     180                async_answer_0(icall, EINVAL);
     181                return;
     182        }
     183
     184        cfg = calloc(1, sizeof(hr_config_t));
     185        if (cfg == NULL) {
     186                async_answer_0(&call, ENOMEM);
     187                async_answer_0(icall, ENOMEM);
     188                return;
     189        }
     190
     191        rc = async_data_write_finalize(&call, cfg, size);
     192        if (rc != EOK) {
     193                async_answer_0(&call, rc);
     194                async_answer_0(icall, rc);
     195                return;
     196        }
     197
     198        new_volume = calloc(1, sizeof(hr_volume_t));
     199        if (new_volume == NULL) {
     200                free(cfg);
     201                async_answer_0(icall, ENOMEM);
     202                return;
     203        }
     204
     205        str_cpy(new_volume->devname, 32, cfg->devname);
     206        memcpy(new_volume->devs, cfg->devs, sizeof(service_id_t) * HR_MAXDEVS);
     207        new_volume->dev_no = cfg->dev_no;
     208
     209        if (cfg->level != hr_l_empty)
     210                log_msg(LOG_DEFAULT, LVL_WARN,
     211                    "level manually set when assembling, ingoring");
     212
     213        new_volume->level = hr_l_empty;
     214
     215        rc = hr_init_devs(new_volume);
     216        if (rc != EOK) {
     217                free(cfg);
     218                async_answer_0(icall, rc);
     219                return;
     220        }
     221
     222        rc = hr_check_devs(new_volume);
     223        if (rc != EOK)
     224                goto error;
     225
     226        rc = hr_get_vol_from_meta(cfg, new_volume);
    124227        if (rc != EOK)
    125228                goto error;
    … …  
    147250        fibril_mutex_unlock(&hr_volumes_lock);
    148251
    149         log_msg(LOG_DEFAULT, LVL_NOTE, "created volume \"%s\" (%" PRIun ")",
    150             new_volume->devname, new_volume->svc_id);
    151 
    152         free(cfg);
    153         async_answer_0(icall, rc);
    154         return;
    155 error:
    156         free(cfg);
    157         hr_fini_devs(new_volume);
    158         async_answer_0(icall, rc);
    159 }
    160 
    161 static 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 
    251252        log_msg(LOG_DEFAULT, LVL_NOTE, "assembled volume \"%s\" (%" PRIun ")",
    252253            new_volume->devname, new_volume->svc_id);
    … …  
    297298                /* print usable number of blocks */
    298299                info.nblocks = volume->data_blkno;
     300                info.strip_size = volume->strip_size;
    299301                info.bsize = volume->bsize;
    300302

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

    rb0f1366 r9c1cf34c  
    7878{
    7979        uint64_t N = vol->dev_no; /* extents */
    80         uint64_t L = HR_STRIP_SIZE / vol->bsize; /* size of strip in blocks */
     80        uint64_t L = vol->strip_size / vol->bsize; /* size of strip in blocks */
    8181
    8282        uint64_t i = (x / L) % N; /* extent */

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

    rb0f1366 r9c1cf34c  
    9090        metadata->data_blkno = host2uint64_t_le(data_blkno);
    9191        metadata->data_offset = host2uint32_t_le(data_offset);
     92        metadata->strip_size = host2uint32_t_le(vol->strip_size);
    9293        for (i = 0; i < vol->dev_no; i++) {
    9394                metadata->index = host2uint32_t_le(i);
    … …  
    144145        new_volume->data_blkno = uint64_t_le2host(metadata->data_blkno);
    145146        new_volume->data_offset = uint32_t_le2host(metadata->data_offset);
     147        new_volume->strip_size = uint32_t_le2host(metadata->strip_size);
    146148
    147149        if (str_cmp(metadata->devname, new_volume->devname) != 0) {

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

    rb0f1366 r9c1cf34c  
    4949        uint32_t data_offset;   /* block where data starts */
    5050        uint32_t index;         /* index of disk in array */
     51        uint32_t strip_size;
     52        uint32_t status;        /* yet unused */
    5153        uint8_t uuid[16];
    5254        char devname[32];

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

    rb0f1366 r9c1cf34c  
    6060        uint64_t data_blkno;
    6161        uint32_t data_offset;
     62        uint32_t strip_size;
    6263        service_id_t svc_id;
    6364        size_t bsize;
Note: See TracChangeset for help on using the changeset viewer.