Index: uspace/srv/bd/hr/hr.c
===================================================================
--- uspace/srv/bd/hr/hr.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/hr.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -59,5 +59,5 @@
 static void hr_stop_all_srv(ipc_call_t *);
 static void hr_add_hotspare_srv(ipc_call_t *);
-static void hr_print_status_srv(ipc_call_t *);
+static void hr_print_state_srv(ipc_call_t *);
 static void hr_ctl_conn(ipc_call_t *);
 static void hr_client_conn(ipc_call_t *, void *);
@@ -368,5 +368,5 @@
 	fibril_rwlock_write_lock(&vol->states_lock);
 
-	switch (vol->extents[fail_extent].status) {
+	switch (vol->extents[fail_extent].state) {
 	case HR_EXT_NONE:
 	case HR_EXT_MISSING:
@@ -377,5 +377,5 @@
 		return;
 	default:
-		hr_update_ext_status(vol, fail_extent, HR_EXT_FAILED);
+		hr_update_ext_state(vol, fail_extent, HR_EXT_FAILED);
 		hr_mark_vol_state_dirty(vol);
 	}
@@ -384,5 +384,5 @@
 	fibril_rwlock_read_unlock(&vol->extents_lock);
 
-	vol->hr_ops.status_event(vol);
+	vol->hr_ops.state_event(vol);
 
 	async_answer_0(icall, EOK);
@@ -428,5 +428,5 @@
  * Prints info about all active volumes.
  */
-static void hr_print_status_srv(ipc_call_t *icall)
+static void hr_print_state_srv(ipc_call_t *icall)
 {
 	HR_DEBUG("%s()", __func__);
@@ -470,5 +470,5 @@
 		info.strip_size = vol->strip_size;
 		info.bsize = vol->bsize;
-		info.status = vol->status;
+		info.state = vol->state;
 		info.layout = vol->layout;
 
@@ -538,5 +538,5 @@
 			break;
 		case HR_STATUS:
-			hr_print_status_srv(&call);
+			hr_print_state_srv(&call);
 			break;
 		default:
Index: uspace/srv/bd/hr/metadata/foreign/geom/hr_g_mirror.c
===================================================================
--- uspace/srv/bd/hr/metadata/foreign/geom/hr_g_mirror.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/metadata/foreign/geom/hr_g_mirror.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -160,7 +160,7 @@
 		/* for now no md_sync_offset handling for saved REBUILD */
 		if (iter_meta->md_genid == max_counter_val)
-			vol->extents[index].status = HR_EXT_ONLINE;
+			vol->extents[index].state = HR_EXT_ONLINE;
 		else
-			vol->extents[index].status = HR_EXT_INVALID;
+			vol->extents[index].state = HR_EXT_INVALID;
 
 		index++;
@@ -168,6 +168,6 @@
 
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_NONE)
-			vol->extents[i].status = HR_EXT_MISSING;
+		if (vol->extents[i].state == HR_EXT_NONE)
+			vol->extents[i].state = HR_EXT_MISSING;
 	}
 
@@ -223,5 +223,5 @@
 	rc = block_read_direct(dev, blkno - 1, 1, block);
 	/*
-	 * XXX: here maybe call vol status event or the state callback...
+	 * XXX: here maybe call vol state event or the state callback...
 	 *
 	 * but need to pass vol pointer
Index: uspace/srv/bd/hr/metadata/foreign/geom/hr_g_stripe.c
===================================================================
--- uspace/srv/bd/hr/metadata/foreign/geom/hr_g_stripe.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/metadata/foreign/geom/hr_g_stripe.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -167,10 +167,10 @@
 		iter->fini = false;
 
-		vol->extents[index].status = HR_EXT_ONLINE;
+		vol->extents[index].state = HR_EXT_ONLINE;
 	}
 
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_NONE)
-			vol->extents[i].status = HR_EXT_MISSING;
+		if (vol->extents[i].state == HR_EXT_NONE)
+			vol->extents[i].state = HR_EXT_MISSING;
 	}
 
@@ -227,5 +227,5 @@
 	rc = block_read_direct(dev, blkno - 1, 1, block);
 	/*
-	 * XXX: here maybe call vol status event or the state callback...
+	 * XXX: here maybe call vol state event or the state callback...
 	 *
 	 * but need to pass vol pointer
Index: uspace/srv/bd/hr/metadata/foreign/softraid/hr_softraid.c
===================================================================
--- uspace/srv/bd/hr/metadata/foreign/softraid/hr_softraid.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/metadata/foreign/softraid/hr_softraid.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -167,12 +167,12 @@
 		/* for now no ssd_rebuild handling for saved REBUILD */
 		if (iter_meta->ssd_ondisk == max_counter_val)
-			vol->extents[index].status = HR_EXT_ONLINE;
+			vol->extents[index].state = HR_EXT_ONLINE;
 		else
-			vol->extents[index].status = HR_EXT_INVALID;
+			vol->extents[index].state = HR_EXT_INVALID;
 	}
 
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_NONE)
-			vol->extents[i].status = HR_EXT_MISSING;
+		if (vol->extents[i].state == HR_EXT_NONE)
+			vol->extents[i].state = HR_EXT_MISSING;
 	}
 
Index: uspace/srv/bd/hr/metadata/native.c
===================================================================
--- uspace/srv/bd/hr/metadata/native.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/metadata/native.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -171,12 +171,12 @@
 
 		if (iter_meta->counter == max_counter_val)
-			vol->extents[iter_meta->index].status = HR_EXT_ONLINE;
+			vol->extents[iter_meta->index].state = HR_EXT_ONLINE;
 		else
-			vol->extents[iter_meta->index].status = HR_EXT_INVALID;
+			vol->extents[iter_meta->index].state = HR_EXT_INVALID;
 	}
 
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_NONE)
-			vol->extents[i].status = HR_EXT_MISSING;
+		if (vol->extents[i].state == HR_EXT_NONE)
+			vol->extents[i].state = HR_EXT_MISSING;
 	}
 
@@ -283,5 +283,5 @@
 	rc = block_read_direct(dev, blkno - 1, HR_NATIVE_META_SIZE, block);
 	/*
-	 * XXX: here maybe call vol status event or the state callback...
+	 * XXX: here maybe call vol state event or the state callback...
 	 *
 	 * but need to pass vol pointer
@@ -379,5 +379,5 @@
 
 		/* TODO: special case for REBUILD */
-		if (ext->status != HR_EXT_ONLINE)
+		if (ext->state != HR_EXT_ONLINE)
 			continue;
 
@@ -396,5 +396,5 @@
 
 	if (with_state_callback)
-		vol->hr_ops.status_event(vol);
+		vol->hr_ops.state_event(vol);
 
 	free(md_block);
Index: uspace/srv/bd/hr/raid0.c
===================================================================
--- uspace/srv/bd/hr/raid0.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/raid0.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -53,5 +53,5 @@
 #include "var.h"
 
-static void	hr_raid0_update_vol_status(hr_volume_t *);
+static void	hr_raid0_update_vol_state(hr_volume_t *);
 static void	hr_raid0_state_callback(hr_volume_t *, size_t, errno_t);
 static errno_t	hr_raid0_bd_op(hr_bd_op_type_t, bd_srv_t *, aoff64_t, size_t,
@@ -92,6 +92,6 @@
 	}
 
-	hr_raid0_update_vol_status(new_volume);
-	if (new_volume->status != HR_VOL_ONLINE) {
+	hr_raid0_update_vol_state(new_volume);
+	if (new_volume->state != HR_VOL_ONLINE) {
 		HR_NOTE("\"%s\": unusable state, not creating\n",
 		    new_volume->devname);
@@ -130,9 +130,9 @@
 }
 
-void hr_raid0_status_event(hr_volume_t *vol)
-{
-	HR_DEBUG("%s()", __func__);
-
-	hr_raid0_update_vol_status(vol);
+void hr_raid0_state_event(hr_volume_t *vol)
+{
+	HR_DEBUG("%s()", __func__);
+
+	hr_raid0_update_vol_state(vol);
 }
 
@@ -192,5 +192,5 @@
 }
 
-static void hr_raid0_update_vol_status(hr_volume_t *vol)
+static void hr_raid0_update_vol_state(hr_volume_t *vol)
 {
 	fibril_mutex_lock(&vol->md_lock);
@@ -203,13 +203,13 @@
 	fibril_rwlock_read_lock(&vol->states_lock);
 
-	hr_vol_status_t old_state = vol->status;
+	hr_vol_state_t old_state = vol->state;
 
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status != HR_EXT_ONLINE) {
+		if (vol->extents[i].state != HR_EXT_ONLINE) {
 			fibril_rwlock_read_unlock(&vol->states_lock);
 
 			if (old_state != HR_VOL_FAULTY) {
 				fibril_rwlock_write_lock(&vol->states_lock);
-				hr_update_vol_status(vol, HR_VOL_FAULTY);
+				hr_update_vol_state(vol, HR_VOL_FAULTY);
 				fibril_rwlock_write_unlock(&vol->states_lock);
 			}
@@ -221,5 +221,5 @@
 	if (old_state != HR_VOL_ONLINE) {
 		fibril_rwlock_write_lock(&vol->states_lock);
-		hr_update_vol_status(vol, HR_VOL_ONLINE);
+		hr_update_vol_state(vol, HR_VOL_ONLINE);
 		fibril_rwlock_write_unlock(&vol->states_lock);
 	}
@@ -235,11 +235,11 @@
 	switch (rc) {
 	case ENOENT:
-		hr_update_ext_status(vol, extent, HR_EXT_MISSING);
+		hr_update_ext_state(vol, extent, HR_EXT_MISSING);
 		break;
 	default:
-		hr_update_ext_status(vol, extent, HR_EXT_FAILED);
-	}
-
-	hr_update_vol_status(vol, HR_VOL_FAULTY);
+		hr_update_ext_state(vol, extent, HR_EXT_FAILED);
+	}
+
+	hr_update_vol_state(vol, HR_VOL_FAULTY);
 
 	fibril_rwlock_write_unlock(&vol->states_lock);
@@ -257,5 +257,5 @@
 
 	fibril_rwlock_read_lock(&vol->states_lock);
-	if (vol->status != HR_VOL_ONLINE) {
+	if (vol->state != HR_VOL_ONLINE) {
 		fibril_rwlock_read_unlock(&vol->states_lock);
 		return EIO;
Index: uspace/srv/bd/hr/raid1.c
===================================================================
--- uspace/srv/bd/hr/raid1.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/raid1.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -56,5 +56,5 @@
 #include "var.h"
 
-static void	hr_raid1_update_vol_status(hr_volume_t *);
+static void	hr_raid1_update_vol_state(hr_volume_t *);
 static void	hr_raid1_ext_state_callback(hr_volume_t *, size_t, errno_t);
 static size_t	hr_raid1_count_good_extents(hr_volume_t *, uint64_t, size_t,
@@ -110,8 +110,8 @@
 	/* force volume state update */
 	hr_mark_vol_state_dirty(new_volume);
-	hr_raid1_update_vol_status(new_volume);
+	hr_raid1_update_vol_state(new_volume);
 
 	fibril_rwlock_read_lock(&new_volume->states_lock);
-	hr_vol_status_t state = new_volume->status;
+	hr_vol_state_t state = new_volume->state;
 	fibril_rwlock_read_unlock(&new_volume->states_lock);
 	if (state == HR_VOL_FAULTY || state == HR_VOL_NONE) {
@@ -140,9 +140,9 @@
 }
 
-void hr_raid1_status_event(hr_volume_t *vol)
+void hr_raid1_state_event(hr_volume_t *vol)
 {
 	HR_DEBUG("%s()", __func__);
 
-	hr_raid1_update_vol_status(vol);
+	hr_raid1_update_vol_state(vol);
 }
 
@@ -153,5 +153,5 @@
 	errno_t rc = hr_util_add_hotspare(vol, hotspare);
 
-	hr_raid1_update_vol_status(vol);
+	hr_raid1_update_vol_state(vol);
 
 	return rc;
@@ -213,5 +213,5 @@
 }
 
-static void hr_raid1_update_vol_status(hr_volume_t *vol)
+static void hr_raid1_update_vol_state(hr_volume_t *vol)
 {
 	bool exp = true;
@@ -231,5 +231,5 @@
 	fibril_rwlock_read_lock(&vol->states_lock);
 
-	hr_vol_status_t old_state = vol->status;
+	hr_vol_state_t old_state = vol->state;
 	size_t healthy = hr_count_extents(vol, HR_EXT_ONLINE);
 
@@ -240,5 +240,5 @@
 		if (old_state != HR_VOL_FAULTY) {
 			fibril_rwlock_write_lock(&vol->states_lock);
-			hr_update_vol_status(vol, HR_VOL_FAULTY);
+			hr_update_vol_state(vol, HR_VOL_FAULTY);
 			fibril_rwlock_write_unlock(&vol->states_lock);
 		}
@@ -247,5 +247,5 @@
 		    old_state != HR_VOL_DEGRADED) {
 			fibril_rwlock_write_lock(&vol->states_lock);
-			hr_update_vol_status(vol, HR_VOL_DEGRADED);
+			hr_update_vol_state(vol, HR_VOL_DEGRADED);
 			fibril_rwlock_write_unlock(&vol->states_lock);
 		}
@@ -265,5 +265,5 @@
 		if (old_state != HR_VOL_ONLINE) {
 			fibril_rwlock_write_lock(&vol->states_lock);
-			hr_update_vol_status(vol, HR_VOL_ONLINE);
+			hr_update_vol_state(vol, HR_VOL_ONLINE);
 			fibril_rwlock_write_unlock(&vol->states_lock);
 		}
@@ -283,11 +283,11 @@
 	switch (rc) {
 	case ENOMEM:
-		hr_update_ext_status(vol, extent, HR_EXT_INVALID);
+		hr_update_ext_state(vol, extent, HR_EXT_INVALID);
 		break;
 	case ENOENT:
-		hr_update_ext_status(vol, extent, HR_EXT_MISSING);
+		hr_update_ext_state(vol, extent, HR_EXT_MISSING);
 		break;
 	default:
-		hr_update_ext_status(vol, extent, HR_EXT_FAILED);
+		hr_update_ext_state(vol, extent, HR_EXT_FAILED);
 	}
 
@@ -305,6 +305,6 @@
 	size_t count = 0;
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_ONLINE ||
-		    (vol->extents[i].status == HR_EXT_REBUILD &&
+		if (vol->extents[i].state == HR_EXT_ONLINE ||
+		    (vol->extents[i].state == HR_EXT_REBUILD &&
 		    ba < rebuild_blk)) {
 			count++;
@@ -326,5 +326,5 @@
 
 	fibril_rwlock_read_lock(&vol->states_lock);
-	hr_vol_status_t vol_state = vol->status;
+	hr_vol_state_t vol_state = vol->state;
 	fibril_rwlock_read_unlock(&vol->states_lock);
 
@@ -358,5 +358,5 @@
 		for (i = 0; i < vol->extent_no; i++) {
 			fibril_rwlock_read_lock(&vol->states_lock);
-			hr_ext_status_t state = vol->extents[i].status;
+			hr_ext_state_t state = vol->extents[i].state;
 			fibril_rwlock_read_unlock(&vol->states_lock);
 
@@ -412,6 +412,6 @@
 
 		for (i = 0; i < vol->extent_no; i++) {
-			if (vol->extents[i].status != HR_EXT_ONLINE &&
-			    (vol->extents[i].status != HR_EXT_REBUILD ||
+			if (vol->extents[i].state != HR_EXT_ONLINE &&
+			    (vol->extents[i].state != HR_EXT_REBUILD ||
 			    ba >= rebuild_blk)) {
 				/*
@@ -458,5 +458,5 @@
 	fibril_rwlock_read_unlock(&vol->extents_lock);
 
-	hr_raid1_update_vol_status(vol);
+	hr_raid1_update_vol_state(vol);
 
 	return rc;
@@ -533,5 +533,5 @@
 	fibril_rwlock_write_lock(&vol->states_lock);
 
-	hr_update_ext_status(vol, rebuild_idx, HR_EXT_ONLINE);
+	hr_update_ext_state(vol, rebuild_idx, HR_EXT_ONLINE);
 
 	/*
@@ -541,5 +541,5 @@
 	 * state accordingly.
 	 */
-	hr_update_vol_status(vol, HR_VOL_ONLINE);
+	hr_update_vol_state(vol, HR_VOL_ONLINE);
 	hr_mark_vol_state_dirty(vol);
 
@@ -558,5 +558,5 @@
 		 */
 		fibril_rwlock_write_lock(&vol->states_lock);
-		hr_update_vol_status(vol, HR_VOL_DEGRADED);
+		hr_update_vol_state(vol, HR_VOL_DEGRADED);
 		hr_mark_vol_state_dirty(vol);
 		fibril_rwlock_write_unlock(&vol->states_lock);
@@ -565,5 +565,5 @@
 	fibril_rwlock_read_unlock(&vol->extents_lock);
 
-	hr_raid1_update_vol_status(vol);
+	hr_raid1_update_vol_state(vol);
 
 	if (buf != NULL)
@@ -591,5 +591,5 @@
 	size_t bad = vol->extent_no;
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status != HR_EXT_ONLINE) {
+		if (vol->extents[i].state != HR_EXT_ONLINE) {
 			bad = i;
 			break;
@@ -606,5 +606,5 @@
 	size_t hotspare_idx = vol->hotspare_no - 1;
 
-	hr_ext_status_t hs_state = vol->hotspares[hotspare_idx].status;
+	hr_ext_state_t hs_state = vol->hotspares[hotspare_idx].state;
 	if (hs_state != HR_EXT_HOTSPARE) {
 		HR_ERROR("hr_raid1_rebuild(): invalid hotspare state \"%s\", "
@@ -628,6 +628,6 @@
 	atomic_store_explicit(&vol->rebuild_blk, 0, memory_order_relaxed);
 
-	hr_update_ext_status(vol, bad, HR_EXT_REBUILD);
-	hr_update_vol_status(vol, HR_VOL_REBUILD);
+	hr_update_ext_state(vol, bad, HR_EXT_REBUILD);
+	hr_update_vol_state(vol, HR_VOL_REBUILD);
 
 	*rebuild_idx = bad;
@@ -648,8 +648,8 @@
 
 	hr_update_ext_svc_id(vol, bad, hs_svc_id);
-	hr_update_ext_status(vol, bad, HR_EXT_HOTSPARE);
+	hr_update_ext_state(vol, bad, HR_EXT_HOTSPARE);
 
 	hr_update_hotspare_svc_id(vol, hs, 0);
-	hr_update_hotspare_status(vol, hs, HR_EXT_MISSING);
+	hr_update_hotspare_state(vol, hs, HR_EXT_MISSING);
 
 	vol->hotspare_no--;
@@ -670,8 +670,8 @@
 
 	fibril_rwlock_read_lock(&vol->states_lock);
-	hr_ext_status_t rebuild_ext_status = rebuild_ext->status;
+	hr_ext_state_t rebuild_ext_state = rebuild_ext->state;
 	fibril_rwlock_read_unlock(&vol->states_lock);
 
-	if (rebuild_ext_status != HR_EXT_REBUILD)
+	if (rebuild_ext_state != HR_EXT_REBUILD)
 		return EINVAL;
 
@@ -679,5 +679,5 @@
 		fibril_rwlock_read_lock(&vol->states_lock);
 		ext = &vol->extents[i];
-		if (ext->status != HR_EXT_ONLINE) {
+		if (ext->state != HR_EXT_ONLINE) {
 			fibril_rwlock_read_unlock(&vol->states_lock);
 			continue;
Index: uspace/srv/bd/hr/raid5.c
===================================================================
--- uspace/srv/bd/hr/raid5.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/raid5.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -56,5 +56,5 @@
 static errno_t	hr_raid5_vol_usable(hr_volume_t *);
 static ssize_t	hr_raid5_get_bad_ext(hr_volume_t *);
-static errno_t	hr_raid5_update_vol_status(hr_volume_t *);
+static errno_t	hr_raid5_update_vol_state(hr_volume_t *);
 static void	hr_raid5_handle_extent_error(hr_volume_t *, size_t, errno_t);
 static void	xor(void *, const void *, size_t);
@@ -105,5 +105,5 @@
 	fibril_rwlock_write_lock(&new_volume->states_lock);
 
-	errno_t rc = hr_raid5_update_vol_status(new_volume);
+	errno_t rc = hr_raid5_update_vol_state(new_volume);
 	if (rc != EOK) {
 		HR_NOTE("\"%s\": unusable state, not creating\n",
@@ -145,9 +145,9 @@
 }
 
-void hr_raid5_status_event(hr_volume_t *vol)
+void hr_raid5_state_event(hr_volume_t *vol)
 {
 	fibril_mutex_lock(&vol->lock);
 	fibril_rwlock_write_lock(&vol->states_lock);
-	(void)hr_raid5_update_vol_status(vol);
+	(void)hr_raid5_update_vol_state(vol);
 	fibril_rwlock_write_unlock(&vol->states_lock);
 	fibril_mutex_unlock(&vol->lock);
@@ -167,5 +167,5 @@
 	 * If the volume is degraded, start rebuild right away.
 	 */
-	if (vol->status == HR_VOL_DEGRADED) {
+	if (vol->state == HR_VOL_DEGRADED) {
 		HR_DEBUG("hr_raid5_add_hotspare(): volume in DEGRADED state, "
 		    "spawning new rebuild fibril\n");
@@ -243,7 +243,7 @@
 static errno_t hr_raid5_vol_usable(hr_volume_t *vol)
 {
-	if (vol->status == HR_VOL_ONLINE ||
-	    vol->status == HR_VOL_DEGRADED ||
-	    vol->status == HR_VOL_REBUILD)
+	if (vol->state == HR_VOL_ONLINE ||
+	    vol->state == HR_VOL_DEGRADED ||
+	    vol->state == HR_VOL_REBUILD)
 		return EOK;
 	return EIO;
@@ -257,15 +257,15 @@
 {
 	for (size_t i = 0; i < vol->extent_no; i++)
-		if (vol->extents[i].status != HR_EXT_ONLINE)
+		if (vol->extents[i].state != HR_EXT_ONLINE)
 			return i;
 	return -1;
 }
 
-static errno_t hr_raid5_update_vol_status(hr_volume_t *vol)
-{
-	hr_vol_status_t old_state = vol->status;
+static errno_t hr_raid5_update_vol_state(hr_volume_t *vol)
+{
+	hr_vol_state_t old_state = vol->state;
 	size_t bad = 0;
 	for (size_t i = 0; i < vol->extent_no; i++)
-		if (vol->extents[i].status != HR_EXT_ONLINE)
+		if (vol->extents[i].state != HR_EXT_ONLINE)
 			bad++;
 
@@ -273,5 +273,5 @@
 	case 0:
 		if (old_state != HR_VOL_ONLINE)
-			hr_update_vol_status(vol, HR_VOL_ONLINE);
+			hr_update_vol_state(vol, HR_VOL_ONLINE);
 		return EOK;
 	case 1:
@@ -279,5 +279,5 @@
 		    old_state != HR_VOL_REBUILD) {
 
-			hr_update_vol_status(vol, HR_VOL_DEGRADED);
+			hr_update_vol_state(vol, HR_VOL_DEGRADED);
 
 			if (vol->hotspare_no > 0) {
@@ -293,5 +293,5 @@
 	default:
 		if (old_state != HR_VOL_FAULTY)
-			hr_update_vol_status(vol, HR_VOL_FAULTY);
+			hr_update_vol_state(vol, HR_VOL_FAULTY);
 		return EIO;
 	}
@@ -302,7 +302,7 @@
 {
 	if (rc == ENOENT)
-		hr_update_ext_status(vol, extent, HR_EXT_MISSING);
+		hr_update_ext_state(vol, extent, HR_EXT_MISSING);
 	else if (rc != EOK)
-		hr_update_ext_status(vol, extent, HR_EXT_FAILED);
+		hr_update_ext_state(vol, extent, HR_EXT_FAILED);
 }
 
@@ -537,5 +537,5 @@
 	if (type == HR_BD_SYNC && ba == 0 && cnt == 0) {
 		hr_sync_all_extents(vol);
-		rc = hr_raid5_update_vol_status(vol);
+		rc = hr_raid5_update_vol_state(vol);
 		return rc;
 	}
@@ -611,5 +611,5 @@
 		switch (type) {
 		case HR_BD_SYNC:
-			if (vol->extents[extent].status != HR_EXT_ONLINE)
+			if (vol->extents[extent].state != HR_EXT_ONLINE)
 				break;
 			rc = block_sync_cache(vol->extents[extent].svc_id,
@@ -648,5 +648,5 @@
 
 		if (rc != EOK) {
-			rc = hr_raid5_update_vol_status(vol);
+			rc = hr_raid5_update_vol_state(vol);
 			if (rc == EOK) {
 				/*
@@ -700,5 +700,5 @@
 
 error:
-	(void)hr_raid5_update_vol_status(vol);
+	(void)hr_raid5_update_vol_state(vol);
 	fibril_rwlock_write_unlock(&vol->states_lock);
 	fibril_mutex_unlock(&vol->lock);
@@ -727,5 +727,5 @@
 	size_t bad = vol->extent_no;
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status == HR_EXT_FAILED) {
+		if (vol->extents[i].state == HR_EXT_FAILED) {
 			bad = i;
 			break;
@@ -742,5 +742,5 @@
 	size_t hotspare_idx = vol->hotspare_no - 1;
 
-	hr_ext_status_t hs_state = vol->hotspares[hotspare_idx].status;
+	hr_ext_state_t hs_state = vol->hotspares[hotspare_idx].state;
 	if (hs_state != HR_EXT_HOTSPARE) {
 		HR_ERROR("hr_raid5_rebuild(): invalid hotspare state \"%s\", "
@@ -755,9 +755,9 @@
 
 	vol->extents[bad].svc_id = vol->hotspares[hotspare_idx].svc_id;
-	hr_update_ext_status(vol, bad, HR_EXT_HOTSPARE);
+	hr_update_ext_state(vol, bad, HR_EXT_HOTSPARE);
 
 	vol->hotspares[hotspare_idx].svc_id = 0;
 	fibril_mutex_lock(&vol->hotspare_lock);
-	hr_update_hotspare_status(vol, hotspare_idx, HR_EXT_MISSING);
+	hr_update_hotspare_state(vol, hotspare_idx, HR_EXT_MISSING);
 	fibril_mutex_unlock(&vol->hotspare_lock);
 
@@ -769,6 +769,6 @@
 	    rebuild_ext->svc_id);
 
-	hr_update_ext_status(vol, bad, HR_EXT_REBUILD);
-	hr_update_vol_status(vol, HR_VOL_REBUILD);
+	hr_update_ext_state(vol, bad, HR_EXT_REBUILD);
+	hr_update_vol_state(vol, HR_VOL_REBUILD);
 
 	uint64_t max_blks = DATA_XFER_LIMIT / vol->bsize;
@@ -838,10 +838,10 @@
 	    "extent number %zu\n", vol->devname, vol->svc_id, hotspare_idx);
 
-	hr_update_ext_status(vol, bad, HR_EXT_ONLINE);
+	hr_update_ext_state(vol, bad, HR_EXT_ONLINE);
 
 	rc = vol->meta_ops->save(vol, WITH_STATE_CALLBACK);
 
 end:
-	(void)hr_raid5_update_vol_status(vol);
+	(void)hr_raid5_update_vol_state(vol);
 
 	fibril_rwlock_write_unlock(&vol->states_lock);
Index: uspace/srv/bd/hr/util.c
===================================================================
--- uspace/srv/bd/hr/util.c	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/util.c	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -98,10 +98,10 @@
 		vol->hr_ops.create = hr_raid0_create;
 		vol->hr_ops.init = hr_raid0_init;
-		vol->hr_ops.status_event = hr_raid0_status_event;
+		vol->hr_ops.state_event = hr_raid0_state_event;
 		break;
 	case HR_LVL_1:
 		vol->hr_ops.create = hr_raid1_create;
 		vol->hr_ops.init = hr_raid1_init;
-		vol->hr_ops.status_event = hr_raid1_status_event;
+		vol->hr_ops.state_event = hr_raid1_state_event;
 		if (meta_flags & HR_METADATA_HOTSPARE_SUPPORT)
 			vol->hr_ops.add_hotspare = hr_raid1_add_hotspare;
@@ -111,5 +111,5 @@
 		vol->hr_ops.create = hr_raid5_create;
 		vol->hr_ops.init = hr_raid5_init;
-		vol->hr_ops.status_event = hr_raid5_status_event;
+		vol->hr_ops.state_event = hr_raid5_state_event;
 		if (meta_flags & HR_METADATA_HOTSPARE_SUPPORT)
 			vol->hr_ops.add_hotspare = hr_raid5_add_hotspare;
@@ -134,5 +134,5 @@
 	}
 
-	vol->status = HR_VOL_NONE;
+	vol->state = HR_VOL_NONE;
 
 	fibril_mutex_initialize(&vol->lock); /* XXX: will remove this */
@@ -268,5 +268,5 @@
 
 		vol->extents[i].svc_id = svc_id;
-		vol->extents[i].status = HR_EXT_ONLINE;
+		vol->extents[i].state = HR_EXT_ONLINE;
 
 		if (blkno < smallest_blkno)
@@ -280,5 +280,5 @@
 
 	for (i = 0; i < HR_MAX_HOTSPARES; i++)
-		vol->hotspares[i].status = HR_EXT_MISSING;
+		vol->hotspares[i].state = HR_EXT_MISSING;
 
 	return EOK;
@@ -374,5 +374,5 @@
 }
 
-void hr_update_ext_status(hr_volume_t *vol, size_t ext_idx, hr_ext_status_t s)
+void hr_update_ext_state(hr_volume_t *vol, size_t ext_idx, hr_ext_state_t s)
 {
 	if (vol->level != HR_LVL_0)
@@ -383,13 +383,13 @@
 	assert(ext_idx < vol->extent_no);
 
-	hr_ext_status_t old = vol->extents[ext_idx].status;
+	hr_ext_state_t old = vol->extents[ext_idx].state;
 	HR_NOTE("\"%s\": changing extent %zu state: %s -> %s\n",
 	    vol->devname, ext_idx, hr_get_ext_state_str(old),
 	    hr_get_ext_state_str(s));
-	vol->extents[ext_idx].status = s;
-}
-
-void hr_update_hotspare_status(hr_volume_t *vol, size_t hs_idx,
-    hr_ext_status_t s)
+	vol->extents[ext_idx].state = s;
+}
+
+void hr_update_hotspare_state(hr_volume_t *vol, size_t hs_idx,
+    hr_ext_state_t s)
 {
 	assert(fibril_mutex_is_locked(&vol->hotspare_lock));
@@ -397,18 +397,18 @@
 	assert(hs_idx < vol->hotspare_no);
 
-	hr_ext_status_t old = vol->hotspares[hs_idx].status;
+	hr_ext_state_t old = vol->hotspares[hs_idx].state;
 	HR_NOTE("\"%s\": changing hotspare %zu state: %s -> %s\n",
 	    vol->devname, hs_idx, hr_get_ext_state_str(old),
 	    hr_get_ext_state_str(s));
-	vol->hotspares[hs_idx].status = s;
-}
-
-void hr_update_vol_status(hr_volume_t *vol, hr_vol_status_t new)
+	vol->hotspares[hs_idx].state = s;
+}
+
+void hr_update_vol_state(hr_volume_t *vol, hr_vol_state_t new)
 {
 	assert(fibril_rwlock_is_write_locked(&vol->states_lock));
 
 	HR_NOTE("\"%s\": changing volume state: %s -> %s\n", vol->devname,
-	    hr_get_vol_state_str(vol->status), hr_get_vol_state_str(new));
-	vol->status = new;
+	    hr_get_vol_state_str(vol->state), hr_get_vol_state_str(new));
+	vol->state = new;
 }
 
@@ -441,8 +441,8 @@
 /*
  * Do a whole sync (ba = 0, cnt = 0) across all extents,
- * and update extent status. *For now*, the caller has to
- * update volume status after the syncs.
+ * and update extent state. *For now*, the caller has to
+ * update volume state after the syncs.
  *
- * TODO: add update_vol_status fcn ptr for each raid
+ * TODO: add update_vol_state fcn ptr for each raid
  */
 void hr_sync_all_extents(hr_volume_t *vol)
@@ -452,5 +452,5 @@
 	fibril_mutex_lock(&vol->lock);
 	for (size_t i = 0; i < vol->extent_no; i++) {
-		if (vol->extents[i].status != HR_EXT_ONLINE)
+		if (vol->extents[i].state != HR_EXT_ONLINE)
 			continue;
 		rc = block_sync_cache(vol->extents[i].svc_id, 0, 0);
@@ -459,7 +459,7 @@
 		if (rc != EOK) {
 			if (rc == ENOENT)
-				hr_update_ext_status(vol, i, HR_EXT_MISSING);
+				hr_update_ext_state(vol, i, HR_EXT_MISSING);
 			else if (rc != EOK)
-				hr_update_ext_status(vol, i, HR_EXT_FAILED);
+				hr_update_ext_state(vol, i, HR_EXT_FAILED);
 		}
 	}
@@ -467,5 +467,5 @@
 }
 
-size_t hr_count_extents(hr_volume_t *vol, hr_ext_status_t status)
+size_t hr_count_extents(hr_volume_t *vol, hr_ext_state_t state)
 {
 	if (vol->level != HR_LVL_0)
@@ -475,5 +475,5 @@
 	size_t count = 0;
 	for (size_t i = 0; i < vol->extent_no; i++)
-		if (vol->extents[i].status == status)
+		if (vol->extents[i].state == state)
 			count++;
 
@@ -1052,5 +1052,5 @@
 
 	hr_update_hotspare_svc_id(vol, hs_idx, hotspare);
-	hr_update_hotspare_status(vol, hs_idx, HR_EXT_HOTSPARE);
+	hr_update_hotspare_state(vol, hs_idx, HR_EXT_HOTSPARE);
 
 	hr_mark_vol_state_dirty(vol);
Index: uspace/srv/bd/hr/util.h
===================================================================
--- uspace/srv/bd/hr/util.h	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/util.h	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -77,9 +77,9 @@
 extern errno_t		 hr_check_ba_range(hr_volume_t *, size_t, uint64_t);
 extern void		 hr_add_ba_offset(hr_volume_t *, uint64_t *);
-extern void		 hr_update_ext_status(hr_volume_t *, size_t,
-    hr_ext_status_t);
-extern void		 hr_update_hotspare_status(hr_volume_t *, size_t,
-    hr_ext_status_t);
-extern void		 hr_update_vol_status(hr_volume_t *, hr_vol_status_t);
+extern void		 hr_update_ext_state(hr_volume_t *, size_t,
+    hr_ext_state_t);
+extern void		 hr_update_hotspare_state(hr_volume_t *, size_t,
+    hr_ext_state_t);
+extern void		 hr_update_vol_state(hr_volume_t *, hr_vol_state_t);
 extern void		 hr_update_ext_svc_id(hr_volume_t *, size_t,
     service_id_t);
@@ -87,5 +87,5 @@
     service_id_t);
 extern void		 hr_sync_all_extents(hr_volume_t *);
-extern size_t		 hr_count_extents(hr_volume_t *, hr_ext_status_t);
+extern size_t		 hr_count_extents(hr_volume_t *, hr_ext_state_t);
 extern void		 hr_mark_vol_state_dirty(hr_volume_t *);
 extern void		 hr_range_lock_release(hr_range_lock_t *);
Index: uspace/srv/bd/hr/var.h
===================================================================
--- uspace/srv/bd/hr/var.h	(revision 155d34fab0cbaad1a3fb64bb7f99b7e653b5d098)
+++ uspace/srv/bd/hr/var.h	(revision 56602e01dd921b17bea4aa87f346c2b2fea742a0)
@@ -58,5 +58,5 @@
 	errno_t		(*create)(hr_volume_t *);
 	errno_t		(*init)(hr_volume_t *);
-	void		(*status_event)(hr_volume_t *);
+	void		(*state_event)(hr_volume_t *);
 	errno_t		(*add_hotspare)(hr_volume_t *, service_id_t);
 } hr_ops_t;
@@ -103,5 +103,5 @@
 	_Atomic uint64_t rebuild_blk;		/* rebuild position */
 	_Atomic int	 open_cnt;		/* open/close() counter */
-	hr_vol_status_t	 status;		/* volume status */
+	hr_vol_state_t	 state;			/* volume state */
 	void		 (*state_callback)(hr_volume_t *, size_t, errno_t);
 } hr_volume_t;
@@ -136,7 +136,7 @@
 extern errno_t 		hr_raid5_init(hr_volume_t *);
 
-extern void		hr_raid0_status_event(hr_volume_t *);
-extern void		hr_raid1_status_event(hr_volume_t *);
-extern void		hr_raid5_status_event(hr_volume_t *);
+extern void		hr_raid0_state_event(hr_volume_t *);
+extern void		hr_raid1_state_event(hr_volume_t *);
+extern void		hr_raid5_state_event(hr_volume_t *);
 
 extern errno_t		hr_raid1_add_hotspare(hr_volume_t *, service_id_t);
