Changeset 5b320ac in mainline for uspace/srv

Timestamp:

2024-11-22T18:38:49Z (11 months ago)

Author:

Miroslav Cimerman <mc@…>

Children:

d0f0744

Parents:

06f2762

Message:

hr: hotspares + RAID1 rebuild

Location:

uspace/srv/bd/hr

Files:

• hr.c (modified) (4 diffs)
• raid1.c (modified) (6 diffs)
• var.h (modified) (3 diffs)

uspace/srv/bd/hr/hr.c

@@ -191 +191 @@
                 new_volume->hr_ops.init = hr_raid1_init;
                 new_volume->hr_ops.status_event = hr_raid1_status_event;
+                new_volume->hr_ops.add_hotspare = hr_raid1_add_hotspare;
                 break;
         case HR_LVL_0:
@@ -287 +288 @@
 }
 
+static void hr_add_hotspare_srv(ipc_call_t *icall)
+{
+        HR_DEBUG("hr_add_hotspare()\n");
+
+        errno_t rc = EOK;
+        service_id_t vol_svc_id;
+        service_id_t hotspare;
+        hr_volume_t *vol;
+
+        vol_svc_id = ipc_get_arg1(icall);
+        hotspare = ipc_get_arg2(icall);
+
+        vol = hr_get_volume(vol_svc_id);
+        if (vol == NULL) {
+                async_answer_0(icall, ENOENT);
+                return;
+        }
+
+        if (vol->hr_ops.add_hotspare == NULL) {
+                HR_DEBUG("hr_add_hotspare(): not supported on RAID level %d\n",
+                    vol->level);
+                async_answer_0(icall, ENOTSUP);
+                return;
+        }
+
+        rc = vol->hr_ops.add_hotspare(vol, hotspare);
+
+        async_answer_0(icall, rc);
+}
+
 static void hr_print_status_srv(ipc_call_t *icall)
 {
@@ -318 +349 @@
                 memcpy(info.extents, vol->extents,
                     sizeof(hr_extent_t) * HR_MAX_EXTENTS);
+                memcpy(info.hotspares, vol->hotspares,
+                    sizeof(hr_extent_t) * HR_MAX_HOTSPARES);
                 info.svc_id = vol->svc_id;
                 info.extent_no = vol->dev_no;
+                info.hotspare_no = vol->hotspare_no;
                 info.level = vol->level;
                 /* print usable number of blocks */
@@ -377 +411 @@
                         hr_stop_srv(&call);
                         break;
+                case HR_ADD_HOTSPARE:
+                        hr_add_hotspare_srv(&call);
+                        break;
                 case HR_STATUS:
                         hr_print_status_srv(&call);

uspace/srv/bd/hr/raid1.c

@@ -58 +58 @@
 static errno_t hr_raid1_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
     void *, const void *, size_t);
+static errno_t hr_raid1_rebuild(void *);
 
 /* bdops */
@@ -132 +133 @@
 }
 
+errno_t hr_raid1_add_hotspare(hr_volume_t *vol, service_id_t hotspare)
+{
+        HR_DEBUG("hr_raid1_add_hotspare()\n");
+
+        fibril_mutex_lock(&vol->lock);
+
+        if (vol->hotspare_no >= HR_MAX_HOTSPARES) {
+                HR_ERROR("hr_raid1_add_hotspare(): cannot add more hotspares "
+                    "to \"%s\"\n", vol->devname);
+                fibril_mutex_unlock(&vol->lock);
+                return ELIMIT;
+        }
+
+        vol->hotspares[vol->hotspare_no].svc_id = hotspare;
+        vol->hotspares[vol->hotspare_no].status = HR_EXT_HOTSPARE;
+        vol->hotspare_no++;
+
+        /*
+         * If the volume is degraded, start rebuild right away.
+         */
+        if (vol->status == HR_VOL_DEGRADED) {
+                HR_DEBUG("hr_raid1_add_hotspare(): volume in DEGRADED state, "
+                    "spawning new rebuild fibril\n");
+                fid_t fib = fibril_create(hr_raid1_rebuild, vol);
+                if (fib == 0)
+                        return EINVAL;
+                fibril_start(fib);
+                fibril_detach(fib);
+        }
+
+        fibril_mutex_unlock(&vol->lock);
+
+        return EOK;
+}
+
 static errno_t hr_raid1_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
 {
@@ -180 +216 @@
 {
         if (vol->status == HR_VOL_ONLINE ||
-            vol->status == HR_VOL_DEGRADED)
+            vol->status == HR_VOL_DEGRADED ||
+            vol->status == HR_VOL_REBUILD)
                 return EOK;
         return EINVAL;
@@ -192 +229 @@
 {
         hr_vol_status_t old_state = vol->status;
-        size_t healthy = 0;
-        for (size_t i = 0; i < vol->dev_no; i++)
-                if (vol->extents[i].status == HR_EXT_ONLINE)
-                        healthy++;
+        size_t healthy = hr_count_extents(vol, HR_EXT_ONLINE);
 
         if (healthy == 0) {
@@ -206 +240 @@
                 return EINVAL;
         } else if (healthy < vol->dev_no) {
-                if (old_state != HR_VOL_DEGRADED) {
+                if (old_state != HR_VOL_DEGRADED &&
+                    old_state != HR_VOL_REBUILD) {
                         HR_WARN("RAID 1 array \"%s\" (%lu) has some "
-                            "inactive extent(s), marking volume as DEGRADED",
+                            "unusable extent(s), marking volume as DEGRADED",
                             vol->devname, vol->svc_id);
                         vol->status = HR_VOL_DEGRADED;
+                        if (vol->hotspare_no > 0) {
+                                fid_t fib = fibril_create(hr_raid1_rebuild,
+                                    vol);
+                                if (fib == 0) {
+                                        return EINVAL;
+                                }
+                                fibril_start(fib);
+                                fibril_detach(fib);
+                        }
                 }
                 return EOK;
@@ -309 +353 @@
 }
 
+/*
+ * Put the last HOTSPARE extent in place
+ * of first DEGRADED, and start the rebuild.
+ */
+static errno_t hr_raid1_rebuild(void *arg)
+{
+        HR_DEBUG("hr_raid1_rebuild()\n");
+
+        hr_volume_t *vol = arg;
+        void *buf = NULL;
+        errno_t rc = EOK;
+
+        fibril_mutex_lock(&vol->lock);
+
+        if (vol->hotspare_no == 0) {
+                HR_WARN("hr_raid1_rebuild(): no free hotspares on \"%s\", "
+                    "aborting rebuild\n", vol->devname);
+                /* retval isn't checked for now */
+                goto end;
+        }
+
+        size_t bad = vol->dev_no;
+        for (size_t i = 0; i < vol->dev_no; i++) {
+                if (vol->extents[i].status == HR_EXT_FAILED) {
+                        bad = i;
+                        break;
+                }
+        }
+
+        if (bad == vol->dev_no) {
+                HR_WARN("hr_raid1_rebuild(): no bad extent on \"%s\", "
+                    "aborting rebuild\n", vol->devname);
+                /* retval isn't checked for now */
+                goto end;
+        }
+
+        block_fini(vol->extents[bad].svc_id);
+
+        size_t hotspare_idx = vol->hotspare_no - 1;
+
+        vol->extents[bad].svc_id = vol->hotspares[hotspare_idx].svc_id;
+        hr_update_ext_status(vol, bad, HR_EXT_REBUILD);
+
+        vol->hotspares[hotspare_idx].svc_id = 0;
+        vol->hotspares[hotspare_idx].status = HR_EXT_MISSING;
+        vol->hotspare_no--;
+
+        HR_WARN("hr_raid1_rebuild(): changing volume \"%s\" (%lu) state "
+            "from %s to %s\n", vol->devname, vol->svc_id,
+            hr_get_vol_status_msg(vol->status),
+            hr_get_vol_status_msg(HR_VOL_REBUILD));
+        vol->status = HR_VOL_REBUILD;
+
+        hr_extent_t *hotspare = &vol->extents[bad];
+
+        HR_DEBUG("hr_raid1_rebuild(): initing (%lu)\n", hotspare->svc_id);
+
+        rc = block_init(hotspare->svc_id);
+        if (rc != EOK) {
+                HR_ERROR("hr_raid1_rebuild(): initing (%lu) failed, "
+                    "aborting rebuild\n", hotspare->svc_id);
+                goto end;
+        }
+
+        size_t left = vol->data_blkno;
+        size_t max_blks = DATA_XFER_LIMIT / vol->bsize;
+        buf = malloc(max_blks * vol->bsize);
+
+        hr_extent_t *ext;
+        size_t rebuild_ext_idx = bad;
+
+        size_t cnt;
+        uint64_t ba = 0;
+        hr_add_ba_offset(vol, &ba);
+        while (left != 0) {
+                cnt = min(max_blks, left);
+                for (size_t i = 0; i < vol->dev_no; i++) {
+                        ext = &vol->extents[i];
+                        if (ext->status == HR_EXT_ONLINE) {
+                                rc = block_read_direct(ext->svc_id, ba, cnt,
+                                    buf);
+                                if (rc != EOK) {
+                                        handle_extent_error(vol, i, rc);
+                                        if (i + 1 < vol->dev_no) {
+                                                /* still might have one ONLINE */
+                                                continue;
+                                        } else {
+                                                HR_ERROR("rebuild on \"%s\" (%lu), failed due to "
+                                                    "too many failed extents\n",
+                                                    vol->devname, vol->svc_id);
+                                                goto end;
+                                        }
+                                }
+                                break;
+                        }
+                }
+
+                rc = block_write_direct(hotspare->svc_id, ba, cnt, buf);
+                if (rc != EOK) {
+                        handle_extent_error(vol, rebuild_ext_idx, rc);
+                        HR_ERROR("rebuild on \"%s\" (%lu), extent number %lu\n",
+                            vol->devname, vol->svc_id, rebuild_ext_idx);
+                        goto end;
+
+                }
+
+                ba += cnt;
+                left -= cnt;
+        }
+
+        HR_DEBUG("hr_raid1_rebuild(): rebuild finished on \"%s\" (%lu), "
+            "extent number %lu\n", vol->devname, vol->svc_id, hotspare_idx);
+
+        hr_update_ext_status(vol, hotspare_idx, HR_EXT_ONLINE);
+        /*
+         * For now write metadata at the end, because
+         * we don't sync metada accross extents yet.
+         */
+        hr_write_meta_to_ext(vol, bad);
+end:
+        (void) hr_raid1_update_vol_status(vol);
+
+        fibril_mutex_unlock(&vol->lock);
+
+        if (buf != NULL)
+                free(buf);
+
+        /* retval isn't checked anywhere for now */
+        return rc;
+}
+
 /** @}
  */

uspace/srv/bd/hr/var.h

@@ -51 +51 @@
         errno_t (*init)(hr_volume_t *);
         void    (*status_event)(hr_volume_t *);
+        errno_t (*add_hotspare)(hr_volume_t *, service_id_t);
 } hr_ops_t;
 
@@ -56 +57 @@
         hr_ops_t hr_ops;
         bd_srvs_t hr_bds;
+
         link_t lvolumes;
         fibril_mutex_t lock;
-        char devname[HR_DEVNAME_LEN];
+
+        size_t dev_no;
         hr_extent_t extents[HR_MAX_EXTENTS];
+
+        size_t hotspare_no;
+        hr_extent_t hotspares[HR_MAX_EXTENTS];
+
+        size_t bsize;
         uint64_t nblocks;
         uint64_t data_blkno;
         uint32_t data_offset; /* in blocks */
         uint32_t strip_size;
+
         service_id_t svc_id;
-        size_t bsize;
-        size_t dev_no;
+        hr_vol_status_t status;
         hr_level_t level;
-        hr_vol_status_t status;
+        char devname[HR_DEVNAME_LEN];
 } hr_volume_t;
 
@@ -95 +103 @@
 extern void hr_raid5_status_event(hr_volume_t *);
 
+extern errno_t hr_raid1_add_hotspare(hr_volume_t *, service_id_t);
+
 #endif