Changeset b81ae12 in mainline

Timestamp:

2025-06-29T16:27:35Z (3 months ago)

Author:

Miroslav Cimerman <mc@…>

Children:

7ef5ea2

Parents:

4a77540

Message:

hr: softraid metadata saving support

File:

• uspace/srv/bd/hr/metadata/foreign/softraid/hr_softraid.c (modified) (10 diffs)

uspace/srv/bd/hr/metadata/foreign/softraid/hr_softraid.c

@@ -56 +56 @@
 /* not exposed */
 static void *meta_softraid_alloc_struct(void);
-/* static void meta_softraid_encode(void *, void *); */
+static void meta_softraid_encode(void *, void *);
 static errno_t meta_softraid_decode(const void *, void *);
 static errno_t meta_softraid_get_block(service_id_t, void **);
-/* static errno_t meta_softraid_write_block(service_id_t, const void *); */
+static errno_t meta_softraid_write_block(service_id_t, const void *);
 
 static errno_t meta_softraid_probe(service_id_t, void **);
@@ -182 +182 @@
         memcpy(vol->in_mem_md, main_meta, SR_META_SIZE * DEV_BSIZE);
 
+        bool rebuild = false;
         list_foreach(*list, link, struct dev_list_member, iter) {
                 struct sr_metadata *iter_meta = iter->md;
@@ -191 +192 @@
 
                 struct sr_meta_chunk *mc =
-                    (struct sr_meta_chunk *)(main_meta + 1);
-                mc += index;
-
-                /* for now no ssd_rebuild handling for saved REBUILD */
-                if (iter_meta->ssd_ondisk == max_counter_val &&
-                    mc->scm_status != BIOC_SDREBUILD)
+                    ((struct sr_meta_chunk *)(main_meta + 1)) + index;
+
+                bool invalidate = false;
+
+                if (iter_meta->ssd_meta_flags & SR_META_DIRTY)
+                        invalidate = true;
+                if (iter_meta->ssd_ondisk != max_counter_val)
+                        invalidate = true;
+
+                if (mc->scm_status == BIOC_SDREBUILD && !invalidate) {
+                        if (rebuild) {
+                                HR_DEBUG("only 1 rebuilt extent allowed");
+                                rc = EINVAL;
+                                goto error;
+                        }
+                        rebuild = true;
+                        vol->rebuild_blk = iter_meta->ssd_rebuild;
+                }
+
+                if (!rebuild && !invalidate)
                         vol->extents[index].state = HR_EXT_ONLINE;
+                else if (rebuild && !invalidate)
+                        vol->extents[index].state = HR_EXT_REBUILD;
                 else
                         vol->extents[index].state = HR_EXT_INVALID;
@@ -224 +241 @@
         const struct sr_metadata *m1 = m1_v;
         const struct sr_metadata *m2 = m2_v;
-        if (memcmp(&m1->ssdi.ssd_uuid, &m2->ssdi.ssd_uuid,
-            SR_UUID_MAX) == 0)
+        if (memcmp(&m1->ssdi.ssd_uuid, &m2->ssdi.ssd_uuid, SR_UUID_MAX) == 0)
                 return true;
 
@@ -246 +262 @@
         HR_DEBUG("%s()", __func__);
 
-        return ENOTSUP;
+        fibril_rwlock_read_lock(&vol->extents_lock);
+
+        for (size_t i = 0; i < vol->extent_no; i++)
+                meta_softraid_save_ext(vol, i, with_state_callback);
+
+        fibril_rwlock_read_unlock(&vol->extents_lock);
+
+        return EOK;
 }
 
@@ -254 +277 @@
         HR_DEBUG("%s()", __func__);
 
-        return ENOTSUP;
+        assert(fibril_rwlock_is_locked(&vol->extents_lock));
+
+        void *md_block = hr_calloc_waitok(1, vol->bsize * SR_META_SIZE);
+
+        struct sr_metadata *md = vol->in_mem_md;
+        struct sr_meta_chunk *mc =
+            ((struct sr_meta_chunk *)(md + 1)) + ext_idx;
+
+        hr_extent_t *ext = &vol->extents[ext_idx];
+
+        fibril_rwlock_read_lock(&vol->states_lock);
+        hr_ext_state_t s = ext->state;
+        fibril_rwlock_read_unlock(&vol->states_lock);
+
+        if (s != HR_EXT_ONLINE && s != HR_EXT_REBUILD) {
+                return EINVAL;
+        }
+
+        fibril_mutex_lock(&vol->md_lock);
+
+        if (s == HR_EXT_REBUILD) {
+                md->ssd_rebuild = vol->rebuild_blk;
+                mc->scm_status = BIOC_SDREBUILD;
+        } else {
+                md->ssd_rebuild = 0;
+                mc->scm_status = BIOC_SDONLINE;
+        }
+
+        meta_softraid_encode(md, md_block);
+        errno_t rc = meta_softraid_write_block(ext->svc_id, md_block);
+        if (rc != EOK && with_state_callback)
+                vol->hr_ops.ext_state_cb(vol, ext_idx, rc);
+
+        fibril_mutex_unlock(&vol->md_lock);
+
+        if (with_state_callback)
+                vol->hr_ops.vol_state_eval(vol);
+
+        free(md_block);
+        return EOK;
 }
 
@@ -316 +378 @@
 }
 
-#if 0
 static void meta_softraid_encode(void *md_v, void *block)
 {
         HR_DEBUG("%s()", __func__);
 
-        (void)md_v;
-        (void)block;
-}
-#endif
+        errno_t rc = EOK;
+        struct sr_metadata *md = md_v;
+        uint8_t md5_hash[16];
+
+        struct sr_metadata *scratch_md =
+            hr_calloc_waitok(1, SR_META_SIZE * DEV_BSIZE);
+
+        scratch_md->ssdi.ssd_magic = host2uint64_t_le(md->ssdi.ssd_magic);
+        scratch_md->ssdi.ssd_version = host2uint32_t_le(md->ssdi.ssd_version);
+        scratch_md->ssdi.ssd_vol_flags =
+            host2uint32_t_le(md->ssdi.ssd_vol_flags);
+        memcpy(&scratch_md->ssdi.ssd_uuid, &md->ssdi.ssd_uuid, SR_UUID_MAX);
+        scratch_md->ssdi.ssd_chunk_no =
+            host2uint32_t_le(md->ssdi.ssd_chunk_no);
+        scratch_md->ssdi.ssd_chunk_id =
+            host2uint32_t_le(md->ssdi.ssd_chunk_id);
+        scratch_md->ssdi.ssd_opt_no = host2uint32_t_le(md->ssdi.ssd_opt_no);
+        scratch_md->ssdi.ssd_secsize = host2uint32_t_le(md->ssdi.ssd_secsize);
+        scratch_md->ssdi.ssd_volid = host2uint32_t_le(md->ssdi.ssd_volid);
+        scratch_md->ssdi.ssd_level = host2uint32_t_le(md->ssdi.ssd_level);
+        scratch_md->ssdi.ssd_size = host2int64_t_le(md->ssdi.ssd_size);
+        memcpy(scratch_md->ssdi.ssd_vendor, md->ssdi.ssd_vendor, 8);
+        memcpy(scratch_md->ssdi.ssd_product, md->ssdi.ssd_product, 16);
+        memcpy(scratch_md->ssdi.ssd_revision, md->ssdi.ssd_revision, 4);
+        scratch_md->ssdi.ssd_strip_size =
+            host2uint32_t_le(md->ssdi.ssd_strip_size);
+        rc = create_hash((const uint8_t *)&scratch_md->ssdi,
+            sizeof(struct sr_meta_invariant), md5_hash, HASH_MD5);
+        assert(rc == EOK);
+        memcpy(scratch_md->ssd_checksum, md5_hash, MD5_DIGEST_LENGTH);
+
+        memcpy(scratch_md->ssd_devname, md->ssd_devname, 32);
+
+        scratch_md->ssd_meta_flags = host2uint32_t_le(md->ssd_meta_flags);
+        scratch_md->ssd_data_blkno = host2uint32_t_le(md->ssd_data_blkno);
+        scratch_md->ssd_ondisk = host2uint64_t_le(md->ssd_ondisk);
+        scratch_md->ssd_rebuild = host2int64_t_le(md->ssd_rebuild);
+
+        struct sr_meta_chunk *scratch_mc =
+            (struct sr_meta_chunk *)(scratch_md + 1);
+        struct sr_meta_chunk *mc = (struct sr_meta_chunk *)(md + 1);
+        for (size_t i = 0; i < md->ssdi.ssd_chunk_no; i++, mc++, scratch_mc++) {
+                scratch_mc->scmi.scm_volid =
+                    host2uint32_t_le(mc->scmi.scm_volid);
+                scratch_mc->scmi.scm_chunk_id =
+                    host2uint32_t_le(mc->scmi.scm_chunk_id);
+                memcpy(scratch_mc->scmi.scm_devname, mc->scmi.scm_devname, 32);
+                scratch_mc->scmi.scm_size = host2int64_t_le(mc->scmi.scm_size);
+                scratch_mc->scmi.scm_coerced_size =
+                    host2int64_t_le(mc->scmi.scm_coerced_size);
+                memcpy(&scratch_mc->scmi.scm_uuid, &mc->scmi.scm_uuid,
+                    SR_UUID_MAX);
+
+                rc = create_hash((const uint8_t *)&scratch_mc->scmi,
+                    sizeof(struct sr_meta_chunk_invariant), md5_hash, HASH_MD5);
+                assert(rc == EOK);
+
+                memcpy(scratch_mc->scm_checksum, md5_hash,
+                    MD5_DIGEST_LENGTH);
+                scratch_mc->scm_status = host2uint32_t_le(mc->scm_status);
+        }
+
+        struct sr_meta_opt_hdr *scratch_om =
+            (struct sr_meta_opt_hdr *)((u_int8_t *)(scratch_md + 1) +
+            sizeof(struct sr_meta_chunk) * md->ssdi.ssd_chunk_no);
+        struct sr_meta_opt_hdr *om =
+            (struct sr_meta_opt_hdr *)((u_int8_t *)(md + 1) +
+            sizeof(struct sr_meta_chunk) * md->ssdi.ssd_chunk_no);
+        for (size_t i = 0; i < md->ssdi.ssd_opt_no; i++) {
+                scratch_om->som_type = host2uint32_t_le(om->som_type);
+                scratch_om->som_length = host2uint32_t_le(om->som_length);
+                memcpy(scratch_om->som_checksum, om->som_checksum,
+                    MD5_DIGEST_LENGTH);
+
+                /*
+                 * No need to do checksum, we don't support optional headers.
+                 * Despite this, still load it the headers.
+                 */
+
+                om = (struct sr_meta_opt_hdr *)((void *)om +
+                    om->som_length);
+                scratch_om = (struct sr_meta_opt_hdr *)((void *)scratch_om +
+                    om->som_length);
+        }
+
+        memcpy(block, scratch_md, meta_softraid_get_size() * 512);
+
+        free(scratch_md);
+}
 
 static errno_t meta_softraid_decode(const void *block, void *md_v)
@@ -396 +542 @@
         memcpy(md->ssd_devname, scratch_md->ssd_devname, 32);
         md->ssd_meta_flags = uint32_t_le2host(scratch_md->ssd_meta_flags);
-        if (md->ssd_meta_flags & SR_META_DIRTY) {
-                HR_DEBUG("dirty metadata not supported\n");
-                rc = EINVAL;
-                goto error;
-        }
         md->ssd_data_blkno = uint32_t_le2host(scratch_md->ssd_data_blkno);
         md->ssd_ondisk = uint64_t_le2host(scratch_md->ssd_ondisk);
@@ -514 +655 @@
 }
 
-#if 0
 static errno_t meta_softraid_write_block(service_id_t dev, const void *block)
 {
@@ -541 +681 @@
         return rc;
 }
-#endif
 
 /** @}