6510052 Wrong error message for "-z" option

6510054 raidctl "-s" option can not work correctly
6510056 raidctl should display correct disk infomation of array
6568605 raidctl mpt plugin cystle clean for continuation checking
6570499 raidctl cli cystle clean for continuation checking
6570500 raidctl common library cystle clean for continuation checking
6571564 raidctl failed when disk member is missing on SAS device

2 files changed, 212 insertions, 205 deletions

diff --git a/usr/src/cmd/raidctl/raidctl.c b/usr/src/cmd/raidctl/raidctl.c
index dcee7f7ef9..659b98f194 100644
--- a/usr/src/cmd/raidctl/raidctl.c
+++ b/usr/src/cmd/raidctl/raidctl.c
@@ -933,7 +933,7 @@ do_list(char *disk_argp, char **argv, uint32_t optind, uint8_t is_snapshot)
 					} else {
 						ret =
 						    snapshot_ctl(ctl_handle,
-							FALSE, 0, is_snapshot);
+						    FALSE, 0, is_snapshot);
 					}
 					(void) raidcfg_close_controller(
 					    ctl_handle, NULL);
@@ -1071,7 +1071,7 @@ do_delete(uint32_t f_flag, char **argv, uint32_t optind)
 	if (f_flag == FALSE) {
 		(void) fprintf(stdout, gettext("Deleting RAID volume "
 		    "%s will destroy all data it contains, "
-			"proceed (%s/%s)? "), array_argp, yesstr, nostr);
+		    "proceed (%s/%s)? "), array_argp, yesstr, nostr);
 		if (!yes()) {
 			(void) fprintf(stdout, gettext("RAID Volume "
 			    "%s not deleted.\n\n"), array_argp);
@@ -1576,10 +1576,10 @@ snapshot_array(raid_obj_handle_t array_handle, uint8_t indent, uint8_t is_sub,
 			}
 		} else {
 			subarray_handle = raidcfg_list_head(array_handle,
-							    OBJ_TYPE_ARRAY);
+			    OBJ_TYPE_ARRAY);
 			while (subarray_handle > 0) {
 				task_handle = raidcfg_list_head(subarray_handle,
-								OBJ_TYPE_TASK);
+				    OBJ_TYPE_TASK);
 				if (task_handle > 0) {
 					(void) raidcfg_get_attr(task_handle,
 					    &task_attr);
@@ -2690,6 +2690,11 @@ calc_size(char *sizep, uint64_t *valp)
 		return (INVALID_ARG);
 	}
 
+	if (is_fully_numeric(sizep) == TRUE) {
+		*valp = atoi(sizep);
+		return (SUCCESS);
+	}
+
 	len = strlen(sizep);
 	if (len == 0) {
 		return (INVALID_ARG);
diff --git a/usr/src/lib/libraidcfg/common/raidcfg.c b/usr/src/lib/libraidcfg/common/raidcfg.c
index e418fd4f39..a97d7106bf 100644
--- a/usr/src/lib/libraidcfg/common/raidcfg.c
+++ b/usr/src/lib/libraidcfg/common/raidcfg.c
@@ -333,11 +333,11 @@ raidcfg_errstr(int err_code)
 		break;
 	case	STD_IOCTL:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Request standard IOCTL service.\n");
+		    "Request standard IOCTL service.\n");
 		break;
 	case	ERR_DRIVER_NOT_FOUND:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Controller device can not be found.\n");
+		    "Controller device can not be found.\n");
 		break;
 	case	ERR_DRIVER_OPEN:
 		ret_val = dgettext(TEXT_DOMAIN, "Can not open controller.\n");
@@ -350,22 +350,22 @@ raidcfg_errstr(int err_code)
 		break;
 	case	ERR_DRIVER_ACROSS:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Operation across multiple controllers.\n");
+		    "Operation across multiple controllers.\n");
 		break;
 	case	ERR_ARRAY_LEVEL:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Operation not support with volume of this level.\n");
+		    "Operation not support with volume of this level.\n");
 		break;
 	case	ERR_ARRAY_SIZE:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Capacity of array out of range.\n");
+		    "Capacity of array out of range.\n");
 		break;
 	case	ERR_ARRAY_STRIPE_SIZE:
 		ret_val = dgettext(TEXT_DOMAIN, "Illegal stripe size.\n");
 		break;
 	case	ERR_ARRAY_CACHE_POLICY:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Illegal cache-write policy.\n");
+		    "Illegal cache-write policy.\n");
 		break;
 	case	ERR_ARRAY_IN_USE:
 		ret_val = dgettext(TEXT_DOMAIN, "Array or disk in use.\n");
@@ -375,7 +375,7 @@ raidcfg_errstr(int err_code)
 		break;
 	case	ERR_ARRAY_CONFIG:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Configuration over device node failed.\n");
+		    "Configuration over device node failed.\n");
 		break;
 	case	ERR_ARRAY_DISKNUM:
 		ret_val = dgettext(TEXT_DOMAIN, "Incorrect number of disks.\n");
@@ -388,7 +388,7 @@ raidcfg_errstr(int err_code)
 		break;
 	case	ERR_DISK_STATE:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Incorrect disk status for current operation.\n");
+		    "Incorrect disk status for current operation.\n");
 		break;
 	case	ERR_DISK_SPACE:
 		ret_val = dgettext(TEXT_DOMAIN, "No enough disk space.\n");
@@ -404,14 +404,14 @@ raidcfg_errstr(int err_code)
 		break;
 	case	ERR_TASK_STATE:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Incorrect task state for current operation.\n");
+		    "Incorrect task state for current operation.\n");
 		break;
 	case	ERR_OP_ILLEGAL:
 		ret_val = dgettext(TEXT_DOMAIN, "Illegal operation.\n");
 		break;
 	case	ERR_OP_NO_IMPL:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Operation is not implemented.\n");
+		    "Operation is not implemented.\n");
 		break;
 	case	ERR_OP_FAILED:
 		ret_val = dgettext(TEXT_DOMAIN, "Operation failed.\n");
@@ -436,7 +436,7 @@ raidcfg_errstr(int err_code)
 		break;
 	case	ERR_NOMEM:
 		ret_val = dgettext(TEXT_DOMAIN,
-			"Can not allocate more memory space.\n");
+		    "Can not allocate more memory space.\n");
 		break;
 	case	ERR_PRIV:
 		ret_val = dgettext(TEXT_DOMAIN, "No privilege.\n");
@@ -493,7 +493,7 @@ raidcfg_get_array(int controller_handle, uint64_t target_id, uint64_t lun)
 	while (obj_id > OBJ_NONE) {
 		(void) obj_get_attr(&raid_tab_sys, obj_id, (void **)(&attr));
 		if (attr->tag.idl.target_id == target_id &&
-			attr->tag.idl.lun == lun)
+		    attr->tag.idl.lun == lun)
 			break;
 
 		obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
@@ -570,7 +570,7 @@ raidcfg_open_controller(int handle, char **plugin_err_str)
 	}
 
 	ret = obj_controller_act(&raid_tab_sys, obj_id,
-		ACT_CONTROLLER_OPEN, NULL, plugin_err_str);
+	    ACT_CONTROLLER_OPEN, NULL, plugin_err_str);
 	if (ret < SUCCESS) {
 		(void) mutex_unlock(&raidcfg_mp);
 		return (ret);
@@ -596,7 +596,7 @@ raidcfg_close_controller(int handle, char **plugin_err_str)
 	}
 
 	ret = obj_controller_act(&raid_tab_sys, obj_id,
-		ACT_CONTROLLER_CLOSE, NULL, plugin_err_str);
+	    ACT_CONTROLLER_CLOSE, NULL, plugin_err_str);
 	if (ret < SUCCESS) {
 		(void) mutex_unlock(&raidcfg_mp);
 		return (ret);
@@ -674,7 +674,7 @@ raidcfg_get_attr(int handle, void *attr)
 
 			obj_id = obj_get_controller(&raid_tab_sys, obj_id);
 			ret = obj_get_attr(&raid_tab_sys, obj_id,
-				(void **)(&ctlr_attr));
+			    (void **)(&ctlr_attr));
 			if (ret < SUCCESS) {
 				(void) mutex_unlock(&raidcfg_mp);
 				return (ret);
@@ -682,17 +682,17 @@ raidcfg_get_attr(int handle, void *attr)
 
 			if (src->type == HSP_TYPE_LOCAL) {
 				obj_id = obj_locate_array(&raid_tab_sys,
-					ctlr_attr->controller_id,
-					src->associated_id);
+				    ctlr_attr->controller_id,
+				    src->associated_id);
 				ret = obj_get_attr(&raid_tab_sys, obj_id,
-					(void **)(&array_attr));
+				    (void **)(&array_attr));
 				if (ret < SUCCESS) {
 					(void) mutex_unlock(&raidcfg_mp);
 					return (ret);
 				}
 
 				dst->tag.idl.target_id =
-					array_attr->tag.idl.target_id;
+				    array_attr->tag.idl.target_id;
 				dst->tag.idl.lun = array_attr->tag.idl.lun;
 			}
 		}
@@ -715,14 +715,14 @@ raidcfg_get_attr(int handle, void *attr)
 
 			obj_id = obj_get_controller(&raid_tab_sys, obj_id);
 			ret = obj_get_attr(&raid_tab_sys, obj_id,
-				(void **)(&ctlr_attr));
+			    (void **)(&ctlr_attr));
 			if (ret < SUCCESS) {
 				(void) mutex_unlock(&raidcfg_mp);
 				return (ret);
 			}
 
 			obj_id = obj_locate_disk(&raid_tab_sys,
-				ctlr_attr->controller_id, src->disk_id);
+			    ctlr_attr->controller_id, src->disk_id);
 			if (obj_id <= OBJ_NONE) {
 				dst->tag.cidl.bus = (uint64_t)OBJ_ATTR_NONE;
 				dst->tag.cidl.target_id =
@@ -733,7 +733,7 @@ raidcfg_get_attr(int handle, void *attr)
 			}
 
 			ret = obj_get_attr(&raid_tab_sys, obj_id,
-				(void **)(&disk_attr));
+			    (void **)(&disk_attr));
 			if (ret < SUCCESS) {
 				(void) mutex_unlock(&raidcfg_mp);
 				return (ret);
@@ -864,7 +864,7 @@ raidcfg_set_attr(int handle, uint32_t set_cmd, void *value,
 	}
 
 	ret = raid_obj_op_sys[type].set_attr(&raid_tab_sys,
-		obj_id, set_cmd, value, plugin_err_str);
+	    obj_id, set_cmd, value, plugin_err_str);
 
 	(void) mutex_unlock(&raidcfg_mp);
 	return (ret);
@@ -891,7 +891,7 @@ raidcfg_update_fw(int handle, char *file, char **plugin_err_str)
 	}
 
 	ret = raid_obj_op_sys[OBJ_TYPE_CONTROLLER].act(&raid_tab_sys,
-		obj_id, ACT_CONTROLLER_FLASH_FW, file, plugin_err_str);
+	    obj_id, ACT_CONTROLLER_FLASH_FW, file, plugin_err_str);
 
 	(void) mutex_unlock(&raidcfg_mp);
 	return (ret);
@@ -919,15 +919,15 @@ raidcfg_create_array(int num_of_comps, int *disk_handles,
 	/* convert disk handles into disk object ids; */
 	for (i = 0; i < num_of_comps; ++i) {
 		if (*(disk_handles + i) == OBJ_SEPARATOR_BEGIN ||
-			*(disk_handles + i) == OBJ_SEPARATOR_END) {
+		    *(disk_handles + i) == OBJ_SEPARATOR_END) {
 			*(disk_obj_ids + i) = *(disk_handles + i);
 			continue;
 		}
 
 		*(disk_obj_ids + i) = raid_handle_to_obj(&raid_tab_sys,
-			*(disk_handles + i));
+		    *(disk_handles + i));
 		if (raid_obj_get_type(&raid_tab_sys, *(disk_obj_ids + i)) !=
-			OBJ_TYPE_DISK) {
+		    OBJ_TYPE_DISK) {
 			free(disk_obj_ids);
 			(void) obj_rescan(&raid_tab_sys);
 			(void) mutex_unlock(&raidcfg_mp);
@@ -944,7 +944,7 @@ raidcfg_create_array(int num_of_comps, int *disk_handles,
 		return (obj_id);
 	}
 	(void) raid_obj_clear_status(&raid_tab_sys, obj_id,
-		OBJ_STATUS_CMD_CLEAN);
+	    OBJ_STATUS_CMD_CLEAN);
 
 	array_attr = raid_obj_get_data_ptr(&raid_tab_sys, obj_id);
 	array_attr->array_id = (uint32_t)OBJ_ATTR_NONE;
@@ -955,7 +955,7 @@ raidcfg_create_array(int num_of_comps, int *disk_handles,
 	array_attr->read_policy = CACHE_RD_ON;
 
 	ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].create_obj(&raid_tab_sys, obj_id,
-		num_of_comps, disk_obj_ids, plugin_err_str);
+	    num_of_comps, disk_obj_ids, plugin_err_str);
 	free(disk_obj_ids);
 
 	if (ret < SUCCESS) {
@@ -997,7 +997,7 @@ raidcfg_delete_array(int array_handle, char **plugin_err_str)
 	}
 
 	ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].delete_obj(&raid_tab_sys,
-		array_obj_id, plugin_err_str);
+	    array_obj_id, plugin_err_str);
 	(void) obj_rescan(&raid_tab_sys);
 
 	(void) mutex_unlock(&raidcfg_mp);
@@ -1030,7 +1030,7 @@ raidcfg_set_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 	for (i = 0; i < num; ++ i) {
 		if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
 			array_obj_id = raid_handle_to_obj(&raid_tab_sys,
-				hsp_relations[i].array_handle);
+			    hsp_relations[i].array_handle);
 			if (array_obj_id < OBJ_NONE) {
 				free(hsp_relation_objs);
 				(void) mutex_unlock(&raidcfg_mp);
@@ -1042,7 +1042,7 @@ raidcfg_set_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 				return (ERR_DEVICE_NOENT);
 			}
 			if (raidcfg_get_type(hsp_relations[i].array_handle) !=
-				OBJ_TYPE_ARRAY) {
+			    OBJ_TYPE_ARRAY) {
 				free(hsp_relation_objs);
 				(void) mutex_unlock(&raidcfg_mp);
 				return (ERR_DEVICE_TYPE);
@@ -1051,7 +1051,7 @@ raidcfg_set_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 			array_obj_id = OBJ_ATTR_NONE;
 
 		disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
-			hsp_relations[i].disk_handle);
+		    hsp_relations[i].disk_handle);
 		if (disk_obj_id < OBJ_NONE) {
 			free(hsp_relation_objs);
 			(void) mutex_unlock(&raidcfg_mp);
@@ -1063,7 +1063,7 @@ raidcfg_set_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 			return (ERR_DEVICE_NOENT);
 		}
 		if (raidcfg_get_type(hsp_relations[i].disk_handle) !=
-			OBJ_TYPE_DISK) {
+		    OBJ_TYPE_DISK) {
 			free(hsp_relation_objs);
 			(void) mutex_unlock(&raidcfg_mp);
 			return (ERR_DEVICE_TYPE);
@@ -1074,7 +1074,7 @@ raidcfg_set_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 	}
 
 	ret = raid_obj_op_sys[OBJ_TYPE_HSP].bind_obj(&raid_tab_sys, num,
-		hsp_relation_objs, plugin_err_str);
+	    hsp_relation_objs, plugin_err_str);
 
 	(void) obj_rescan(&raid_tab_sys);
 	free(hsp_relation_objs);
@@ -1109,7 +1109,7 @@ raidcfg_unset_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 	for (i = 0; i < num; ++ i) {
 		if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
 			array_obj_id = raid_handle_to_obj(&raid_tab_sys,
-				hsp_relations[i].array_handle);
+			    hsp_relations[i].array_handle);
 			if (array_obj_id < OBJ_NONE) {
 				free(hsp_relation_objs);
 				(void) mutex_unlock(&raidcfg_mp);
@@ -1121,7 +1121,7 @@ raidcfg_unset_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 				return (ERR_DEVICE_NOENT);
 			}
 			if (raidcfg_get_type(hsp_relations[i].array_handle) !=
-				OBJ_TYPE_ARRAY) {
+			    OBJ_TYPE_ARRAY) {
 				free(hsp_relation_objs);
 				(void) mutex_unlock(&raidcfg_mp);
 				return (ERR_DEVICE_TYPE);
@@ -1130,7 +1130,7 @@ raidcfg_unset_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 			array_obj_id = OBJ_ATTR_NONE;
 
 		disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
-			hsp_relations[i].disk_handle);
+		    hsp_relations[i].disk_handle);
 		if (disk_obj_id < OBJ_NONE) {
 			free(hsp_relation_objs);
 			(void) mutex_unlock(&raidcfg_mp);
@@ -1142,7 +1142,7 @@ raidcfg_unset_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 			return (ERR_DEVICE_NOENT);
 		}
 		if (raidcfg_get_type(hsp_relations[i].disk_handle) !=
-			OBJ_TYPE_DISK) {
+		    OBJ_TYPE_DISK) {
 			free(hsp_relation_objs);
 			(void) mutex_unlock(&raidcfg_mp);
 			return (ERR_DEVICE_TYPE);
@@ -1153,7 +1153,7 @@ raidcfg_unset_hsp(int num, raidcfg_hsp_relation_t *hsp_relations,
 	}
 
 	ret = raid_obj_op_sys[OBJ_TYPE_HSP].unbind_obj(&raid_tab_sys,
-		num, hsp_relation_objs, plugin_err_str);
+	    num, hsp_relation_objs, plugin_err_str);
 
 	(void) obj_rescan(&raid_tab_sys);
 	free(hsp_relation_objs);
@@ -1212,13 +1212,13 @@ raid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
 	/* Find out the maximum available space for all disks */
 	for (i = 0; i < num; ++i) {
 		if ((disk_objs[i] == OBJ_SEPARATOR_BEGIN) ||
-			(disk_objs[i] == OBJ_SEPARATOR_END))
+		    (disk_objs[i] == OBJ_SEPARATOR_END))
 			continue;
 
 		(void) obj_get_attr(raid_tab, disk_objs[i],
-			(void **)(&disk_attr));
+		    (void **)(&disk_attr));
 		obj_id = obj_get_comp(raid_tab, disk_objs[i],
-			OBJ_TYPE_DISK_SEG);
+		    OBJ_TYPE_DISK_SEG);
 		if (obj_id == OBJ_NONE) {
 			arraypart_attrs[i].offset = 0;
 			arraypart_attrs[i].size = disk_attr->capacity;
@@ -1226,7 +1226,7 @@ raid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
 		}
 
 		(void) obj_get_attr(raid_tab, obj_id, (void **)
-			(&diskseg_attr));
+		    (&diskseg_attr));
 		arraypart_attrs[i].offset = 0;
 		arraypart_attrs[i].size = diskseg_attr->offset;
 		offset = diskseg_attr->offset + diskseg_attr->size;
@@ -1234,12 +1234,12 @@ raid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
 		while ((obj_id = obj_get_sibling(raid_tab, obj_id)) !=
 		    OBJ_NONE) {
 			(void) obj_get_attr(raid_tab, obj_id,
-				(void **)(&diskseg_attr));
+			    (void **)(&diskseg_attr));
 			if ((diskseg_attr->offset - offset) >
-				arraypart_attrs[i].size) {
+			    arraypart_attrs[i].size) {
 				arraypart_attrs[i].offset = offset;
-				arraypart_attrs[i].size = diskseg_attr->offset
-					- offset;
+				arraypart_attrs[i].size = diskseg_attr->offset -
+				    offset;
 			}
 
 			offset = diskseg_attr->offset + diskseg_attr->size;
@@ -1247,8 +1247,8 @@ raid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
 
 		if ((disk_attr->capacity - offset) > arraypart_attrs[i].size) {
 			arraypart_attrs[i].offset = offset;
-			arraypart_attrs[i].size = disk_attr->capacity
-				- offset;
+			arraypart_attrs[i].size = disk_attr->capacity -
+			    offset;
 		}
 	}
 
@@ -1320,7 +1320,7 @@ raid_dev_config(cfga_cmd_t cmd, uint32_t controller_id, uint32_t target_id,
 
 	do {
 		cfga_err = config_change_state(cmd, 1, &ap_id, "disable_rcm",
-			NULL, NULL, NULL, 0);
+		    NULL, NULL, NULL, 0);
 		count++;
 	} while (cfga_err != CFGA_OK && count < 2);
 
@@ -1344,14 +1344,14 @@ raid_handle_init()
 
 	raid_handle_sys.handle_num += HANDLER_SLOTS;
 	ptr = realloc(raid_handle_sys.handles,
-		raid_handle_sys.handle_num * sizeof (handle_attr_t));
+	    raid_handle_sys.handle_num * sizeof (handle_attr_t));
 	if (ptr == NULL)
 		return (ERR_NOMEM);
 	raid_handle_sys.handles = ptr;
 
 	/* Clean up the new allocated handles */
 	for (i = raid_handle_sys.handle_num - HANDLER_SLOTS;
-		i < raid_handle_sys.handle_num; ++i) {
+	    i < raid_handle_sys.handle_num; ++i) {
 		raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
 		raid_handle_sys.handles[i].next = i + 1;
 	}
@@ -1376,10 +1376,10 @@ raid_handle_fini()
 	/* Close all opened controllers */
 	while (i != 0) {
 		if ((raid_handle_sys.handles[i].type == OBJ_TYPE_CONTROLLER) &&
-			(raid_handle_sys.handles[i].fd != 0) &&
-			(raid_handle_sys.handles[i].raid_lib != NULL))
+		    (raid_handle_sys.handles[i].fd != 0) &&
+		    (raid_handle_sys.handles[i].raid_lib != NULL))
 			raid_handle_sys.handles[i].raid_lib->close_controller(
-				raid_handle_sys.handles[i].controller_id, NULL);
+			    raid_handle_sys.handles[i].controller_id, NULL);
 		i = raid_handle_sys.handles[i].next;
 	}
 
@@ -1428,14 +1428,14 @@ raid_handle_delete(raid_obj_handle_t handle)
 	if (i == handle) {
 		if (j != 0)
 			raid_handle_sys.handles[j].next =
-				raid_handle_sys.handles[i].next;
+			    raid_handle_sys.handles[i].next;
 		else
 			raid_handle_sys.used =
-				raid_handle_sys.handles[i].next;
+			    raid_handle_sys.handles[i].next;
 
 		raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
 		raid_handle_sys.handles[i].next =
-			raid_handle_sys.unused;
+		    raid_handle_sys.unused;
 		raid_handle_sys.unused = i;
 	}
 }
@@ -1446,10 +1446,12 @@ raid_handle_delete_controller_comp(uint32_t controller_id)
 	int i = raid_handle_sys.used, j;
 
 	while (i != 0) {
-	    j = i;
-	    i = raid_handle_sys.handles[i].next;
-	    if ((raid_handle_sys.handles[j].controller_id == controller_id) &&
-		(raid_handle_sys.handles[j].type != OBJ_TYPE_CONTROLLER))
+		j = i;
+		i = raid_handle_sys.handles[i].next;
+		if ((raid_handle_sys.handles[j].controller_id ==
+		    controller_id) &&
+		    (raid_handle_sys.handles[j].type !=
+		    OBJ_TYPE_CONTROLLER))
 		raid_handle_delete(j);
 	}
 }
@@ -1470,34 +1472,34 @@ raid_handle_to_obj(raid_obj_tab_t *raid_tab, raid_obj_handle_t handle)
 		return (OBJ_SYSTEM);
 	case	OBJ_TYPE_CONTROLLER:
 		obj_id = obj_locate_controller(raid_tab,
-			handle_attr->controller_id);
+		    handle_attr->controller_id);
 		break;
 	case	OBJ_TYPE_ARRAY:
 		obj_id = obj_locate_array(raid_tab,
-			handle_attr->controller_id, handle_attr->array_id);
+		    handle_attr->controller_id, handle_attr->array_id);
 		break;
 	case	OBJ_TYPE_HSP:
 		obj_id = obj_locate_hsp(raid_tab,
-			handle_attr->controller_id, handle_attr->disk_id,
-			handle_attr->array_id);
+		    handle_attr->controller_id, handle_attr->disk_id,
+		    handle_attr->array_id);
 		break;
 	case	OBJ_TYPE_DISK:
 		obj_id = obj_locate_disk(raid_tab,
-			handle_attr->controller_id, handle_attr->disk_id);
+		    handle_attr->controller_id, handle_attr->disk_id);
 		break;
 	case	OBJ_TYPE_ARRAY_PART:
 		obj_id = obj_locate_arraypart(raid_tab,
-			handle_attr->controller_id, handle_attr->array_id,
-			handle_attr->disk_id);
+		    handle_attr->controller_id, handle_attr->array_id,
+		    handle_attr->disk_id);
 		break;
 	case	OBJ_TYPE_DISK_SEG:
 		obj_id = obj_locate_diskseg(raid_tab,
-			handle_attr->controller_id,
-			handle_attr->disk_id, handle_attr->seq_id);
+		    handle_attr->controller_id,
+		    handle_attr->disk_id, handle_attr->seq_id);
 		break;
 	case	OBJ_TYPE_TASK:
 		obj_id = obj_locate_task(raid_tab,
-			handle_attr->controller_id, handle_attr->task_id);
+		    handle_attr->controller_id, handle_attr->task_id);
 		break;
 	default:
 		return (ERR_DEVICE_INVALID);
@@ -1536,7 +1538,7 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 
 	/* Search for existing handles */
 	for (handle = raid_handle_sys.used; handle != 0;
-		handle = raid_handle_sys.handles[handle].next)
+	    handle = raid_handle_sys.handles[handle].next)
 		if (raid_handle_to_obj(raid_tab, handle) == obj_id)
 			break;
 
@@ -1555,7 +1557,7 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 	case OBJ_TYPE_CONTROLLER:
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_ARRAY:
 		array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -1563,19 +1565,19 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_HSP:
 		hsp_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].array_id =
-			hsp_attr->associated_id;
+		    hsp_attr->associated_id;
 		obj_id = raid_obj_get_container(raid_tab, obj_id);
 		disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_DISK:
 		disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -1583,20 +1585,20 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_ARRAY_PART:
 		arraypart_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].disk_id =
-			arraypart_attr->disk_id;
+		    arraypart_attr->disk_id;
 		obj_id = raid_obj_get_container(raid_tab, obj_id);
 		array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].array_id =
-			array_attr->array_id;
+		    array_attr->array_id;
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_DISK_SEG:
 		diskseg_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -1604,11 +1606,11 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		obj_id = raid_obj_get_container(raid_tab, obj_id);
 		disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].disk_id =
-				disk_attr->disk_id;
+		    disk_attr->disk_id;
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	case OBJ_TYPE_TASK:
 		task_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -1616,7 +1618,7 @@ raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		obj_id = obj_get_controller(raid_tab, obj_id);
 		controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 		raid_handle_sys.handles[handle].controller_id =
-			controller_attr->controller_id;
+		    controller_attr->controller_id;
 		break;
 	default:
 		return (ERR_DEVICE_INVALID);
@@ -1638,8 +1640,8 @@ raid_obj_get_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 	handle = raid_handle_sys.used;
 	while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
-		raid_handle_sys.handles[handle].controller_id !=
-		attr->controller_id)
+	    raid_handle_sys.handles[handle].controller_id !=
+	    attr->controller_id)
 		handle = raid_handle_sys.handles[handle].next;
 
 	if (handle == 0)
@@ -1661,8 +1663,8 @@ raid_obj_set_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 	handle = raid_handle_sys.used;
 	while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
-		raid_handle_sys.handles[handle].controller_id !=
-		attr->controller_id)
+	    raid_handle_sys.handles[handle].controller_id !=
+	    attr->controller_id)
 		handle = raid_handle_sys.handles[handle].next;
 
 	if (handle == 0)
@@ -1684,8 +1686,8 @@ raid_obj_get_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 	handle = raid_handle_sys.used;
 	while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
-		raid_handle_sys.handles[handle].controller_id !=
-		attr->controller_id)
+	    raid_handle_sys.handles[handle].controller_id !=
+	    attr->controller_id)
 		handle = raid_handle_sys.handles[handle].next;
 
 	if (handle == 0)
@@ -1706,8 +1708,8 @@ raid_obj_set_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, int fd)
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
 	handle = raid_handle_sys.used;
 	while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
-		raid_handle_sys.handles[handle].controller_id !=
-		attr->controller_id)
+	    raid_handle_sys.handles[handle].controller_id !=
+	    attr->controller_id)
 		handle = raid_handle_sys.handles[handle].next;
 
 	if (handle == 0)
@@ -1740,10 +1742,10 @@ obj_scan_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DEVICE_INVALID);
 
 	for (obj_type_cnt = OBJ_SYSTEM; obj_type_cnt < OBJ_TYPE_ALL;
-		++obj_type_cnt) {
+	    ++obj_type_cnt) {
 		if (raid_obj_op_sys[type].compnum != NULL)
 			comp_num = raid_obj_op_sys[type].compnum(
-				raid_tab, obj_id, obj_type_cnt);
+			    raid_tab, obj_id, obj_type_cnt);
 		else
 			comp_num = 0;
 
@@ -1758,7 +1760,7 @@ obj_scan_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 
 		for (i = 0; i < comp_num; ++i) {
 			*(comp_list + i) = raid_obj_create(raid_tab,
-				obj_type_cnt);
+			    obj_type_cnt);
 			if (*(comp_list + i) < SUCCESS) {
 				ret = *(comp_list + i);
 				free(comp_list);
@@ -1766,14 +1768,14 @@ obj_scan_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 			}
 
 			(void) raid_obj_clear_status(raid_tab,
-				*(comp_list + i), OBJ_STATUS_CMD_CLEAN);
+			    *(comp_list + i), OBJ_STATUS_CMD_CLEAN);
 			(void) raid_obj_add_org(raid_tab, *(comp_list + i),
-				obj_id);
+			    obj_id);
 		}
 
 		if (raid_obj_op_sys[type].complist != NULL)
 			raid_obj_op_sys[type].complist(raid_tab,
-				obj_id, comp_num, comp_list, obj_type_cnt);
+			    obj_id, comp_num, comp_list, obj_type_cnt);
 		free(comp_list);
 	}
 
@@ -1891,7 +1893,7 @@ obj_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, void **data)
 	if (!(status & OBJ_STATUS_OPENED)) {
 		if (raid_obj_op_sys[type].get_attr == NULL)
 			(void) raid_obj_set_status(raid_tab, obj_id,
-				OBJ_STATUS_OPENED);
+			    OBJ_STATUS_OPENED);
 		else
 			ret = raid_obj_op_sys[type].get_attr(raid_tab, obj_id);
 	}
@@ -2050,7 +2052,7 @@ obj_locate_arraypart(raid_obj_tab_t *raid_tab, uint32_t controller_id,
 		if (attr->disk_id == disk_id)
 			break;
 	} while ((obj_id = obj_get_sibling(raid_tab, obj_id)) >
-		OBJ_NONE);
+	    OBJ_NONE);
 
 	return (obj_id);
 }
@@ -2101,7 +2103,7 @@ obj_locate_task(raid_obj_tab_t *raid_tab, uint32_t controller_id,
 		obj_id2 = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY);
 		while (obj_id2 != OBJ_NONE) {
 			task_obj_id = obj_get_comp(raid_tab, obj_id2,
-				OBJ_TYPE_TASK);
+			    OBJ_TYPE_TASK);
 
 			if (task_obj_id < OBJ_NONE)
 				return (task_obj_id);
@@ -2203,7 +2205,7 @@ obj_sys_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		char path[MAX_PATH_LEN];
 
 		if (strcmp(dp->d_name, ".") == 0 ||
-			strcmp(dp->d_name, "..") == 0)
+		    strcmp(dp->d_name, "..") == 0)
 			continue;
 
 		if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
@@ -2245,7 +2247,7 @@ obj_sys_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 	}
 	while ((dp = readdir(dir)) != NULL) {
 		if (strcmp(dp->d_name, ".") == 0 ||
-			strcmp(dp->d_name, "..") == 0)
+		    strcmp(dp->d_name, "..") == 0)
 			continue;
 
 		if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
@@ -2259,7 +2261,7 @@ obj_sys_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 	qsort((void *)tmplist, num, sizeof (uint32_t), intcompare);
 	for (i = 0; i < num; i++) {
 		attr = raid_obj_get_data_ptr(raid_tab,
-			*(comp_list + i));
+		    *(comp_list + i));
 
 		if (attr == NULL) {
 			free(tmplist);
@@ -2294,7 +2296,7 @@ obj_controller_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->compnum(ctl_attrp->controller_id, 0,
-				OBJ_TYPE_CONTROLLER, comp_type);
+	    OBJ_TYPE_CONTROLLER, comp_type);
 
 	return (ret);
 }
@@ -2319,7 +2321,7 @@ obj_controller_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 
 	for (i = 0; i < comp_num; ++i)
 		if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
-			comp_type)
+		    comp_type)
 			return (ERR_DEVICE_TYPE);
 
 	raid_lib = raid_obj_get_lib(raid_tab, obj_id);
@@ -2333,7 +2335,7 @@ obj_controller_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_NOMEM);
 
 	ret = raid_lib->complist(ctl_attrp->controller_id, 0,
-		OBJ_TYPE_CONTROLLER, comp_type, comp_num, ids);
+	    OBJ_TYPE_CONTROLLER, comp_type, comp_num, ids);
 	if (ret < SUCCESS) {
 		free(ids);
 		return (ret);
@@ -2402,7 +2404,7 @@ obj_controller_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 	}
 
 	ret = raid_lib->get_attr(attr->controller_id, OBJ_ATTR_NONE,
-		OBJ_ATTR_NONE, OBJ_TYPE_CONTROLLER, attr);
+	    OBJ_ATTR_NONE, OBJ_TYPE_CONTROLLER, attr);
 	if (ret < SUCCESS)
 		return (ret);
 
@@ -2442,7 +2444,7 @@ obj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		}
 
 		ret = raid_lib->open_controller(attr->controller_id,
-			plugin_err_str);
+		    plugin_err_str);
 		if (ret == SUCCESS) {
 			(void) raid_obj_set_lib(raid_tab, obj_id, raid_lib);
 			(void) raid_obj_set_fd(raid_tab, obj_id, 1);
@@ -2457,7 +2459,7 @@ obj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 			return (SUCCESS);
 		}
 		ret = raid_lib->close_controller(attr->controller_id,
-			plugin_err_str);
+		    plugin_err_str);
 		if (ret == SUCCESS) {
 			(void) raid_obj_set_fd(raid_tab, obj_id, 0);
 			(void) raid_obj_set_lib(raid_tab, obj_id, NULL);
@@ -2476,7 +2478,7 @@ obj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 
 			/* Open firmware image file */
 			image_fd = open((const char *)prop_list,
-				O_RDONLY | O_NDELAY);
+			    O_RDONLY | O_NDELAY);
 			if (image_fd == -1)
 				return (ERR_OP_FAILED);
 
@@ -2516,7 +2518,7 @@ obj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 			}
 
 			ret = raid_lib->flash_fw(attr->controller_id,
-				filebuf, size, plugin_err_str);
+			    filebuf, size, plugin_err_str);
 		}
 		break;
 	default:
@@ -2540,8 +2542,8 @@ obj_array_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DEVICE_TYPE);
 
 	if (comp_type != OBJ_TYPE_ARRAY_PART &&
-		comp_type != OBJ_TYPE_ARRAY &&
-		comp_type != OBJ_TYPE_TASK)
+	    comp_type != OBJ_TYPE_ARRAY &&
+	    comp_type != OBJ_TYPE_TASK)
 		return (0);
 
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -2563,7 +2565,7 @@ obj_array_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->compnum(ctl_attrp->controller_id, attr->array_id,
-		OBJ_TYPE_ARRAY, comp_type);
+	    OBJ_TYPE_ARRAY, comp_type);
 
 	return (ret);
 }
@@ -2583,8 +2585,8 @@ obj_array_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DEVICE_TYPE);
 
 	if (comp_type != OBJ_TYPE_ARRAY_PART &&
-		comp_type != OBJ_TYPE_ARRAY &&
-		comp_type != OBJ_TYPE_TASK)
+	    comp_type != OBJ_TYPE_ARRAY &&
+	    comp_type != OBJ_TYPE_TASK)
 		return (0);
 
 	if (comp_num <= 0 || comp_list == NULL)
@@ -2592,7 +2594,7 @@ obj_array_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 
 	for (i = 0; i < comp_num; ++i)
 		if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
-			comp_type)
+		    comp_type)
 			return (ERR_DEVICE_TYPE);
 
 	attr = raid_obj_get_data_ptr(raid_tab, obj_id);
@@ -2618,7 +2620,7 @@ obj_array_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_NOMEM);
 
 	ret = raid_lib->complist(ctl_attrp->controller_id,
-		attr->array_id, OBJ_TYPE_ARRAY, comp_type, comp_num, ids);
+	    attr->array_id, OBJ_TYPE_ARRAY, comp_type, comp_num, ids);
 
 	if (ret < SUCCESS) {
 		free(ids);
@@ -2695,7 +2697,7 @@ obj_array_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->get_attr(ctl_attrp->controller_id,
-		attr->array_id, 0, OBJ_TYPE_ARRAY, attr);
+	    attr->array_id, 0, OBJ_TYPE_ARRAY, attr);
 
 	if (ret < SUCCESS)
 		return (ret);
@@ -2721,12 +2723,12 @@ obj_array_set_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 	switch (sub_cmd) {
 	case SET_CACHE_WR_PLY:
 		if (*value != CACHE_WR_OFF &&
-			*value != CACHE_WR_ON)
+		    *value != CACHE_WR_ON)
 			return (ERR_OP_ILLEGAL);
 		break;
 	case SET_CACHE_RD_PLY:
 		if (*value != CACHE_RD_OFF &&
-			*value != CACHE_RD_ON)
+		    *value != CACHE_RD_ON)
 			return (ERR_OP_ILLEGAL);
 		break;
 	default:
@@ -2753,7 +2755,7 @@ obj_array_set_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_OP_NO_IMPL);
 
 	ret = raid_lib->set_attr(ctl_attrp->controller_id,
-		attr->array_id, sub_cmd, value, plugin_err_str);
+	    attr->array_id, sub_cmd, value, plugin_err_str);
 
 	return (ret);
 }
@@ -2772,8 +2774,8 @@ obj_disk_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DEVICE_TYPE);
 
 	if (comp_type != OBJ_TYPE_DISK_SEG &&
-		comp_type != OBJ_TYPE_HSP &&
-		comp_type != OBJ_TYPE_TASK)
+	    comp_type != OBJ_TYPE_HSP &&
+	    comp_type != OBJ_TYPE_TASK)
 		return (0);
 	ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
 	if ((ret != SUCCESS) || (attr == NULL)) {
@@ -2798,7 +2800,7 @@ obj_disk_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->compnum(ctl_attrp->controller_id,
-		attr->disk_id, OBJ_TYPE_DISK, comp_type);
+	    attr->disk_id, OBJ_TYPE_DISK, comp_type);
 
 	return (ret);
 }
@@ -2818,8 +2820,8 @@ obj_disk_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_DEVICE_TYPE);
 
 	if (comp_type != OBJ_TYPE_DISK_SEG &&
-		comp_type != OBJ_TYPE_HSP &&
-		comp_type != OBJ_TYPE_TASK)
+	    comp_type != OBJ_TYPE_HSP &&
+	    comp_type != OBJ_TYPE_TASK)
 		return (0);
 
 	if (comp_num <= 0 || comp_list == NULL)
@@ -2827,7 +2829,7 @@ obj_disk_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 
 	for (i = 0; i < comp_num; ++i)
 		if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
-			comp_type)
+		    comp_type)
 			return (ERR_DEVICE_TYPE);
 	ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
 	if ((ret != SUCCESS) || (attr == NULL)) {
@@ -2856,7 +2858,7 @@ obj_disk_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
 		return (ERR_NOMEM);
 
 	ret = raid_lib->complist(ctl_attrp->controller_id,
-		attr->disk_id, OBJ_TYPE_DISK, comp_type, comp_num, ids);
+	    attr->disk_id, OBJ_TYPE_DISK, comp_type, comp_num, ids);
 
 	if (ret < SUCCESS) {
 		free(ids);
@@ -2933,7 +2935,7 @@ obj_disk_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->get_attr(ctl_attrp->controller_id,
-		attr->disk_id, 0, OBJ_TYPE_DISK, attr);
+	    attr->disk_id, 0, OBJ_TYPE_DISK, attr);
 
 	if (ret < SUCCESS)
 		return (ret);
@@ -3009,8 +3011,8 @@ obj_arraypart_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->get_attr(ctl_attrp->controller_id,
-		array_attr->array_id, attr->disk_id,
-		OBJ_TYPE_ARRAY_PART, attr);
+	    array_attr->array_id, attr->disk_id,
+	    OBJ_TYPE_ARRAY_PART, attr);
 
 	if (ret < SUCCESS)
 		return (ret);
@@ -3063,7 +3065,7 @@ obj_diskseg_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->get_attr(ctl_attrp->controller_id,
-		disk_attr->disk_id, attr->seq_no, OBJ_TYPE_DISK_SEG, attr);
+	    disk_attr->disk_id, attr->seq_no, OBJ_TYPE_DISK_SEG, attr);
 
 	if (ret < SUCCESS)
 		return (ret);
@@ -3104,7 +3106,7 @@ obj_task_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DRIVER_CLOSED);
 
 	ret = raid_lib->get_attr(ctl_attrp->controller_id,
-		attr->task_id, OBJ_ATTR_NONE, OBJ_TYPE_TASK, attr);
+	    attr->task_id, OBJ_ATTR_NONE, OBJ_TYPE_TASK, attr);
 
 	return (ret);
 }
@@ -3130,7 +3132,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 	/* Check the disk layout expression */
 	if (disk_list[0] != OBJ_SEPARATOR_BEGIN ||
-		disk_list[num_of_comp - 1] != OBJ_SEPARATOR_END)
+	    disk_list[num_of_comp - 1] != OBJ_SEPARATOR_END)
 		return (ERR_ARRAY_LAYOUT);
 	for (i = 0; i < num_of_comp; ++i) {
 		if (disk_list[i] == OBJ_SEPARATOR_BEGIN) {
@@ -3205,20 +3207,20 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 		/* Keep seperators */
 		if (*(disk_list + i) == OBJ_SEPARATOR_BEGIN) {
 			arraypart_attrs[i].disk_id =
-				(uint32_t)OBJ_SEPARATOR_BEGIN;
+			    (uint32_t)OBJ_SEPARATOR_BEGIN;
 			continue;
 		}
 
 		if (*(disk_list + i) == OBJ_SEPARATOR_END) {
 			arraypart_attrs[i].disk_id =
-				(uint32_t)OBJ_SEPARATOR_END;
+			    (uint32_t)OBJ_SEPARATOR_END;
 			continue;
 		}
 
 		disk_cnt++;
 		/* Check if it's a disk */
 		if (raid_obj_get_type(raid_tab, *(disk_list + i)) !=
-			OBJ_TYPE_DISK)
+		    OBJ_TYPE_DISK)
 			return (ERR_DEVICE_TYPE);
 
 		/* Check if it's duplicated with other disks */
@@ -3230,7 +3232,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 		/* Check disk status */
 		ret = obj_get_attr(raid_tab, *(disk_list + i),
-			(void **)(&disk_attr));
+		    (void **)(&disk_attr));
 		if (ret != SUCCESS)
 			return (ret);
 
@@ -3246,7 +3248,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 		if (controller_obj_id == OBJ_NONE) {
 			controller_obj_id = obj_id;
 			ret = obj_get_attr(raid_tab, controller_obj_id,
-				(void **)(&controller_attr));
+			    (void **)(&controller_attr));
 		} else if (obj_id != controller_obj_id) {
 			free(arraypart_attrs);
 			return (ERR_DRIVER_ACROSS);
@@ -3254,7 +3256,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 		/* Check if the disk contains too many segments */
 		obj_id = obj_get_comp(raid_tab, *(disk_list + i),
-				OBJ_TYPE_DISK_SEG);
+		    OBJ_TYPE_DISK_SEG);
 		j = 0;
 		while (obj_id > OBJ_NONE) {
 			++j;
@@ -3277,7 +3279,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 				/* Can not specify capacity for hostraid */
 				if (array_attr->capacity != 0) {
 					free(arraypart_attrs);
-					return (ERR_DISK_SPACE);
+					return (ERR_OP_ILLEGAL);
 				}
 			} else if (min_disk_capacity > disk_attr->capacity) {
 				free(arraypart_attrs);
@@ -3286,7 +3288,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 			/* Disk should not be used for hostraid */
 			obj_id = obj_get_comp(raid_tab, *(disk_list + i),
-				OBJ_TYPE_DISK_SEG);
+			    OBJ_TYPE_DISK_SEG);
 			if (obj_id < OBJ_NONE) {
 				free(arraypart_attrs);
 				return (obj_id);
@@ -3303,8 +3305,8 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 	/* Check if array amount exceeds limit */
 	if (controller_attr->max_array_num <=
-		obj_controller_compnum(raid_tab, controller_obj_id,
-		OBJ_TYPE_ARRAY))
+	    obj_controller_compnum(raid_tab, controller_obj_id,
+	    OBJ_TYPE_ARRAY))
 		return (ERR_ARRAY_AMOUNT);
 
 
@@ -3360,14 +3362,14 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 	(void) memcpy(&array_attr2, array_attr, sizeof (array_attr_t));
 	array_attr2.capacity = OBJ_ATTR_NONE;
 	ret = raid_lib->array_create(controller_attr->controller_id,
-		&array_attr2, num_of_comp, arraypart_attrs, plugin_err_str);
+	    &array_attr2, num_of_comp, arraypart_attrs, plugin_err_str);
 
 	/* If plugin/driver will not calculate space */
 	if (ret == ERR_OP_NO_IMPL) {
 		/* Calculate the maximum capacity */
 		array_attr2.capacity = raid_space_noalign(raid_tab,
-			array_attr2.raid_level, num_of_comp, disk_list,
-			arraypart_attrs);
+		    array_attr2.raid_level, num_of_comp, disk_list,
+		    arraypart_attrs);
 
 		/*
 		 * If controller is capable to allocate space,
@@ -3377,9 +3379,9 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 		if (controller_attr->capability & RAID_CAP_SMART_ALLOC)
 			for (i = 0; i < num_of_comp; ++i) {
 				arraypart_attrs[i].offset =
-					OBJ_ATTR_NONE;
+				    OBJ_ATTR_NONE;
 				arraypart_attrs[i].size =
-					OBJ_ATTR_NONE;
+				    OBJ_ATTR_NONE;
 			}
 
 		/* There's no enough space for specified capacity */
@@ -3408,7 +3410,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 
 
 	ret = raid_lib->array_create(controller_attr->controller_id,
-		array_attr, num_of_comp, arraypart_attrs, plugin_err_str);
+	    array_attr, num_of_comp, arraypart_attrs, plugin_err_str);
 	free(arraypart_attrs);
 
 	if (ret != SUCCESS)
@@ -3420,7 +3422,7 @@ obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 	/* unconfig disk minor nodes if it's hostraid */
 	if (controller_attr->capability & RAID_CAP_DISK_TRANS) {
 		diskid_list = (uint32_t *)calloc(num_of_comp,
-			sizeof (uint32_t));
+		    sizeof (uint32_t));
 		if (diskid_list == NULL) {
 			return (ERR_NOMEM);
 		}
@@ -3488,7 +3490,7 @@ obj_array_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 		return (controller_obj_id);
 
 	ret = obj_get_attr(raid_tab, controller_obj_id,
-		(void **)(&controller_attr));
+	    (void **)(&controller_attr));
 	if (ret < SUCCESS) {
 		return (ret);
 	}
@@ -3540,7 +3542,7 @@ obj_array_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 			    LUN(arraypart_attr->disk_id) ==
 			    ARRAY_LUN(array_attr->array_id)) {
 				arraypart_obj_id = obj_get_sibling(raid_tab,
-					arraypart_obj_id);
+				    arraypart_obj_id);
 				continue;
 			}
 
@@ -3557,7 +3559,7 @@ obj_array_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
 	}
 
 	ret = raid_lib->array_delete(controller_attr->controller_id,
-		array_attr->array_id, plugin_err_str);
+	    array_attr->array_id, plugin_err_str);
 	if (ret < SUCCESS) {
 		if (disk_ids)
 			free(disk_ids);
@@ -3605,9 +3607,9 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 		disk_obj_id = *(obj_ids + i * 2 + 1);
 
 		if (raid_obj_get_type(raid_tab, disk_obj_id) != OBJ_TYPE_DISK ||
-			(array_obj_id != OBJ_ATTR_NONE &&
-			raid_obj_get_type(raid_tab, array_obj_id) !=
-			OBJ_TYPE_ARRAY)) {
+		    (array_obj_id != OBJ_ATTR_NONE &&
+		    raid_obj_get_type(raid_tab, array_obj_id) !=
+		    OBJ_TYPE_ARRAY)) {
 			free(hsp_relation);
 			return (ERR_DEVICE_TYPE);
 		}
@@ -3615,19 +3617,19 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 		/* Get controller attributes */
 		if (controller_obj_id == OBJ_NONE)
 			controller_obj_id = obj_get_controller(raid_tab,
-				disk_obj_id);
+			    disk_obj_id);
 		else if (controller_obj_id != obj_get_controller(raid_tab,
-			disk_obj_id)) {
+		    disk_obj_id)) {
 			free(hsp_relation);
 			return (ERR_DRIVER_ACROSS);
 		}
 
 		ret = obj_get_attr(raid_tab, controller_obj_id,
-			(void **)(&controller_attr));
+		    (void **)(&controller_attr));
 
 		/* Get disk attributes */
 		ret = obj_get_attr(raid_tab,  disk_obj_id,
-			(void **)(&disk_attr));
+		    (void **)(&disk_attr));
 		if (disk_attr->state == DISK_STATE_FAILED) {
 			free(hsp_relation);
 			return (ERR_DISK_STATE);
@@ -3637,12 +3639,12 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 		if (obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP) ==
 		    OBJ_NONE) {
 			obj_id = obj_get_comp(raid_tab, disk_obj_id,
-				OBJ_TYPE_DISK_SEG);
+			    OBJ_TYPE_DISK_SEG);
 			while (obj_id != OBJ_NONE) {
 				ret = obj_get_attr(raid_tab, obj_id,
-					(void **)(&diskseg_attr));
+				    (void **)(&diskseg_attr));
 				if (!(diskseg_attr->state &
-					DISKSEG_STATE_RESERVED)) {
+				    DISKSEG_STATE_RESERVED)) {
 					free(hsp_relation);
 					return (ERR_DISK_NOT_EMPTY);
 				}
@@ -3658,14 +3660,14 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 			}
 
 			if (raid_obj_get_type(raid_tab, array_obj_id) !=
-				OBJ_TYPE_ARRAY) {
+			    OBJ_TYPE_ARRAY) {
 				free(hsp_relation);
 				return (ERR_DEVICE_TYPE);
 			}
 
 			/* Get array attributes */
 			ret = obj_get_attr(raid_tab, array_obj_id,
-				(void **)(&array_attr));
+			    (void **)(&array_attr));
 			/* RAID 0 array can not use hsp */
 			if (array_attr->raid_level == RAID_LEVEL_0) {
 				free(hsp_relation);
@@ -3674,22 +3676,22 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 
 			/* If It's belong to another controller */
 			if (controller_obj_id != obj_get_controller(raid_tab,
-				array_obj_id)) {
+			    array_obj_id)) {
 				free(hsp_relation);
 				return (ERR_DRIVER_ACROSS);
 			}
 
 			/* Get an array part attributes */
 			if ((array_attr->raid_level == RAID_LEVEL_10) ||
-				(array_attr->raid_level == RAID_LEVEL_50))
+			    (array_attr->raid_level == RAID_LEVEL_50))
 				obj_id = obj_get_comp(raid_tab, array_obj_id,
-					OBJ_TYPE_ARRAY);
+				    OBJ_TYPE_ARRAY);
 			else
 				obj_id = array_obj_id;
 			obj_id = obj_get_comp(raid_tab, obj_id,
-				OBJ_TYPE_ARRAY_PART);
+			    OBJ_TYPE_ARRAY_PART);
 			ret = obj_get_attr(raid_tab, obj_id,
-				(void **)(&arraypart_attr));
+			    (void **)(&arraypart_attr));
 
 			/* Check if disk space is enough for array */
 			if (arraypart_attr->size > disk_attr->capacity) {
@@ -3698,8 +3700,8 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 			}
 			if (controller_attr->capability & RAID_CAP_ARRAY_ALIGN)
 				if ((arraypart_attr->size +
-					arraypart_attr->offset) >
-					disk_attr->capacity) {
+				    arraypart_attr->offset) >
+				    disk_attr->capacity) {
 				free(hsp_relation);
 				return (ERR_DISK_SPACE);
 				}
@@ -3721,8 +3723,8 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 				    (array_obj_id != OBJ_ATTR_NONE)) ||
 				    ((hsp_attr->type == HSP_TYPE_LOCAL) &&
 				    (array_obj_id == OBJ_ATTR_NONE))) {
-				    free(hsp_relation);
-				    return (ERR_OP_ILLEGAL);
+					free(hsp_relation);
+					return (ERR_OP_ILLEGAL);
 				}
 			}
 		}
@@ -3750,7 +3752,7 @@ obj_hsp_bind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 	}
 
 	ret = raid_lib->hsp_bind(controller_attr->controller_id,
-		j, hsp_relation, plugin_err_str);
+	    j, hsp_relation, plugin_err_str);
 
 	free(hsp_relation);
 	return (ret);
@@ -3786,19 +3788,19 @@ obj_hsp_unbind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 		/* Get controller attributes */
 		if (controller_obj_id == OBJ_NONE)
 			controller_obj_id = obj_get_controller(raid_tab,
-				disk_obj_id);
+			    disk_obj_id);
 		else if (controller_obj_id != obj_get_controller(raid_tab,
-			disk_obj_id)) {
+		    disk_obj_id)) {
 			free(hsp_relation);
 			return (ERR_DRIVER_ACROSS);
 		}
 
 		ret = obj_get_attr(raid_tab, controller_obj_id,
-			(void **)(&controller_attr));
+		    (void **)(&controller_attr));
 
 		/* Get disk attributes */
 		ret = obj_get_attr(raid_tab,  disk_obj_id,
-			(void **)(&disk_attr));
+		    (void **)(&disk_attr));
 		if (disk_attr->state == DISK_STATE_FAILED) {
 			free(hsp_relation);
 			return (ERR_DISK_STATE);
@@ -3814,18 +3816,18 @@ obj_hsp_unbind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 
 		if (array_obj_id != OBJ_ATTR_NONE) {
 			if (raid_obj_get_type(raid_tab, array_obj_id) !=
-				OBJ_TYPE_ARRAY) {
+			    OBJ_TYPE_ARRAY) {
 				free(hsp_relation);
 				return (ERR_DEVICE_TYPE);
-				}
+			}
 
 			/* Get array attributes */
 			ret = obj_get_attr(raid_tab, array_obj_id,
-				(void **)(&array_attr));
+			    (void **)(&array_attr));
 
 			/* If It's belong to another controller */
 			if (controller_obj_id != obj_get_controller(raid_tab,
-				array_obj_id)) {
+			    array_obj_id)) {
 				free(hsp_relation);
 				return (ERR_DRIVER_ACROSS);
 			}
@@ -3838,11 +3840,11 @@ obj_hsp_unbind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 
 			do {
 				(void) obj_get_attr(raid_tab, obj_id,
-					(void **)(&hsp_attr));
+				    (void **)(&hsp_attr));
 
 				if (hsp_attr->associated_id ==
-					array_attr->array_id ||
-					hsp_attr->type == HSP_TYPE_GLOBAL)
+				    array_attr->array_id ||
+				    hsp_attr->type == HSP_TYPE_GLOBAL)
 					break;
 
 				obj_id = obj_get_sibling(raid_tab, obj_id);
@@ -3858,12 +3860,12 @@ obj_hsp_unbind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 		 * global hsp disk
 		 */
 		if ((obj_id && (array_obj_id != OBJ_ATTR_NONE)) ||
-			(array_obj_id == OBJ_ATTR_NONE)) {
+		    (array_obj_id == OBJ_ATTR_NONE)) {
 			if (array_obj_id != OBJ_ATTR_NONE)
 				hsp_relation[j].array_id = array_attr->array_id;
 			else
 				hsp_relation[j].array_id =
-					(uint32_t)OBJ_ATTR_NONE;
+				    (uint32_t)OBJ_ATTR_NONE;
 			hsp_relation[j].disk_id = disk_attr->disk_id;
 			++ j;
 		} else {
@@ -3884,7 +3886,7 @@ obj_hsp_unbind(raid_obj_tab_t *raid_tab, int num, raid_obj_id_t *obj_ids,
 	}
 
 	ret = raid_lib->hsp_unbind(controller_attr->controller_id,
-		j, hsp_relation, plugin_err_str);
+	    j, hsp_relation, plugin_err_str);
 
 	free(hsp_relation);
 	return (ret);
@@ -4044,7 +4046,7 @@ raid_obj_get_type(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
 		return (ERR_DEVICE_NOENT);
 
 	if ((obj->obj_type_id < OBJ_TYPE_SYSTEM) ||
-		(obj->obj_type_id >= OBJ_TYPE_ALL))
+	    (obj->obj_type_id >= OBJ_TYPE_ALL))
 		return (ERR_DEVICE_INVALID);
 
 	return (obj->obj_type_id);
@@ -4325,7 +4327,7 @@ raid_list_find(raid_list_t *list, raid_obj_id_t obj_id)
 	raid_obj_t *obj;
 
 	for (obj = raid_list_head(list); obj != NULL;
-		obj = raid_list_next(list, obj))
+	    obj = raid_list_next(list, obj))
 			if (obj->obj_id == obj_id)
 				break;
 
@@ -4508,7 +4510,7 @@ raid_plugin_load(char *driver_name)
 		return (NULL);
 
 	(void) snprintf(buf, MAX_PATH_LEN, "%s/%s.so.1",
-		SUPP_PLUGIN_DIR, driver_name);
+	    SUPP_PLUGIN_DIR, driver_name);
 
 	supplib->lib_handle = dlopen(buf, RTLD_LAZY);
 	if (supplib->lib_handle == NULL) {
@@ -4530,7 +4532,7 @@ raid_plugin_load(char *driver_name)
 	}
 
 	if ((sym = dlsym(supplib->lib_handle, "rdcfg_open_controller")) ==
-		NULL) {
+	    NULL) {
 		(void) dlclose(supplib->lib_handle);
 		free(supplib);
 		return (NULL);
@@ -4538,7 +4540,7 @@ raid_plugin_load(char *driver_name)
 		supplib->open_controller = (int(*)(uint32_t, char **))sym;
 
 	if ((sym = dlsym(supplib->lib_handle, "rdcfg_close_controller")) ==
-		NULL) {
+	    NULL) {
 		(void) dlclose(supplib->lib_handle);
 		free(supplib);
 		return (NULL);
@@ -4613,18 +4615,18 @@ raid_find_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t controller_obj_id)
 		return (raid_handle_sys.handles[handle].raid_lib);
 
 	(void) obj_get_attr(raid_tab, controller_obj_id,
-		(void **)(&controller_attr));
+	    (void **)(&controller_attr));
 
 	/* Check if the plugin module is already loaded */
 	driver_name = controller_id_to_driver_name(
-		controller_attr->controller_id);
+	    controller_attr->controller_id);
 	if (driver_name == NULL)
 		return (NULL);
 
 	raid_lib = raid_lib_sys;
 	while (raid_lib != NULL) {
 		if (raid_lib->name != NULL &&
-			strcmp(driver_name, raid_lib->name) == 0)
+		    strcmp(driver_name, raid_lib->name) == 0)
 			return (raid_lib);
 
 		raid_lib = raid_lib->next;