Changeset 56602e0 in mainline


Ignore:
Timestamp:
2025-05-07T11:27:25Z (5 weeks ago)
Author:
Miroslav Cimerman <mc@…>
Children:
964e897
Parents:
155d34f
git-author:
Miroslav Cimerman <mc@…> (2025-05-07 11:26:23)
git-committer:
Miroslav Cimerman <mc@…> (2025-05-07 11:27:25)
Message:

hr: rename all strings status' -> state'

Location:
uspace
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/hrctl/hrctl.c

    r155d34f r56602e0  
    7474    "          -h, --hotspare device             add hotspare.\n"
    7575    "\n"
    76     "  -s, --status                              Display status of active volumes.\n"
     76    "  -s, --state                               Display state of active volumes.\n"
    7777    "\n"
    7878    "Example usage:\n"
    … …  
    435435}
    436436
    437 static int handle_status(hr_t *hr, int argc, char **argv)
     437static int handle_state(hr_t *hr, int argc, char **argv)
    438438{
    439439        (void)argc;
    440440        (void)argv;
    441441
    442         errno_t rc = hr_print_status(hr);
     442        errno_t rc = hr_print_state(hr);
    443443        if (rc != EOK) {
    444                 printf(NAME ": status printing failed: %s\n", str_error(rc));
     444                printf(NAME ": state printing failed: %s\n", str_error(rc));
    445445                return EXIT_FAILURE;
    446446        }
    … …  
    474474                { "disassemble",        no_argument, 0, 'd' },
    475475                { "modify",             no_argument, 0, 'm' },
    476                 { "status",             no_argument, 0, 's' },
     476                { "state",              no_argument, 0, 's' },
    477477                { 0, 0, 0, 0 }
    478478        };
    … …  
    496496                goto end;
    497497        case 's':
    498                 rc = handle_status(hr, argc, argv);
     498                rc = handle_state(hr, argc, argv);
    499499                goto end;
    500500        default:

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

    r155d34f r56602e0  
    6464} hr_layout_t;
    6565
    66 typedef enum hr_vol_status {
     66typedef enum hr_vol_state {
    6767        HR_VOL_NONE = 0,        /* Unknown/None */
    6868        HR_VOL_ONLINE,          /* optimal */
    … …  
    7070        HR_VOL_DEGRADED,        /* not optimal */
    7171        HR_VOL_REBUILD          /* rebuild in progress */
    72 } hr_vol_status_t;
     72} hr_vol_state_t;
    7373
    74 typedef enum hr_ext_status {
    75         HR_EXT_NONE = 0,        /* unknown/none status */
     74typedef enum hr_ext_state {
     75        HR_EXT_NONE = 0,        /* unknown/none state */
    7676        HR_EXT_INVALID,         /* working but not consistent */
    7777        HR_EXT_ONLINE,          /* ok */
    … …  
    8080        HR_EXT_REBUILD,
    8181        HR_EXT_HOTSPARE
    82 } hr_ext_status_t;
     82} hr_ext_state_t;
    8383
    8484typedef struct hr {
    … …  
    9595typedef struct hr_extent {
    9696        service_id_t    svc_id;
    97         hr_ext_status_t status;
     97        hr_ext_state_t  state;
    9898} hr_extent_t;
    9999
    … …  
    108108        uint32_t         strip_size;
    109109        size_t           bsize;
    110         hr_vol_status_t  status;
     110        hr_vol_state_t   state;
    111111        uint8_t          layout;
    112112} hr_vol_info_t;
    … …  
    129129extern errno_t           hr_fail_extent(hr_t *, const char *, unsigned long);
    130130extern errno_t           hr_add_hotspare(hr_t *, const char *, const char *);
    131 extern errno_t           hr_print_status(hr_t *);
    132 extern const char       *hr_get_vol_state_str(hr_vol_status_t);
    133 extern const char       *hr_get_ext_state_str(hr_ext_status_t);
     131extern errno_t           hr_print_state(hr_t *);
     132extern const char       *hr_get_vol_state_str(hr_vol_state_t);
     133extern const char       *hr_get_ext_state_str(hr_ext_state_t);
    134134extern const char       *hr_get_layout_str(hr_layout_t);
    135135extern const char       *hr_get_metadata_type_str(hr_metadata_type_t);

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

    r155d34f r56602e0  
    225225        printf("devname: %s\n", devname);
    226226
    227         printf("status: %s\n", hr_get_vol_state_str(vol_info->status));
     227        printf("state: %s\n", hr_get_vol_state_str(vol_info->state));
    228228
    229229        printf("level: %d\n", vol_info->level);
    … …  
    246246
    247247        if (vol_info->level == HR_LVL_4)
    248                 printf("extents: [P] [status] [index] [devname]\n");
     248                printf("extents: [P] [state] [index] [devname]\n");
    249249        else
    250                 printf("extents: [status] [index] [devname]\n");
     250                printf("extents: [state] [index] [devname]\n");
    251251        for (i = 0; i < vol_info->extent_no; i++) {
    252252                ext = &vol_info->extents[i];
    253                 if (ext->status == HR_EXT_MISSING || ext->status == HR_EXT_NONE) {
     253                if (ext->state == HR_EXT_MISSING || ext->state == HR_EXT_NONE) {
    254254                        devname = (char *) "MISSING-devname";
    255255                } else {
    … …  
    264264                            (i == vol_info->extent_no - 1 &&
    265265                            vol_info->layout == HR_RLQ_RAID4_N))
    266                                 printf("          P   %s    %zu       %s\n", hr_get_ext_state_str(ext->status), i, devname);
     266                                printf("          P   %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    267267                        else
    268                                 printf("              %s    %zu       %s\n", hr_get_ext_state_str(ext->status), i, devname);
     268                                printf("              %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    269269                } else {
    270                         printf("          %s    %zu       %s\n", hr_get_ext_state_str(ext->status), i, devname);
     270                        printf("          %s    %zu       %s\n", hr_get_ext_state_str(ext->state), i, devname);
    271271                }
    272272        }
    … …  
    275275                return EOK;
    276276
    277         printf("hotspares: [status] [index] [devname]\n");
     277        printf("hotspares: [state] [index] [devname]\n");
    278278        for (i = 0; i < vol_info->hotspare_no; i++) {
    279279                ext = &vol_info->hotspares[i];
    280                 if (ext->status == HR_EXT_MISSING) {
     280                if (ext->state == HR_EXT_MISSING) {
    281281                        devname = (char *) "MISSING-devname";
    282282                } else {
    … …  
    286286                }
    287287                printf("            %s   %zu     %s\n",
    288                     hr_get_ext_state_str(ext->status), i, devname);
     288                    hr_get_ext_state_str(ext->state), i, devname);
    289289        }
    290290
    … …  
    414414 * @return EOK on success or an error code
    415415 */
    416 errno_t hr_print_status(hr_t *hr)
     416errno_t hr_print_state(hr_t *hr)
    417417{
    418418        errno_t rc, retval;
    … …  
    483483 * @return State string
    484484 */
    485 const char *hr_get_vol_state_str(hr_vol_status_t status)
    486 {
    487         switch (status) {
     485const char *hr_get_vol_state_str(hr_vol_state_t state)
     486{
     487        switch (state) {
    488488        case HR_VOL_NONE:
    489489                return "NONE/UNKNOWN";
    … …  
    507507 * @return State string
    508508 */
    509 const char *hr_get_ext_state_str(hr_ext_status_t status)
    510 {
    511         switch (status) {
     509const char *hr_get_ext_state_str(hr_ext_state_t state)
     510{
     511        switch (state) {
    512512        case HR_EXT_NONE:
    513513                return "NONE/UNKNOWN";

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

    r155d34f r56602e0  
    5959static void hr_stop_all_srv(ipc_call_t *);
    6060static void hr_add_hotspare_srv(ipc_call_t *);
    61 static void hr_print_status_srv(ipc_call_t *);
     61static void hr_print_state_srv(ipc_call_t *);
    6262static void hr_ctl_conn(ipc_call_t *);
    6363static void hr_client_conn(ipc_call_t *, void *);
    … …  
    368368        fibril_rwlock_write_lock(&vol->states_lock);
    369369
    370         switch (vol->extents[fail_extent].status) {
     370        switch (vol->extents[fail_extent].state) {
    371371        case HR_EXT_NONE:
    372372        case HR_EXT_MISSING:
    … …  
    377377                return;
    378378        default:
    379                 hr_update_ext_status(vol, fail_extent, HR_EXT_FAILED);
     379                hr_update_ext_state(vol, fail_extent, HR_EXT_FAILED);
    380380                hr_mark_vol_state_dirty(vol);
    381381        }
    … …  
    384384        fibril_rwlock_read_unlock(&vol->extents_lock);
    385385
    386         vol->hr_ops.status_event(vol);
     386        vol->hr_ops.state_event(vol);
    387387
    388388        async_answer_0(icall, EOK);
    … …  
    428428 * Prints info about all active volumes.
    429429 */
    430 static void hr_print_status_srv(ipc_call_t *icall)
     430static void hr_print_state_srv(ipc_call_t *icall)
    431431{
    432432        HR_DEBUG("%s()", __func__);
    … …  
    470470                info.strip_size = vol->strip_size;
    471471                info.bsize = vol->bsize;
    472                 info.status = vol->status;
     472                info.state = vol->state;
    473473                info.layout = vol->layout;
    474474
    … …  
    538538                        break;
    539539                case HR_STATUS:
    540                         hr_print_status_srv(&call);
     540                        hr_print_state_srv(&call);
    541541                        break;
    542542                default:

  • uspace/srv/bd/hr/metadata/foreign/geom/hr_g_mirror.c

    r155d34f r56602e0  
    160160                /* for now no md_sync_offset handling for saved REBUILD */
    161161                if (iter_meta->md_genid == max_counter_val)
    162                         vol->extents[index].status = HR_EXT_ONLINE;
     162                        vol->extents[index].state = HR_EXT_ONLINE;
    163163                else
    164                         vol->extents[index].status = HR_EXT_INVALID;
     164                        vol->extents[index].state = HR_EXT_INVALID;
    165165
    166166                index++;
    … …  
    168168
    169169        for (size_t i = 0; i < vol->extent_no; i++) {
    170                 if (vol->extents[i].status == HR_EXT_NONE)
    171                         vol->extents[i].status = HR_EXT_MISSING;
     170                if (vol->extents[i].state == HR_EXT_NONE)
     171                        vol->extents[i].state = HR_EXT_MISSING;
    172172        }
    173173
    … …  
    223223        rc = block_read_direct(dev, blkno - 1, 1, block);
    224224        /*
    225          * XXX: here maybe call vol status event or the state callback...
     225         * XXX: here maybe call vol state event or the state callback...
    226226         *
    227227         * but need to pass vol pointer

  • uspace/srv/bd/hr/metadata/foreign/geom/hr_g_stripe.c

    r155d34f r56602e0  
    167167                iter->fini = false;
    168168
    169                 vol->extents[index].status = HR_EXT_ONLINE;
     169                vol->extents[index].state = HR_EXT_ONLINE;
    170170        }
    171171
    172172        for (size_t i = 0; i < vol->extent_no; i++) {
    173                 if (vol->extents[i].status == HR_EXT_NONE)
    174                         vol->extents[i].status = HR_EXT_MISSING;
     173                if (vol->extents[i].state == HR_EXT_NONE)
     174                        vol->extents[i].state = HR_EXT_MISSING;
    175175        }
    176176
    … …  
    227227        rc = block_read_direct(dev, blkno - 1, 1, block);
    228228        /*
    229          * XXX: here maybe call vol status event or the state callback...
     229         * XXX: here maybe call vol state event or the state callback...
    230230         *
    231231         * but need to pass vol pointer

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

    r155d34f r56602e0  
    167167                /* for now no ssd_rebuild handling for saved REBUILD */
    168168                if (iter_meta->ssd_ondisk == max_counter_val)
    169                         vol->extents[index].status = HR_EXT_ONLINE;
     169                        vol->extents[index].state = HR_EXT_ONLINE;
    170170                else
    171                         vol->extents[index].status = HR_EXT_INVALID;
     171                        vol->extents[index].state = HR_EXT_INVALID;
    172172        }
    173173
    174174        for (size_t i = 0; i < vol->extent_no; i++) {
    175                 if (vol->extents[i].status == HR_EXT_NONE)
    176                         vol->extents[i].status = HR_EXT_MISSING;
     175                if (vol->extents[i].state == HR_EXT_NONE)
     176                        vol->extents[i].state = HR_EXT_MISSING;
    177177        }
    178178

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

    r155d34f r56602e0  
    171171
    172172                if (iter_meta->counter == max_counter_val)
    173                         vol->extents[iter_meta->index].status = HR_EXT_ONLINE;
     173                        vol->extents[iter_meta->index].state = HR_EXT_ONLINE;
    174174                else
    175                         vol->extents[iter_meta->index].status = HR_EXT_INVALID;
     175                        vol->extents[iter_meta->index].state = HR_EXT_INVALID;
    176176        }
    177177
    178178        for (size_t i = 0; i < vol->extent_no; i++) {
    179                 if (vol->extents[i].status == HR_EXT_NONE)
    180                         vol->extents[i].status = HR_EXT_MISSING;
     179                if (vol->extents[i].state == HR_EXT_NONE)
     180                        vol->extents[i].state = HR_EXT_MISSING;
    181181        }
    182182
    … …  
    283283        rc = block_read_direct(dev, blkno - 1, HR_NATIVE_META_SIZE, block);
    284284        /*
    285          * XXX: here maybe call vol status event or the state callback...
     285         * XXX: here maybe call vol state event or the state callback...
    286286         *
    287287         * but need to pass vol pointer
    … …  
    379379
    380380                /* TODO: special case for REBUILD */
    381                 if (ext->status != HR_EXT_ONLINE)
     381                if (ext->state != HR_EXT_ONLINE)
    382382                        continue;
    383383
    … …  
    396396
    397397        if (with_state_callback)
    398                 vol->hr_ops.status_event(vol);
     398                vol->hr_ops.state_event(vol);
    399399
    400400        free(md_block);

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

    r155d34f r56602e0  
    5353#include "var.h"
    5454
    55 static void     hr_raid0_update_vol_status(hr_volume_t *);
     55static void     hr_raid0_update_vol_state(hr_volume_t *);
    5656static void     hr_raid0_state_callback(hr_volume_t *, size_t, errno_t);
    5757static errno_t  hr_raid0_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
    … …  
    9292        }
    9393
    94         hr_raid0_update_vol_status(new_volume);
    95         if (new_volume->status != HR_VOL_ONLINE) {
     94        hr_raid0_update_vol_state(new_volume);
     95        if (new_volume->state != HR_VOL_ONLINE) {
    9696                HR_NOTE("\"%s\": unusable state, not creating\n",
    9797                    new_volume->devname);
    … …  
    130130}
    131131
    132 void hr_raid0_status_event(hr_volume_t *vol)
    133 {
    134         HR_DEBUG("%s()", __func__);
    135 
    136         hr_raid0_update_vol_status(vol);
     132void hr_raid0_state_event(hr_volume_t *vol)
     133{
     134        HR_DEBUG("%s()", __func__);
     135
     136        hr_raid0_update_vol_state(vol);
    137137}
    138138
    … …  
    192192}
    193193
    194 static void hr_raid0_update_vol_status(hr_volume_t *vol)
     194static void hr_raid0_update_vol_state(hr_volume_t *vol)
    195195{
    196196        fibril_mutex_lock(&vol->md_lock);
    … …  
    203203        fibril_rwlock_read_lock(&vol->states_lock);
    204204
    205         hr_vol_status_t old_state = vol->status;
     205        hr_vol_state_t old_state = vol->state;
    206206
    207207        for (size_t i = 0; i < vol->extent_no; i++) {
    208                 if (vol->extents[i].status != HR_EXT_ONLINE) {
     208                if (vol->extents[i].state != HR_EXT_ONLINE) {
    209209                        fibril_rwlock_read_unlock(&vol->states_lock);
    210210
    211211                        if (old_state != HR_VOL_FAULTY) {
    212212                                fibril_rwlock_write_lock(&vol->states_lock);
    213                                 hr_update_vol_status(vol, HR_VOL_FAULTY);
     213                                hr_update_vol_state(vol, HR_VOL_FAULTY);
    214214                                fibril_rwlock_write_unlock(&vol->states_lock);
    215215                        }
    … …  
    221221        if (old_state != HR_VOL_ONLINE) {
    222222                fibril_rwlock_write_lock(&vol->states_lock);
    223                 hr_update_vol_status(vol, HR_VOL_ONLINE);
     223                hr_update_vol_state(vol, HR_VOL_ONLINE);
    224224                fibril_rwlock_write_unlock(&vol->states_lock);
    225225        }
    … …  
    235235        switch (rc) {
    236236        case ENOENT:
    237                 hr_update_ext_status(vol, extent, HR_EXT_MISSING);
     237                hr_update_ext_state(vol, extent, HR_EXT_MISSING);
    238238                break;
    239239        default:
    240                 hr_update_ext_status(vol, extent, HR_EXT_FAILED);
    241         }
    242 
    243         hr_update_vol_status(vol, HR_VOL_FAULTY);
     240                hr_update_ext_state(vol, extent, HR_EXT_FAILED);
     241        }
     242
     243        hr_update_vol_state(vol, HR_VOL_FAULTY);
    244244
    245245        fibril_rwlock_write_unlock(&vol->states_lock);
    … …  
    257257
    258258        fibril_rwlock_read_lock(&vol->states_lock);
    259         if (vol->status != HR_VOL_ONLINE) {
     259        if (vol->state != HR_VOL_ONLINE) {
    260260                fibril_rwlock_read_unlock(&vol->states_lock);
    261261                return EIO;

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

    r155d34f r56602e0  
    5656#include "var.h"
    5757
    58 static void     hr_raid1_update_vol_status(hr_volume_t *);
     58static void     hr_raid1_update_vol_state(hr_volume_t *);
    5959static void     hr_raid1_ext_state_callback(hr_volume_t *, size_t, errno_t);
    6060static size_t   hr_raid1_count_good_extents(hr_volume_t *, uint64_t, size_t,
    … …  
    110110        /* force volume state update */
    111111        hr_mark_vol_state_dirty(new_volume);
    112         hr_raid1_update_vol_status(new_volume);
     112        hr_raid1_update_vol_state(new_volume);
    113113
    114114        fibril_rwlock_read_lock(&new_volume->states_lock);
    115         hr_vol_status_t state = new_volume->status;
     115        hr_vol_state_t state = new_volume->state;
    116116        fibril_rwlock_read_unlock(&new_volume->states_lock);
    117117        if (state == HR_VOL_FAULTY || state == HR_VOL_NONE) {
    … …  
    140140}
    141141
    142 void hr_raid1_status_event(hr_volume_t *vol)
     142void hr_raid1_state_event(hr_volume_t *vol)
    143143{
    144144        HR_DEBUG("%s()", __func__);
    145145
    146         hr_raid1_update_vol_status(vol);
     146        hr_raid1_update_vol_state(vol);
    147147}
    148148
    … …  
    153153        errno_t rc = hr_util_add_hotspare(vol, hotspare);
    154154
    155         hr_raid1_update_vol_status(vol);
     155        hr_raid1_update_vol_state(vol);
    156156
    157157        return rc;
    … …  
    213213}
    214214
    215 static void hr_raid1_update_vol_status(hr_volume_t *vol)
     215static void hr_raid1_update_vol_state(hr_volume_t *vol)
    216216{
    217217        bool exp = true;
    … …  
    231231        fibril_rwlock_read_lock(&vol->states_lock);
    232232
    233         hr_vol_status_t old_state = vol->status;
     233        hr_vol_state_t old_state = vol->state;
    234234        size_t healthy = hr_count_extents(vol, HR_EXT_ONLINE);
    235235
    … …  
    240240                if (old_state != HR_VOL_FAULTY) {
    241241                        fibril_rwlock_write_lock(&vol->states_lock);
    242                         hr_update_vol_status(vol, HR_VOL_FAULTY);
     242                        hr_update_vol_state(vol, HR_VOL_FAULTY);
    243243                        fibril_rwlock_write_unlock(&vol->states_lock);
    244244                }
    … …  
    247247                    old_state != HR_VOL_DEGRADED) {
    248248                        fibril_rwlock_write_lock(&vol->states_lock);
    249                         hr_update_vol_status(vol, HR_VOL_DEGRADED);
     249                        hr_update_vol_state(vol, HR_VOL_DEGRADED);
    250250                        fibril_rwlock_write_unlock(&vol->states_lock);
    251251                }
    … …  
    265265                if (old_state != HR_VOL_ONLINE) {
    266266                        fibril_rwlock_write_lock(&vol->states_lock);
    267                         hr_update_vol_status(vol, HR_VOL_ONLINE);
     267                        hr_update_vol_state(vol, HR_VOL_ONLINE);
    268268                        fibril_rwlock_write_unlock(&vol->states_lock);
    269269                }
    … …  
    283283        switch (rc) {
    284284        case ENOMEM:
    285                 hr_update_ext_status(vol, extent, HR_EXT_INVALID);
     285                hr_update_ext_state(vol, extent, HR_EXT_INVALID);
    286286                break;
    287287        case ENOENT:
    288                 hr_update_ext_status(vol, extent, HR_EXT_MISSING);
     288                hr_update_ext_state(vol, extent, HR_EXT_MISSING);
    289289                break;
    290290        default:
    291                 hr_update_ext_status(vol, extent, HR_EXT_FAILED);
     291                hr_update_ext_state(vol, extent, HR_EXT_FAILED);
    292292        }
    293293
    … …  
    305305        size_t count = 0;
    306306        for (size_t i = 0; i < vol->extent_no; i++) {
    307                 if (vol->extents[i].status == HR_EXT_ONLINE ||
    308                     (vol->extents[i].status == HR_EXT_REBUILD &&
     307                if (vol->extents[i].state == HR_EXT_ONLINE ||
     308                    (vol->extents[i].state == HR_EXT_REBUILD &&
    309309                    ba < rebuild_blk)) {
    310310                        count++;
    … …  
    326326
    327327        fibril_rwlock_read_lock(&vol->states_lock);
    328         hr_vol_status_t vol_state = vol->status;
     328        hr_vol_state_t vol_state = vol->state;
    329329        fibril_rwlock_read_unlock(&vol->states_lock);
    330330
    … …  
    358358                for (i = 0; i < vol->extent_no; i++) {
    359359                        fibril_rwlock_read_lock(&vol->states_lock);
    360                         hr_ext_status_t state = vol->extents[i].status;
     360                        hr_ext_state_t state = vol->extents[i].state;
    361361                        fibril_rwlock_read_unlock(&vol->states_lock);
    362362
    … …  
    412412
    413413                for (i = 0; i < vol->extent_no; i++) {
    414                         if (vol->extents[i].status != HR_EXT_ONLINE &&
    415                             (vol->extents[i].status != HR_EXT_REBUILD ||
     414                        if (vol->extents[i].state != HR_EXT_ONLINE &&
     415                            (vol->extents[i].state != HR_EXT_REBUILD ||
    416416                            ba >= rebuild_blk)) {
    417417                                /*
    … …  
    458458        fibril_rwlock_read_unlock(&vol->extents_lock);
    459459
    460         hr_raid1_update_vol_status(vol);
     460        hr_raid1_update_vol_state(vol);
    461461
    462462        return rc;
    … …  
    533533        fibril_rwlock_write_lock(&vol->states_lock);
    534534
    535         hr_update_ext_status(vol, rebuild_idx, HR_EXT_ONLINE);
     535        hr_update_ext_state(vol, rebuild_idx, HR_EXT_ONLINE);
    536536
    537537        /*
    … …  
    541541         * state accordingly.
    542542         */
    543         hr_update_vol_status(vol, HR_VOL_ONLINE);
     543        hr_update_vol_state(vol, HR_VOL_ONLINE);
    544544        hr_mark_vol_state_dirty(vol);
    545545
    … …  
    558558                 */
    559559                fibril_rwlock_write_lock(&vol->states_lock);
    560                 hr_update_vol_status(vol, HR_VOL_DEGRADED);
     560                hr_update_vol_state(vol, HR_VOL_DEGRADED);
    561561                hr_mark_vol_state_dirty(vol);
    562562                fibril_rwlock_write_unlock(&vol->states_lock);
    … …  
    565565        fibril_rwlock_read_unlock(&vol->extents_lock);
    566566
    567         hr_raid1_update_vol_status(vol);
     567        hr_raid1_update_vol_state(vol);
    568568
    569569        if (buf != NULL)
    … …  
    591591        size_t bad = vol->extent_no;
    592592        for (size_t i = 0; i < vol->extent_no; i++) {
    593                 if (vol->extents[i].status != HR_EXT_ONLINE) {
     593                if (vol->extents[i].state != HR_EXT_ONLINE) {
    594594                        bad = i;
    595595                        break;
    … …  
    606606        size_t hotspare_idx = vol->hotspare_no - 1;
    607607
    608         hr_ext_status_t hs_state = vol->hotspares[hotspare_idx].status;
     608        hr_ext_state_t hs_state = vol->hotspares[hotspare_idx].state;
    609609        if (hs_state != HR_EXT_HOTSPARE) {
    610610                HR_ERROR("hr_raid1_rebuild(): invalid hotspare state \"%s\", "
    … …  
    628628        atomic_store_explicit(&vol->rebuild_blk, 0, memory_order_relaxed);
    629629
    630         hr_update_ext_status(vol, bad, HR_EXT_REBUILD);
    631         hr_update_vol_status(vol, HR_VOL_REBUILD);
     630        hr_update_ext_state(vol, bad, HR_EXT_REBUILD);
     631        hr_update_vol_state(vol, HR_VOL_REBUILD);
    632632
    633633        *rebuild_idx = bad;
    … …  
    648648
    649649        hr_update_ext_svc_id(vol, bad, hs_svc_id);
    650         hr_update_ext_status(vol, bad, HR_EXT_HOTSPARE);
     650        hr_update_ext_state(vol, bad, HR_EXT_HOTSPARE);
    651651
    652652        hr_update_hotspare_svc_id(vol, hs, 0);
    653         hr_update_hotspare_status(vol, hs, HR_EXT_MISSING);
     653        hr_update_hotspare_state(vol, hs, HR_EXT_MISSING);
    654654
    655655        vol->hotspare_no--;
    … …  
    670670
    671671        fibril_rwlock_read_lock(&vol->states_lock);
    672         hr_ext_status_t rebuild_ext_status = rebuild_ext->status;
     672        hr_ext_state_t rebuild_ext_state = rebuild_ext->state;
    673673        fibril_rwlock_read_unlock(&vol->states_lock);
    674674
    675         if (rebuild_ext_status != HR_EXT_REBUILD)
     675        if (rebuild_ext_state != HR_EXT_REBUILD)
    676676                return EINVAL;
    677677
    … …  
    679679                fibril_rwlock_read_lock(&vol->states_lock);
    680680                ext = &vol->extents[i];
    681                 if (ext->status != HR_EXT_ONLINE) {
     681                if (ext->state != HR_EXT_ONLINE) {
    682682                        fibril_rwlock_read_unlock(&vol->states_lock);
    683683                        continue;

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

    r155d34f r56602e0  
    5656static errno_t  hr_raid5_vol_usable(hr_volume_t *);
    5757static ssize_t  hr_raid5_get_bad_ext(hr_volume_t *);
    58 static errno_t  hr_raid5_update_vol_status(hr_volume_t *);
     58static errno_t  hr_raid5_update_vol_state(hr_volume_t *);
    5959static void     hr_raid5_handle_extent_error(hr_volume_t *, size_t, errno_t);
    6060static void     xor(void *, const void *, size_t);
    … …  
    105105        fibril_rwlock_write_lock(&new_volume->states_lock);
    106106
    107         errno_t rc = hr_raid5_update_vol_status(new_volume);
     107        errno_t rc = hr_raid5_update_vol_state(new_volume);
    108108        if (rc != EOK) {
    109109                HR_NOTE("\"%s\": unusable state, not creating\n",
    … …  
    145145}
    146146
    147 void hr_raid5_status_event(hr_volume_t *vol)
     147void hr_raid5_state_event(hr_volume_t *vol)
    148148{
    149149        fibril_mutex_lock(&vol->lock);
    150150        fibril_rwlock_write_lock(&vol->states_lock);
    151         (void)hr_raid5_update_vol_status(vol);
     151        (void)hr_raid5_update_vol_state(vol);
    152152        fibril_rwlock_write_unlock(&vol->states_lock);
    153153        fibril_mutex_unlock(&vol->lock);
    … …  
    167167         * If the volume is degraded, start rebuild right away.
    168168         */
    169         if (vol->status == HR_VOL_DEGRADED) {
     169        if (vol->state == HR_VOL_DEGRADED) {
    170170                HR_DEBUG("hr_raid5_add_hotspare(): volume in DEGRADED state, "
    171171                    "spawning new rebuild fibril\n");
    … …  
    243243static errno_t hr_raid5_vol_usable(hr_volume_t *vol)
    244244{
    245         if (vol->status == HR_VOL_ONLINE ||
    246             vol->status == HR_VOL_DEGRADED ||
    247             vol->status == HR_VOL_REBUILD)
     245        if (vol->state == HR_VOL_ONLINE ||
     246            vol->state == HR_VOL_DEGRADED ||
     247            vol->state == HR_VOL_REBUILD)
    248248                return EOK;
    249249        return EIO;
    … …  
    257257{
    258258        for (size_t i = 0; i < vol->extent_no; i++)
    259                 if (vol->extents[i].status != HR_EXT_ONLINE)
     259                if (vol->extents[i].state != HR_EXT_ONLINE)
    260260                        return i;
    261261        return -1;
    262262}
    263263
    264 static errno_t hr_raid5_update_vol_status(hr_volume_t *vol)
    265 {
    266         hr_vol_status_t old_state = vol->status;
     264static errno_t hr_raid5_update_vol_state(hr_volume_t *vol)
     265{
     266        hr_vol_state_t old_state = vol->state;
    267267        size_t bad = 0;
    268268        for (size_t i = 0; i < vol->extent_no; i++)
    269                 if (vol->extents[i].status != HR_EXT_ONLINE)
     269                if (vol->extents[i].state != HR_EXT_ONLINE)
    270270                        bad++;
    271271
    … …  
    273273        case 0:
    274274                if (old_state != HR_VOL_ONLINE)
    275                         hr_update_vol_status(vol, HR_VOL_ONLINE);
     275                        hr_update_vol_state(vol, HR_VOL_ONLINE);
    276276                return EOK;
    277277        case 1:
    … …  
    279279                    old_state != HR_VOL_REBUILD) {
    280280
    281                         hr_update_vol_status(vol, HR_VOL_DEGRADED);
     281                        hr_update_vol_state(vol, HR_VOL_DEGRADED);
    282282
    283283                        if (vol->hotspare_no > 0) {
    … …  
    293293        default:
    294294                if (old_state != HR_VOL_FAULTY)
    295                         hr_update_vol_status(vol, HR_VOL_FAULTY);
     295                        hr_update_vol_state(vol, HR_VOL_FAULTY);
    296296                return EIO;
    297297        }
    … …  
    302302{
    303303        if (rc == ENOENT)
    304                 hr_update_ext_status(vol, extent, HR_EXT_MISSING);
     304                hr_update_ext_state(vol, extent, HR_EXT_MISSING);
    305305        else if (rc != EOK)
    306                 hr_update_ext_status(vol, extent, HR_EXT_FAILED);
     306                hr_update_ext_state(vol, extent, HR_EXT_FAILED);
    307307}
    308308
    … …  
    537537        if (type == HR_BD_SYNC && ba == 0 && cnt == 0) {
    538538                hr_sync_all_extents(vol);
    539                 rc = hr_raid5_update_vol_status(vol);
     539                rc = hr_raid5_update_vol_state(vol);
    540540                return rc;
    541541        }
    … …  
    611611                switch (type) {
    612612                case HR_BD_SYNC:
    613                         if (vol->extents[extent].status != HR_EXT_ONLINE)
     613                        if (vol->extents[extent].state != HR_EXT_ONLINE)
    614614                                break;
    615615                        rc = block_sync_cache(vol->extents[extent].svc_id,
    … …  
    648648
    649649                if (rc != EOK) {
    650                         rc = hr_raid5_update_vol_status(vol);
     650                        rc = hr_raid5_update_vol_state(vol);
    651651                        if (rc == EOK) {
    652652                                /*
    … …  
    700700
    701701error:
    702         (void)hr_raid5_update_vol_status(vol);
     702        (void)hr_raid5_update_vol_state(vol);
    703703        fibril_rwlock_write_unlock(&vol->states_lock);
    704704        fibril_mutex_unlock(&vol->lock);
    … …  
    727727        size_t bad = vol->extent_no;
    728728        for (size_t i = 0; i < vol->extent_no; i++) {
    729                 if (vol->extents[i].status == HR_EXT_FAILED) {
     729                if (vol->extents[i].state == HR_EXT_FAILED) {
    730730                        bad = i;
    731731                        break;
    … …  
    742742        size_t hotspare_idx = vol->hotspare_no - 1;
    743743
    744         hr_ext_status_t hs_state = vol->hotspares[hotspare_idx].status;
     744        hr_ext_state_t hs_state = vol->hotspares[hotspare_idx].state;
    745745        if (hs_state != HR_EXT_HOTSPARE) {
    746746                HR_ERROR("hr_raid5_rebuild(): invalid hotspare state \"%s\", "
    … …  
    755755
    756756        vol->extents[bad].svc_id = vol->hotspares[hotspare_idx].svc_id;
    757         hr_update_ext_status(vol, bad, HR_EXT_HOTSPARE);
     757        hr_update_ext_state(vol, bad, HR_EXT_HOTSPARE);
    758758
    759759        vol->hotspares[hotspare_idx].svc_id = 0;
    760760        fibril_mutex_lock(&vol->hotspare_lock);
    761         hr_update_hotspare_status(vol, hotspare_idx, HR_EXT_MISSING);
     761        hr_update_hotspare_state(vol, hotspare_idx, HR_EXT_MISSING);
    762762        fibril_mutex_unlock(&vol->hotspare_lock);
    763763
    … …  
    769769            rebuild_ext->svc_id);
    770770
    771         hr_update_ext_status(vol, bad, HR_EXT_REBUILD);
    772         hr_update_vol_status(vol, HR_VOL_REBUILD);
     771        hr_update_ext_state(vol, bad, HR_EXT_REBUILD);
     772        hr_update_vol_state(vol, HR_VOL_REBUILD);
    773773
    774774        uint64_t max_blks = DATA_XFER_LIMIT / vol->bsize;
    … …  
    838838            "extent number %zu\n", vol->devname, vol->svc_id, hotspare_idx);
    839839
    840         hr_update_ext_status(vol, bad, HR_EXT_ONLINE);
     840        hr_update_ext_state(vol, bad, HR_EXT_ONLINE);
    841841
    842842        rc = vol->meta_ops->save(vol, WITH_STATE_CALLBACK);
    843843
    844844end:
    845         (void)hr_raid5_update_vol_status(vol);
     845        (void)hr_raid5_update_vol_state(vol);
    846846
    847847        fibril_rwlock_write_unlock(&vol->states_lock);

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

    r155d34f r56602e0  
    9898                vol->hr_ops.create = hr_raid0_create;
    9999                vol->hr_ops.init = hr_raid0_init;
    100                 vol->hr_ops.status_event = hr_raid0_status_event;
     100                vol->hr_ops.state_event = hr_raid0_state_event;
    101101                break;
    102102        case HR_LVL_1:
    103103                vol->hr_ops.create = hr_raid1_create;
    104104                vol->hr_ops.init = hr_raid1_init;
    105                 vol->hr_ops.status_event = hr_raid1_status_event;
     105                vol->hr_ops.state_event = hr_raid1_state_event;
    106106                if (meta_flags & HR_METADATA_HOTSPARE_SUPPORT)
    107107                        vol->hr_ops.add_hotspare = hr_raid1_add_hotspare;
    … …  
    111111                vol->hr_ops.create = hr_raid5_create;
    112112                vol->hr_ops.init = hr_raid5_init;
    113                 vol->hr_ops.status_event = hr_raid5_status_event;
     113                vol->hr_ops.state_event = hr_raid5_state_event;
    114114                if (meta_flags & HR_METADATA_HOTSPARE_SUPPORT)
    115115                        vol->hr_ops.add_hotspare = hr_raid5_add_hotspare;
    … …  
    134134        }
    135135
    136         vol->status = HR_VOL_NONE;
     136        vol->state = HR_VOL_NONE;
    137137
    138138        fibril_mutex_initialize(&vol->lock); /* XXX: will remove this */
    … …  
    268268
    269269                vol->extents[i].svc_id = svc_id;
    270                 vol->extents[i].status = HR_EXT_ONLINE;
     270                vol->extents[i].state = HR_EXT_ONLINE;
    271271
    272272                if (blkno < smallest_blkno)
    … …  
    280280
    281281        for (i = 0; i < HR_MAX_HOTSPARES; i++)
    282                 vol->hotspares[i].status = HR_EXT_MISSING;
     282                vol->hotspares[i].state = HR_EXT_MISSING;
    283283
    284284        return EOK;
    … …  
    374374}
    375375
    376 void hr_update_ext_status(hr_volume_t *vol, size_t ext_idx, hr_ext_status_t s)
     376void hr_update_ext_state(hr_volume_t *vol, size_t ext_idx, hr_ext_state_t s)
    377377{
    378378        if (vol->level != HR_LVL_0)
    … …  
    383383        assert(ext_idx < vol->extent_no);
    384384
    385         hr_ext_status_t old = vol->extents[ext_idx].status;
     385        hr_ext_state_t old = vol->extents[ext_idx].state;
    386386        HR_NOTE("\"%s\": changing extent %zu state: %s -> %s\n",
    387387            vol->devname, ext_idx, hr_get_ext_state_str(old),
    388388            hr_get_ext_state_str(s));
    389         vol->extents[ext_idx].status = s;
    390 }
    391 
    392 void hr_update_hotspare_status(hr_volume_t *vol, size_t hs_idx,
    393     hr_ext_status_t s)
     389        vol->extents[ext_idx].state = s;
     390}
     391
     392void hr_update_hotspare_state(hr_volume_t *vol, size_t hs_idx,
     393    hr_ext_state_t s)
    394394{
    395395        assert(fibril_mutex_is_locked(&vol->hotspare_lock));
    … …  
    397397        assert(hs_idx < vol->hotspare_no);
    398398
    399         hr_ext_status_t old = vol->hotspares[hs_idx].status;
     399        hr_ext_state_t old = vol->hotspares[hs_idx].state;
    400400        HR_NOTE("\"%s\": changing hotspare %zu state: %s -> %s\n",
    401401            vol->devname, hs_idx, hr_get_ext_state_str(old),
    402402            hr_get_ext_state_str(s));
    403         vol->hotspares[hs_idx].status = s;
    404 }
    405 
    406 void hr_update_vol_status(hr_volume_t *vol, hr_vol_status_t new)
     403        vol->hotspares[hs_idx].state = s;
     404}
     405
     406void hr_update_vol_state(hr_volume_t *vol, hr_vol_state_t new)
    407407{
    408408        assert(fibril_rwlock_is_write_locked(&vol->states_lock));
    409409
    410410        HR_NOTE("\"%s\": changing volume state: %s -> %s\n", vol->devname,
    411             hr_get_vol_state_str(vol->status), hr_get_vol_state_str(new));
    412         vol->status = new;
     411            hr_get_vol_state_str(vol->state), hr_get_vol_state_str(new));
     412        vol->state = new;
    413413}
    414414
    … …  
    441441/*
    442442 * Do a whole sync (ba = 0, cnt = 0) across all extents,
    443  * and update extent status. *For now*, the caller has to
    444  * update volume status after the syncs.
     443 * and update extent state. *For now*, the caller has to
     444 * update volume state after the syncs.
    445445 *
    446  * TODO: add update_vol_status fcn ptr for each raid
     446 * TODO: add update_vol_state fcn ptr for each raid
    447447 */
    448448void hr_sync_all_extents(hr_volume_t *vol)
    … …  
    452452        fibril_mutex_lock(&vol->lock);
    453453        for (size_t i = 0; i < vol->extent_no; i++) {
    454                 if (vol->extents[i].status != HR_EXT_ONLINE)
     454                if (vol->extents[i].state != HR_EXT_ONLINE)
    455455                        continue;
    456456                rc = block_sync_cache(vol->extents[i].svc_id, 0, 0);
    … …  
    459459                if (rc != EOK) {
    460460                        if (rc == ENOENT)
    461                                 hr_update_ext_status(vol, i, HR_EXT_MISSING);
     461                                hr_update_ext_state(vol, i, HR_EXT_MISSING);
    462462                        else if (rc != EOK)
    463                                 hr_update_ext_status(vol, i, HR_EXT_FAILED);
     463                                hr_update_ext_state(vol, i, HR_EXT_FAILED);
    464464                }
    465465        }
    … …  
    467467}
    468468
    469 size_t hr_count_extents(hr_volume_t *vol, hr_ext_status_t status)
     469size_t hr_count_extents(hr_volume_t *vol, hr_ext_state_t state)
    470470{
    471471        if (vol->level != HR_LVL_0)
    … …  
    475475        size_t count = 0;
    476476        for (size_t i = 0; i < vol->extent_no; i++)
    477                 if (vol->extents[i].status == status)
     477                if (vol->extents[i].state == state)
    478478                        count++;
    479479
    … …  
    10521052
    10531053        hr_update_hotspare_svc_id(vol, hs_idx, hotspare);
    1054         hr_update_hotspare_status(vol, hs_idx, HR_EXT_HOTSPARE);
     1054        hr_update_hotspare_state(vol, hs_idx, HR_EXT_HOTSPARE);
    10551055
    10561056        hr_mark_vol_state_dirty(vol);

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

    r155d34f r56602e0  
    7777extern errno_t           hr_check_ba_range(hr_volume_t *, size_t, uint64_t);
    7878extern void              hr_add_ba_offset(hr_volume_t *, uint64_t *);
    79 extern void              hr_update_ext_status(hr_volume_t *, size_t,
    80     hr_ext_status_t);
    81 extern void              hr_update_hotspare_status(hr_volume_t *, size_t,
    82     hr_ext_status_t);
    83 extern void              hr_update_vol_status(hr_volume_t *, hr_vol_status_t);
     79extern void              hr_update_ext_state(hr_volume_t *, size_t,
     80    hr_ext_state_t);
     81extern void              hr_update_hotspare_state(hr_volume_t *, size_t,
     82    hr_ext_state_t);
     83extern void              hr_update_vol_state(hr_volume_t *, hr_vol_state_t);
    8484extern void              hr_update_ext_svc_id(hr_volume_t *, size_t,
    8585    service_id_t);
    … …  
    8787    service_id_t);
    8888extern void              hr_sync_all_extents(hr_volume_t *);
    89 extern size_t            hr_count_extents(hr_volume_t *, hr_ext_status_t);
     89extern size_t            hr_count_extents(hr_volume_t *, hr_ext_state_t);
    9090extern void              hr_mark_vol_state_dirty(hr_volume_t *);
    9191extern void              hr_range_lock_release(hr_range_lock_t *);

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

    r155d34f r56602e0  
    5858        errno_t         (*create)(hr_volume_t *);
    5959        errno_t         (*init)(hr_volume_t *);
    60         void            (*status_event)(hr_volume_t *);
     60        void            (*state_event)(hr_volume_t *);
    6161        errno_t         (*add_hotspare)(hr_volume_t *, service_id_t);
    6262} hr_ops_t;
    … …  
    103103        _Atomic uint64_t rebuild_blk;           /* rebuild position */
    104104        _Atomic int      open_cnt;              /* open/close() counter */
    105         hr_vol_status_t  status;                /* volume status */
     105        hr_vol_state_t   state;                 /* volume state */
    106106        void             (*state_callback)(hr_volume_t *, size_t, errno_t);
    107107} hr_volume_t;
    … …  
    136136extern errno_t          hr_raid5_init(hr_volume_t *);
    137137
    138 extern void             hr_raid0_status_event(hr_volume_t *);
    139 extern void             hr_raid1_status_event(hr_volume_t *);
    140 extern void             hr_raid5_status_event(hr_volume_t *);
     138extern void             hr_raid0_state_event(hr_volume_t *);
     139extern void             hr_raid1_state_event(hr_volume_t *);
     140extern void             hr_raid5_state_event(hr_volume_t *);
    141141
    142142extern errno_t          hr_raid1_add_hotspare(hr_volume_t *, service_id_t);
Note: See TracChangeset for help on using the changeset viewer.