Changeset bc3d695 in mainline

Timestamp:

2025-01-05T18:22:28Z (4 months ago)

Author:

Miroslav Cimerman <mc@…>

Children:

7bf29e5

Parents:

40be7eb

Message:

hr: RAID0 parallelization

Location:

uspace/srv/bd/hr

Files:

• hr.c (modified) (6 diffs)
• io.c (added)
• io.h (added)
• meson.build (modified) (2 diffs)
• raid0.c (modified) (10 diffs)
• util.h (modified) (2 diffs)
• var.h (modified) (5 diffs)

uspace/srv/bd/hr/hr.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Miroslav Cimerman
+ * Copyright (c) 2025 Miroslav Cimerman
  * All rights reserved.
  *
@@ -49 +49 @@
 #include <str_error.h>
 
+#include "fge.h"
+#include "io.h"
 #include "superblock.h"
 #include "util.h"
@@ -83 +85 @@
         list_foreach(hr_volumes, lvolumes, hr_volume_t, vol) {
                 if (vol->svc_id == svc_id) {
+                        hr_fpool_destroy(vol->fge);
                         hr_fini_devs(vol);
                         list_remove(&vol->lvolumes);
@@ -154 +157 @@
                 return;
         }
+
+        hr_fpool_t *fge = hr_fpool_create(16, 32, sizeof(hr_io_t));
+        if (fge == NULL) {
+                free(new_volume);
+                free(cfg);
+                async_answer_0(icall, ENOMEM);
+                return;
+        }
+        new_volume->fge = fge;
 
         str_cpy(new_volume->devname, HR_DEVNAME_LEN, cfg->devname);
@@ -234 +246 @@
         }
 
-        fibril_mutex_initialize(&new_volume->lock);
+        fibril_mutex_initialize(&new_volume->lock); /* XXX: will remove this */
+
+        fibril_mutex_initialize(&new_volume->halt_lock);
+        new_volume->halt_please = false;
+
+        fibril_rwlock_initialize(&new_volume->extents_lock);
+        fibril_rwlock_initialize(&new_volume->states_lock);
 
         list_initialize(&new_volume->range_lock_list);
@@ -260 +278 @@
 error:
         free(cfg);
+        free(fge);
         hr_fini_devs(new_volume);
         free(new_volume);

uspace/srv/bd/hr/meson.build

@@ -1 +1 @@
 #
-# Copyright (c) 2024 Miroslav Cimerman
+# Copyright (c) 2025 Miroslav Cimerman
 # All rights reserved.
 #
@@ -31 +31 @@
             'fge.c',
             'hr.c',
+            'io.c',
             'raid0.c',
             'raid1.c',

uspace/srv/bd/hr/raid0.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Miroslav Cimerman
+ * Copyright (c) 2025 Miroslav Cimerman
  * All rights reserved.
  *
@@ -48 +48 @@
 #include <str_error.h>
 
+#include "io.h"
 #include "superblock.h"
 #include "util.h"
@@ -54 +55 @@
 extern loc_srv_t *hr_srv;
 
-static errno_t hr_raid0_check_vol_status(hr_volume_t *);
 static errno_t hr_raid0_update_vol_status(hr_volume_t *);
 static errno_t hr_raid0_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
@@ -95 +95 @@
                 return rc;
 
+        hr_update_vol_status(new_volume, HR_VOL_ONLINE);
+
         bd_srvs_init(&new_volume->hr_bds);
         new_volume->hr_bds.ops = &hr_raid0_bd_ops;
@@ -127 +129 @@
 void hr_raid0_status_event(hr_volume_t *vol)
 {
-        fibril_mutex_lock(&vol->lock);
         (void)hr_raid0_update_vol_status(vol);
-        fibril_mutex_unlock(&vol->lock);
 }
 
@@ -175 +175 @@
         *rnb = vol->data_blkno;
         return EOK;
-}
-
-static errno_t hr_raid0_check_vol_status(hr_volume_t *vol)
-{
-        if (vol->status == HR_VOL_ONLINE)
-                return EOK;
-        return EIO;
 }
 
@@ -190 +183 @@
 static errno_t hr_raid0_update_vol_status(hr_volume_t *vol)
 {
+        fibril_rwlock_read_lock(&vol->states_lock);
         hr_vol_status_t old_state = vol->status;
 
         for (size_t i = 0; i < vol->extent_no; i++) {
                 if (vol->extents[i].status != HR_EXT_ONLINE) {
+                        fibril_rwlock_read_unlock(&vol->states_lock);
+                        fibril_rwlock_write_lock(&vol->states_lock);
                         if (old_state != HR_VOL_FAULTY)
                                 hr_update_vol_status(vol, HR_VOL_FAULTY);
+                        fibril_rwlock_write_unlock(&vol->states_lock);
                         return EIO;
                 }
         }
-
-        if (old_state != HR_VOL_ONLINE)
-                hr_update_vol_status(vol, HR_VOL_ONLINE);
-
-        return EOK;
+        fibril_rwlock_read_unlock(&vol->states_lock);
+
+        return EOK;
+}
+
+static void raid0_state_callback(hr_volume_t *vol, size_t extent, errno_t rc)
+{
+        if (rc == EOK)
+                return;
+
+        fibril_rwlock_write_lock(&vol->states_lock);
+
+        switch (rc) {
+        case ENOENT:
+                hr_update_ext_status(vol, extent, HR_EXT_MISSING);
+                break;
+        default:
+                hr_update_ext_status(vol, extent, HR_EXT_FAILED);
+        }
+
+        hr_update_vol_status(vol, HR_VOL_FAULTY);
+
+        fibril_rwlock_write_unlock(&vol->states_lock);
 }
 
@@ -216 +231 @@
         uint8_t *data_read = dst;
 
+        fibril_rwlock_read_lock(&vol->states_lock);
+        if (vol->status != HR_VOL_ONLINE) {
+                fibril_rwlock_read_unlock(&vol->states_lock);
+                return EIO;
+        }
+        fibril_rwlock_read_unlock(&vol->states_lock);
+
         /* propagate sync */
         if (type == HR_BD_SYNC && ba == 0 && cnt == 0) {
-                hr_sync_all_extents(vol);
-                rc = hr_raid0_update_vol_status(vol);
-                return rc;
+                hr_fgroup_t *group = hr_fgroup_create(vol->fge, vol->extent_no);
+
+                for (size_t i = 0; i < vol->extent_no; i++) {
+                        hr_io_t *io = hr_fgroup_alloc(group);
+                        io->extent = i;
+                        io->ba = ba;
+                        io->cnt = cnt;
+                        io->type = type;
+                        io->vol = vol;
+                        io->state_callback = raid0_state_callback;
+
+                        hr_fgroup_submit(group, hr_io_worker, io);
+                }
+
+                size_t bad;
+                (void)hr_fgroup_wait(group, NULL, &bad);
+                if (bad > 0)
+                        return EIO;
+                return EOK;
         }
 
@@ -232 +270 @@
 
         uint64_t strip_size = vol->strip_size / vol->bsize; /* in blocks */
-        uint64_t stripe = ba / strip_size; /* stripe number */
-        uint64_t extent = stripe % vol->extent_no;
-        uint64_t ext_stripe = stripe / vol->extent_no; /* stripe level */
-        uint64_t strip_off = ba % strip_size; /* strip offset */
-
-        fibril_mutex_lock(&vol->lock);
-
-        rc = hr_raid0_check_vol_status(vol);
-        if (rc != EOK) {
-                fibril_mutex_unlock(&vol->lock);
-                return EIO;
-        }
+        uint64_t strip_no = ba / strip_size;
+        uint64_t extent = strip_no % vol->extent_no;
+        uint64_t stripe = strip_no / vol->extent_no;
+        uint64_t strip_off = ba % strip_size;
 
         left = cnt;
 
+        /* calculate how many strips does the IO span */
+        size_t end_strip_no = (ba + cnt - 1) / strip_size;
+        size_t span = end_strip_no - strip_no + 1;
+
+        hr_fgroup_t *group = hr_fgroup_create(vol->fge, span);
+
         while (left != 0) {
-                phys_block = ext_stripe * strip_size + strip_off;
+                phys_block = stripe * strip_size + strip_off;
                 cnt = min(left, strip_size - strip_off);
                 len = vol->bsize * cnt;
                 hr_add_ba_offset(vol, &phys_block);
-                switch (type) {
-                case HR_BD_SYNC:
-                        rc = block_sync_cache(vol->extents[extent].svc_id,
-                            phys_block, cnt);
-                        /* allow unsupported sync */
-                        if (rc == ENOTSUP)
-                                rc = EOK;
-                        break;
-                case HR_BD_READ:
-                        rc = block_read_direct(vol->extents[extent].svc_id,
-                            phys_block, cnt, data_read);
+
+                hr_io_t *io = hr_fgroup_alloc(group);
+                io->extent = extent;
+                io->data_write = data_write;
+                io->data_read = data_read;
+                io->ba = ba;
+                io->cnt = cnt;
+                io->type = type;
+                io->vol = vol;
+                io->state_callback = raid0_state_callback;
+
+                hr_fgroup_submit(group, hr_io_worker, io);
+
+                if (type == HR_BD_READ)
                         data_read += len;
-                        break;
-                case HR_BD_WRITE:
-                        rc = block_write_direct(vol->extents[extent].svc_id,
-                            phys_block, cnt, data_write);
+                else if (type == HR_BD_WRITE)
                         data_write += len;
-                        break;
-                default:
-                        rc = EINVAL;
-                }
-
-                if (rc == ENOENT) {
-                        hr_update_ext_status(vol, extent, HR_EXT_MISSING);
-                        rc = EIO;
-                        goto error;
-                } else if (rc != EOK) {
-                        hr_update_ext_status(vol, extent, HR_EXT_FAILED);
-                        rc = EIO;
-                        goto error;
-                }
 
                 left -= cnt;
@@ -288 +310 @@
                 extent++;
                 if (extent >= vol->extent_no) {
-                        ext_stripe++;
+                        stripe++;
                         extent = 0;
                 }
         }
 
-error:
-        (void)hr_raid0_update_vol_status(vol);
-        fibril_mutex_unlock(&vol->lock);
-        return rc;
+        size_t bad;
+        (void)hr_fgroup_wait(group, NULL, &bad);
+        if (bad > 0)
+                return EIO;
+
+        return EOK;
 }
 

uspace/srv/bd/hr/util.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Miroslav Cimerman
+ * Copyright (c) 2025 Miroslav Cimerman
  * All rights reserved.
  *
@@ -38 +38 @@
 
 #include <errno.h>
+#include <io/log.h>
 
 #include "var.h"

uspace/srv/bd/hr/var.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Miroslav Cimerman
+ * Copyright (c) 2025 Miroslav Cimerman
  * All rights reserved.
  *
@@ -43 +43 @@
 #include <hr.h>
 
+#include "fge.h"
+
 #define NAME "hr"
 
@@ -60 +62 @@
         bd_srvs_t hr_bds;
 
-        link_t lvolumes;
+        link_t lvolumes; /* protected by static hr_volumes_lock in hr.c */
+
+        /*
+         * XXX: will be gone after all paralelization, but still used
+         * in yet-unparallelized levels
+         */
         fibril_mutex_t lock;
 
@@ -66 +73 @@
         fibril_mutex_t range_lock_list_lock;
 
+        hr_fpool_t *fge;
+
+        /* after assembly, these are invariant */
         size_t extent_no;
-        hr_extent_t extents[HR_MAX_EXTENTS];
-
-        size_t hotspare_no;
-        hr_extent_t hotspares[HR_MAX_HOTSPARES];
-
         size_t bsize;
         uint64_t nblocks;
@@ -77 +82 @@
         uint64_t data_offset; /* in blocks */
         uint32_t strip_size;
+        hr_level_t level;
+        uint8_t layout; /* RAID Level Qualifier */
+        service_id_t svc_id;
+        char devname[HR_DEVNAME_LEN];
+
+        hr_extent_t extents[HR_MAX_EXTENTS];
+        size_t hotspare_no;
+        hr_extent_t hotspares[HR_MAX_HOTSPARES];
+
+        /* protects ordering (hr_extent_t.svc_id, hotspares) */
+        fibril_rwlock_t extents_lock;
+
+        /* protects states (hr_extent_t.status, hr_vol_status_t.status) */
+        fibril_rwlock_t states_lock;
+
+        /* for halting IO requests when a REBUILD start waits */
+        bool halt_please;
+        fibril_mutex_t halt_lock;
 
         uint64_t rebuild_blk;
-
         uint64_t counter; /* metadata syncing */
-
-        service_id_t svc_id;
         hr_vol_status_t status;
-        hr_level_t level;
-        uint8_t layout; /* RAID Level Qualifier */
-        char devname[HR_DEVNAME_LEN];
 } hr_volume_t;