2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A
2N/A/*
2N/A * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A#include <fcntl.h>
2N/A#include <sys/types.h>
2N/A#include <sys/stat.h>
2N/A#include <stddef.h>
2N/A#include <stdlib.h>
2N/A#include <dirent.h>
2N/A#include <dlfcn.h>
2N/A#include <link.h>
2N/A#include <strings.h>
2N/A#include <stdio.h>
2N/A#include <unistd.h>
2N/A#include <sys/mnttab.h>
2N/A#include <config_admin.h>
2N/A#include <sys/param.h>
2N/A#include <libintl.h>
2N/A#include <libdevinfo.h>
2N/A#include <raidcfg.h>
2N/A#include <thread.h>
2N/A#include <synch.h>
2N/A
2N/A#ifndef TEXT_DOMAIN
2N/A#define TEXT_DOMAIN "SYS_TEST"
2N/A#endif
2N/A
2N/A#define HASH_SLOTS 16
2N/A#define HANDLER_SLOTS 256
2N/A
2N/A/*
2N/A * Raid object status;
2N/A */
2N/A#define OBJ_STATUS_CMD_CLEAN -1
2N/A#define OBJ_STATUS_OPENED 1
2N/A#define OBJ_STATUS_SCANCOMP 1 << 1
2N/A
2N/A#if defined(__sparcv9)
2N/A#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg/sparcv9"
2N/A#elif defined(__amd64)
2N/A#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg/amd64"
2N/A#else
2N/A#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg"
2N/A#endif
2N/A
2N/A/*
2N/A * Basic types
2N/A */
2N/Atypedef int raid_obj_id_t;
2N/Atypedef int raid_obj_status_t;
2N/A
2N/A/*
2N/A * Data structures used for object maintennance
2N/A */
2N/Atypedef struct {
2N/A void *head;
2N/A void *tail;
2N/A size_t offset; /* offset of double-linked element (raid_list_el_t) */
2N/A /* in the linked data structures (objects) */
2N/A} raid_list_t;
2N/A
2N/Atypedef struct {
2N/A void *prev;
2N/A void *next;
2N/A} raid_list_el_t;
2N/A
2N/Atypedef struct {
2N/A raid_obj_id_t obj_id_cnt; /* id 0 is reserved */
2N/A size_t slots; /* How many lists linked by *table */
2N/A raid_list_t *table;
2N/A} raid_obj_tab_t;
2N/A
2N/A/*
2N/A * Object type structure containing function pointers;
2N/A */
2N/Atypedef struct {
2N/A int (*compnum)(raid_obj_tab_t *, raid_obj_id_t, raid_obj_type_id_t);
2N/A int (*complist)(raid_obj_tab_t *, raid_obj_id_t, int, raid_obj_id_t *,
2N/A raid_obj_type_id_t);
2N/A int (*get_attr)(raid_obj_tab_t *, raid_obj_id_t);
2N/A int (*set_attr)(raid_obj_tab_t *, raid_obj_id_t, uint32_t, uint32_t *,
2N/A char **);
2N/A int (*act)(raid_obj_tab_t *, raid_obj_id_t, uint32_t, void *, char **);
2N/A int (*create_obj)(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, char **);
2N/A int (*delete_obj)(raid_obj_tab_t *, raid_obj_id_t, char **);
2N/A int (*bind_obj)(raid_obj_tab_t *, raid_obj_id_t *, char **);
2N/A int (*unbind_obj)(raid_obj_tab_t *, raid_obj_id_t *, char **);
2N/A} raid_obj_op_t;
2N/A
2N/A/*
2N/A * Common object data structure
2N/A */
2N/Atypedef struct {
2N/A raid_list_el_t el; /* double-links */
2N/A
2N/A raid_obj_type_id_t obj_type_id;
2N/A raid_obj_id_t obj_id;
2N/A raid_obj_status_t status;
2N/A
2N/A raid_obj_id_t container;
2N/A raid_obj_id_t sibling;
2N/A raid_obj_id_t component;
2N/A
2N/A void *data; /* Pointer to attribute structure */
2N/A raid_obj_handle_t handle;
2N/A} raid_obj_t;
2N/A
2N/A/*
2N/A * Definition about handle
2N/A */
2N/Atypedef struct {
2N/A uint32_t next;
2N/A uint32_t type;
2N/A uint32_t controller_id;
2N/A uint32_t array_id;
2N/A uint32_t disk_id;
2N/A uint64_t seq_id;
2N/A uint32_t task_id;
2N/A uint32_t prop_id;
2N/A uint32_t fd; /* Only for controller */
2N/A raid_lib_t *raid_lib; /* Only for controller */
2N/A} handle_attr_t;
2N/A
2N/A#define LIST_OBJ_TO_EL(list, obj) \
2N/A ((void *)((char *)(obj) + (list)->offset))
2N/A#define OBJ_TAB_SLOT(tab, id) \
2N/A ((tab)->table + ((id)%(tab)->slots))
2N/A
2N/A#pragma init(raidcfg_init)
2N/A#pragma fini(raidcfg_fini)
2N/A
2N/A/*
2N/A * Function prototypes
2N/A */
2N/Astatic int intcompare(const void *p1, const void *p2);
2N/Astatic uint64_t raid_space_noalign(raid_obj_tab_t *, uint32_t, int,
2N/A raid_obj_id_t *, arraypart_attr_t *);
2N/Astatic int raid_handle_init();
2N/Astatic void raid_handle_fini();
2N/Astatic raid_obj_handle_t raid_handle_new(raid_obj_type_id_t);
2N/Astatic void raid_handle_delete(raid_obj_handle_t);
2N/Astatic void raid_handle_delete_controller_comp(uint32_t);
2N/Astatic raid_obj_id_t raid_handle_to_obj(raid_obj_tab_t *,
2N/A raid_obj_handle_t);
2N/Astatic raid_obj_handle_t raid_obj_to_handle(raid_obj_tab_t *,
2N/A raid_obj_id_t);
2N/Astatic raid_lib_t *raid_obj_get_lib(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_lib(raid_obj_tab_t *, raid_obj_id_t, raid_lib_t *);
2N/Astatic int raid_obj_get_fd(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_fd(raid_obj_tab_t *, raid_obj_id_t, int);
2N/Astatic int obj_scan_comp(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_rescan(raid_obj_tab_t *);
2N/Astatic raid_obj_id_t obj_get_comp(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic raid_obj_id_t obj_get_sibling(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_get_attr(raid_obj_tab_t *, raid_obj_id_t, void **);
2N/Astatic raid_obj_id_t obj_locate_controller(raid_obj_tab_t *, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_array(raid_obj_tab_t *, uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_array_recur(raid_obj_tab_t *, raid_obj_id_t,
2N/A uint32_t);
2N/Astatic raid_obj_id_t obj_locate_hsp(raid_obj_tab_t *, uint32_t,
2N/A uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_disk(raid_obj_tab_t *, uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_arraypart(raid_obj_tab_t *, uint32_t,
2N/A uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_diskseg(raid_obj_tab_t *, uint32_t,
2N/A uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_task(raid_obj_tab_t *, uint32_t, uint32_t);
2N/Astatic raid_obj_id_t obj_locate_prop(raid_obj_tab_t *, uint32_t, uint32_t,
2N/A uint32_t);
2N/Astatic raid_obj_id_t obj_get_controller(raid_obj_tab_t *, raid_obj_id_t);
2N/A
2N/Astatic int obj_sys_compnum(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic int obj_sys_complist(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, raid_obj_type_id_t);
2N/Astatic int obj_controller_compnum(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic int obj_controller_complist(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, raid_obj_type_id_t);
2N/Astatic int obj_controller_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_controller_act(raid_obj_tab_t *, raid_obj_id_t,
2N/A uint32_t, void *, char **);
2N/Astatic int obj_array_compnum(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic int obj_array_complist(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, raid_obj_type_id_t);
2N/Astatic int obj_array_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_array_set_attr(raid_obj_tab_t *, raid_obj_id_t,
2N/A uint32_t, uint32_t *, char **);
2N/Astatic int obj_disk_compnum(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic int obj_disk_complist(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, raid_obj_type_id_t);
2N/Astatic int obj_disk_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_hsp_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_arraypart_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_diskseg_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_task_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_prop_get_attr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int obj_array_create(raid_obj_tab_t *, raid_obj_id_t, int,
2N/A raid_obj_id_t *, char **);
2N/Astatic int obj_array_delete(raid_obj_tab_t *, raid_obj_id_t, char **);
2N/Astatic int obj_hsp_bind(raid_obj_tab_t *, raid_obj_id_t *, char **);
2N/Astatic int obj_hsp_unbind(raid_obj_tab_t *, raid_obj_id_t *, char **);
2N/A
2N/Astatic int raid_obj_create_system_obj(raid_obj_tab_t *);
2N/Astatic raid_obj_id_t raid_obj_id_new(raid_obj_tab_t *);
2N/Astatic void *raid_obj_attr_new(raid_obj_type_id_t);
2N/Astatic raid_obj_id_t raid_obj_create(raid_obj_tab_t *, raid_obj_type_id_t);
2N/Astatic int raid_obj_delete(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_add_org(raid_obj_tab_t *, raid_obj_id_t, raid_obj_id_t);
2N/Astatic raid_obj_type_id_t raid_obj_get_type(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_type(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_type_id_t);
2N/Astatic raid_obj_status_t raid_obj_get_status(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_status(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_status_t);
2N/Astatic int raid_obj_clear_status(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_status_t);
2N/Astatic raid_obj_id_t raid_obj_get_container(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_container(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_id_t);
2N/Astatic raid_obj_id_t raid_obj_get_comp(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_comp(raid_obj_tab_t *, raid_obj_id_t, raid_obj_id_t);
2N/Astatic raid_obj_id_t raid_obj_get_sibling(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_sibling(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_id_t);
2N/Astatic void *raid_obj_get_data_ptr(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic int raid_obj_set_data_ptr(raid_obj_tab_t *, raid_obj_id_t, void *);
2N/Astatic raid_obj_handle_t raid_obj_get_handle(raid_obj_tab_t *,
2N/A raid_obj_id_t);
2N/Astatic int raid_obj_set_handle(raid_obj_tab_t *, raid_obj_id_t,
2N/A raid_obj_handle_t);
2N/A
2N/Astatic void raid_list_create(raid_list_t *, size_t);
2N/Astatic void *raid_list_head(raid_list_t *);
2N/Astatic void *raid_list_next(raid_list_t *, void *);
2N/Astatic void raid_list_insert_tail(raid_list_t *, void *);
2N/Astatic void raid_list_remove(raid_list_t *, void *);
2N/Astatic void *raid_list_remove_head(raid_list_t *);
2N/Astatic void *raid_list_find(raid_list_t *, raid_obj_id_t);
2N/Astatic int raid_obj_tab_create(raid_obj_tab_t *, size_t);
2N/Astatic void raid_obj_tab_destroy(raid_obj_tab_t *);
2N/Astatic int raid_obj_tab_insert(raid_obj_tab_t *, raid_obj_id_t, void *);
2N/Astatic void *raid_obj_tab_remove(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic void *raid_obj_tab_find(raid_obj_tab_t *, raid_obj_id_t);
2N/Astatic void raid_list_destroy(raid_list_t *);
2N/A
2N/Astatic int controller_id_to_path(uint32_t, char *);
2N/Astatic char *controller_id_to_driver_name(uint32_t);
2N/Astatic void raid_plugin_init();
2N/Astatic raid_lib_t *raid_plugin_load(char *);
2N/Astatic raid_lib_t *raid_find_lib(raid_obj_tab_t *, raid_obj_id_t);
2N/A
2N/A/* Global object table */
2N/Astatic raid_obj_tab_t raid_tab_sys = {0, 0, NULL};
2N/A
2N/A/* Plug-in modules maintenance data structures */
2N/Astatic raid_lib_t *raid_lib_sys = NULL;
2N/A
2N/A/* Handle table definition */
2N/Astatic struct {
2N/A int handle_num;
2N/A int used;
2N/A int unused;
2N/A handle_attr_t *handles;
2N/A} raid_handle_sys = {0, 0, 0, NULL};
2N/A
2N/A/*
2N/A * RAID object method table definition
2N/A */
2N/Astatic raid_obj_op_t raid_obj_op_sys[OBJ_TYPE_ALL] = {
2N/A {obj_sys_compnum, obj_sys_complist, NULL, NULL, NULL,
2N/A NULL, NULL, NULL, NULL}, /* system object methods */
2N/A {obj_controller_compnum, obj_controller_complist,
2N/A obj_controller_get_attr, NULL, obj_controller_act,
2N/A NULL, NULL, NULL, NULL}, /* controller object methods */
2N/A {obj_array_compnum, obj_array_complist, obj_array_get_attr,
2N/A obj_array_set_attr, NULL, obj_array_create,
2N/A obj_array_delete, NULL, NULL}, /* array object methods */
2N/A {obj_disk_compnum, obj_disk_complist, obj_disk_get_attr, NULL,
2N/A NULL, NULL, NULL, NULL, NULL}, /* disk object methods */
2N/A {NULL, NULL, obj_hsp_get_attr, NULL, NULL, NULL, NULL, obj_hsp_bind,
2N/A obj_hsp_unbind}, /* hsp object methods */
2N/A {NULL, NULL, obj_arraypart_get_attr, NULL, NULL, NULL, NULL,
2N/A NULL, NULL}, /* array part object methods */
2N/A {NULL, NULL, obj_diskseg_get_attr, NULL, NULL, NULL, NULL, NULL, NULL},
2N/A {NULL, NULL, obj_task_get_attr, NULL, NULL, NULL, NULL,
2N/A NULL, NULL}, /* disk seg object methods */
2N/A {NULL, NULL, obj_prop_get_attr, NULL, NULL, NULL, NULL,
2N/A NULL, NULL} /* property object methods */
2N/A};
2N/A
2N/A/*
2N/A * Mutex for multithread safe
2N/A */
2N/Astatic mutex_t raidcfg_mp;
2N/A
2N/A/*
2N/A * RaidCfg library APIs
2N/A */
2N/Aconst char *
2N/Araidcfg_errstr(int err_code)
2N/A{
2N/A char *ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A switch (err_code) {
2N/A case SUCCESS:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Operation succeeded.\n");
2N/A break;
2N/A case STD_IOCTL:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Request standard IOCTL service.\n");
2N/A break;
2N/A case ERR_DRIVER_NOT_FOUND:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Controller device can not be found.\n");
2N/A break;
2N/A case ERR_DRIVER_OPEN:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Can not open controller.\n");
2N/A break;
2N/A case ERR_DRIVER_LOCK:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Controller is locked.\n");
2N/A break;
2N/A case ERR_DRIVER_CLOSED:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Controller is not opened.\n");
2N/A break;
2N/A case ERR_DRIVER_ACROSS:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Operation across multiple controllers.\n");
2N/A break;
2N/A case ERR_ARRAY_LEVEL:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Operation not support with volume of this level.\n");
2N/A break;
2N/A case ERR_ARRAY_SIZE:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Capacity of array out of range.\n");
2N/A break;
2N/A case ERR_ARRAY_STRIPE_SIZE:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Illegal stripe size.\n");
2N/A break;
2N/A case ERR_ARRAY_CACHE_POLICY:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Illegal cache-write policy.\n");
2N/A break;
2N/A case ERR_ARRAY_IN_USE:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Array or disk in use.\n");
2N/A break;
2N/A case ERR_ARRAY_TASK:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Array has background task.\n");
2N/A break;
2N/A case ERR_ARRAY_CONFIG:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Configuration over device node failed.\n");
2N/A break;
2N/A case ERR_ARRAY_DISKNUM:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Incorrect number of disks.\n");
2N/A break;
2N/A case ERR_ARRAY_LAYOUT:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Illegal array layout.\n");
2N/A break;
2N/A case ERR_ARRAY_AMOUNT:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Too many arrays.\n");
2N/A break;
2N/A case ERR_DISK_STATE:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Incorrect disk status for current operation.\n");
2N/A break;
2N/A case ERR_DISK_SPACE:
2N/A ret_val = dgettext(TEXT_DOMAIN, "No enough disk space.\n");
2N/A break;
2N/A case ERR_DISK_SEG_AMOUNT:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Too many disk segments.\n");
2N/A break;
2N/A case ERR_DISK_NOT_EMPTY:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Disk has occupied space.\n");
2N/A break;
2N/A case ERR_DISK_TASK:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Disk has background task.\n");
2N/A break;
2N/A case ERR_TASK_STATE:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Incorrect task state for current operation.\n");
2N/A break;
2N/A case ERR_OP_ILLEGAL:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Illegal operation.\n");
2N/A break;
2N/A case ERR_OP_NO_IMPL:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Operation is not implemented.\n");
2N/A break;
2N/A case ERR_OP_FAILED:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Operation failed.\n");
2N/A break;
2N/A case ERR_DEVICE_NOENT:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Device not found.\n");
2N/A break;
2N/A case ERR_DEVICE_TYPE:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Illegal type of device.\n");
2N/A break;
2N/A case ERR_DEVICE_DUP:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Device record duplicated.\n");
2N/A break;
2N/A case ERR_DEVICE_OVERFLOW:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Too many devices.\n");
2N/A break;
2N/A case ERR_DEVICE_UNCLEAN:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Device pool is not clean.\n");
2N/A break;
2N/A case ERR_DEVICE_INVALID:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Device record is invalid.\n");
2N/A break;
2N/A case ERR_NOMEM:
2N/A ret_val = dgettext(TEXT_DOMAIN,
2N/A "Can not allocate more memory space.\n");
2N/A break;
2N/A case ERR_PRIV:
2N/A ret_val = dgettext(TEXT_DOMAIN, "No privilege.\n");
2N/A break;
2N/A default:
2N/A ret_val = dgettext(TEXT_DOMAIN, "Undefined error.\n");
2N/A }
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_controller(uint32_t controller_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = obj_locate_controller(&raid_tab_sys, controller_id);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A
2N/A if (obj_id == OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_array(int controller_handle, uint64_t target_id, uint64_t lun)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A raidcfg_array_t *attr;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, controller_handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A
2N/A obj_id = obj_get_comp(&raid_tab_sys, obj_id, OBJ_TYPE_ARRAY);
2N/A
2N/A while (obj_id > OBJ_NONE) {
2N/A (void) obj_get_attr(&raid_tab_sys, obj_id, (void **)(&attr));
2N/A if (attr->tag.idl.target_id == target_id &&
2N/A attr->tag.idl.lun == lun)
2N/A break;
2N/A
2N/A obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
2N/A }
2N/A
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A if (obj_id == OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_disk(int controller_handle, disk_tag_t tag)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A raidcfg_disk_t *attr;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, controller_handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A
2N/A obj_id = obj_get_comp(&raid_tab_sys, obj_id, OBJ_TYPE_DISK);
2N/A
2N/A while (obj_id > OBJ_NONE) {
2N/A (void) obj_get_attr(&raid_tab_sys, obj_id, (void **)(&attr));
2N/A if (attr->tag.cidl.bus == tag.cidl.bus &&
2N/A attr->tag.cidl.target_id == tag.cidl.target_id &&
2N/A attr->tag.cidl.lun == tag.cidl.lun)
2N/A break;
2N/A
2N/A obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
2N/A }
2N/A
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A if (obj_id == OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_open_controller(int handle, char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A ret = obj_controller_act(&raid_tab_sys, obj_id,
2N/A ACT_CONTROLLER_OPEN, NULL, plugin_err_str);
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_close_controller(int handle, char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A ret = obj_controller_act(&raid_tab_sys, obj_id,
2N/A ACT_CONTROLLER_CLOSE, NULL, plugin_err_str);
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_type(int handle)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A ret_val = raid_obj_get_type(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_attr(int handle, void *attr)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A raid_obj_type_id_t type;
2N/A void *data;
2N/A int ret, size;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A if (attr == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A type = raid_obj_get_type(&raid_tab_sys, obj_id);
2N/A ret = obj_get_attr(&raid_tab_sys, obj_id, &data);
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A switch (type) {
2N/A case OBJ_TYPE_CONTROLLER:
2N/A size = sizeof (controller_attr_t);
2N/A break;
2N/A case OBJ_TYPE_ARRAY:
2N/A size = sizeof (array_attr_t);
2N/A break;
2N/A case OBJ_TYPE_HSP:
2N/A {
2N/A raidcfg_hsp_t *dst = attr;
2N/A hsp_attr_t *src = data;
2N/A controller_attr_t *ctlr_attr;
2N/A array_attr_t *array_attr;
2N/A
2N/A dst->associated_id = src->associated_id;
2N/A dst->type = src->type;
2N/A
2N/A obj_id = obj_get_controller(&raid_tab_sys, obj_id);
2N/A ret = obj_get_attr(&raid_tab_sys, obj_id,
2N/A (void **)(&ctlr_attr));
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A if (src->type == HSP_TYPE_LOCAL) {
2N/A obj_id = obj_locate_array(&raid_tab_sys,
2N/A ctlr_attr->controller_id,
2N/A src->associated_id);
2N/A ret = obj_get_attr(&raid_tab_sys, obj_id,
2N/A (void **)(&array_attr));
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A dst->tag.idl.target_id =
2N/A array_attr->tag.idl.target_id;
2N/A dst->tag.idl.lun = array_attr->tag.idl.lun;
2N/A }
2N/A }
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (SUCCESS);
2N/A case OBJ_TYPE_DISK:
2N/A size = sizeof (disk_attr_t);
2N/A break;
2N/A case OBJ_TYPE_ARRAY_PART:
2N/A {
2N/A raidcfg_arraypart_t *dst = attr;
2N/A arraypart_attr_t *src = data;
2N/A controller_attr_t *ctlr_attr;
2N/A disk_attr_t *disk_attr;
2N/A
2N/A dst->disk_id = src->disk_id;
2N/A dst->offset = src->offset;
2N/A dst->size = src->size;
2N/A dst->state = src->state;
2N/A
2N/A obj_id = obj_get_controller(&raid_tab_sys, obj_id);
2N/A ret = obj_get_attr(&raid_tab_sys, obj_id,
2N/A (void **)(&ctlr_attr));
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A obj_id = obj_locate_disk(&raid_tab_sys,
2N/A ctlr_attr->controller_id, src->disk_id);
2N/A if (obj_id <= OBJ_NONE) {
2N/A dst->tag.cidl.bus = (uint64_t)OBJ_ATTR_NONE;
2N/A dst->tag.cidl.target_id =
2N/A (uint64_t)OBJ_ATTR_NONE;
2N/A dst->tag.cidl.lun = (uint64_t)OBJ_ATTR_NONE;
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A ret = obj_get_attr(&raid_tab_sys, obj_id,
2N/A (void **)(&disk_attr));
2N/A if (ret < SUCCESS) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A dst->tag.cidl.bus = disk_attr->tag.cidl.bus;
2N/A dst->tag.cidl.target_id = disk_attr->tag.cidl.target_id;
2N/A dst->tag.cidl.lun = disk_attr->tag.cidl.lun;
2N/A }
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (SUCCESS);
2N/A case OBJ_TYPE_DISK_SEG:
2N/A size = sizeof (diskseg_attr_t);
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A size = sizeof (task_attr_t);
2N/A break;
2N/A case OBJ_TYPE_PROP:
2N/A {
2N/A property_attr_t *src = data, *dst = attr;
2N/A
2N/A dst->prop_id = src->prop_id;
2N/A dst->prop_type = src->prop_type;
2N/A if (dst->prop_size == 0) {
2N/A dst->prop_size = src->prop_size;
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A if (dst->prop_size < src->prop_size)
2N/A size = dst->prop_size;
2N/A else
2N/A size = src->prop_size;
2N/A
2N/A (void) memcpy(dst->prop, src->prop, size);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (SUCCESS);
2N/A }
2N/A /* NOTREACHED */
2N/A break;
2N/A default:
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A (void) memcpy(attr, data, size);
2N/A
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_get_container(int handle)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A obj_id = raid_obj_get_container(&raid_tab_sys, obj_id);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_list_head(int handle, raid_obj_type_id_t type)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A obj_id = obj_get_comp(&raid_tab_sys, obj_id, type);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_list_next(int handle)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret_val;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
2N/A if (obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret_val);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_set_attr(int handle, uint32_t set_cmd, void *value,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A raid_obj_type_id_t type;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A type = raid_obj_get_type(&raid_tab_sys, obj_id);
2N/A if (raid_obj_op_sys[type].set_attr == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_OP_NO_IMPL);
2N/A }
2N/A
2N/A ret = raid_obj_op_sys[type].set_attr(&raid_tab_sys,
2N/A obj_id, set_cmd, value, plugin_err_str);
2N/A
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_update_fw(int handle, char *file, char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
2N/A if (obj_id < OBJ_NONE) {
2N/A raid_handle_delete(handle);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A
2N/A if (raid_obj_get_type(&raid_tab_sys, obj_id) != OBJ_TYPE_CONTROLLER) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_OP_NO_IMPL);
2N/A }
2N/A
2N/A ret = raid_obj_op_sys[OBJ_TYPE_CONTROLLER].act(&raid_tab_sys,
2N/A obj_id, ACT_CONTROLLER_FLASH_FW, file, plugin_err_str);
2N/A
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_create_array(int num_of_comps, int *disk_handles,
2N/A uint32_t raid_level, uint64_t size, uint32_t stripe_size,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t *disk_obj_ids, obj_id;
2N/A array_attr_t *array_attr;
2N/A raid_obj_handle_t array_handle;
2N/A int i, ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A
2N/A disk_obj_ids = calloc(num_of_comps, sizeof (raid_obj_id_t));
2N/A if (disk_obj_ids == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_NOMEM);
2N/A }
2N/A
2N/A /* convert disk handles into disk object ids; */
2N/A for (i = 0; i < num_of_comps; ++i) {
2N/A if (*(disk_handles + i) == OBJ_SEPARATOR_BEGIN ||
2N/A *(disk_handles + i) == OBJ_SEPARATOR_END) {
2N/A *(disk_obj_ids + i) = *(disk_handles + i);
2N/A continue;
2N/A }
2N/A
2N/A *(disk_obj_ids + i) = raid_handle_to_obj(&raid_tab_sys,
2N/A *(disk_handles + i));
2N/A if (raid_obj_get_type(&raid_tab_sys, *(disk_obj_ids + i)) !=
2N/A OBJ_TYPE_DISK) {
2N/A free(disk_obj_ids);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A }
2N/A
2N/A /* Create an empty array object */
2N/A obj_id = raid_obj_create(&raid_tab_sys, OBJ_TYPE_ARRAY);
2N/A if (obj_id < OBJ_NONE) {
2N/A free(disk_obj_ids);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (obj_id);
2N/A }
2N/A (void) raid_obj_clear_status(&raid_tab_sys, obj_id,
2N/A OBJ_STATUS_CMD_CLEAN);
2N/A
2N/A array_attr = raid_obj_get_data_ptr(&raid_tab_sys, obj_id);
2N/A array_attr->array_id = (uint32_t)OBJ_ATTR_NONE;
2N/A array_attr->raid_level = raid_level;
2N/A array_attr->capacity = size;
2N/A array_attr->stripe_size = stripe_size;
2N/A array_attr->write_policy = CACHE_WR_ON;
2N/A array_attr->read_policy = CACHE_RD_ON;
2N/A
2N/A ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].create_obj(&raid_tab_sys, obj_id,
2N/A num_of_comps, disk_obj_ids, plugin_err_str);
2N/A free(disk_obj_ids);
2N/A
2N/A if (ret < SUCCESS) {
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A }
2N/A
2N/A /* create_obj() method should put the array object in the device tree */
2N/A array_handle = raid_obj_to_handle(&raid_tab_sys, obj_id);
2N/A
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (array_handle);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_delete_array(int array_handle, char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t array_obj_id;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A
2N/A if (raidcfg_get_type(array_handle) != OBJ_TYPE_ARRAY) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A array_obj_id = raid_handle_to_obj(&raid_tab_sys, array_handle);
2N/A if (array_obj_id < OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (array_obj_id);
2N/A }
2N/A if (array_obj_id == OBJ_NONE) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].delete_obj(&raid_tab_sys,
2N/A array_obj_id, plugin_err_str);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ret);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_set_hsp(raidcfg_hsp_relation_t *hsp_relations,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t disk_obj_id, array_obj_id;
2N/A raid_obj_id_t *hsp_relation_objs;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A if (hsp_relations == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A hsp_relation_objs = malloc(2 * sizeof (raid_obj_id_t));
2N/A if (hsp_relation_objs == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_NOMEM);
2N/A }
2N/A
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A
2N/A if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
2N/A array_obj_id = raid_handle_to_obj(&raid_tab_sys,
2N/A hsp_relations->array_handle);
2N/A if (array_obj_id < OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (array_obj_id);
2N/A }
2N/A if (array_obj_id == OBJ_NONE) {
2N/A (void) free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A if (raidcfg_get_type(hsp_relations->array_handle) !=
2N/A OBJ_TYPE_ARRAY) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A } else
2N/A array_obj_id = OBJ_ATTR_NONE;
2N/A
2N/A disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
2N/A hsp_relations->disk_handle);
2N/A if (disk_obj_id < OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (disk_obj_id);
2N/A }
2N/A if (disk_obj_id == OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A if (raidcfg_get_type(hsp_relations->disk_handle) !=
2N/A OBJ_TYPE_DISK) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A hsp_relation_objs[0] = array_obj_id;
2N/A hsp_relation_objs[1] = disk_obj_id;
2N/A
2N/A ret = raid_obj_op_sys[OBJ_TYPE_HSP].bind_obj(&raid_tab_sys,
2N/A hsp_relation_objs, plugin_err_str);
2N/A
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Aint
2N/Araidcfg_unset_hsp(raidcfg_hsp_relation_t *hsp_relations,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t disk_obj_id, array_obj_id;
2N/A raid_obj_id_t *hsp_relation_objs;
2N/A int ret;
2N/A
2N/A (void) mutex_lock(&raidcfg_mp);
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A if (hsp_relations == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A hsp_relation_objs = malloc(2 * sizeof (raid_obj_id_t));
2N/A if (hsp_relation_objs == NULL) {
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_NOMEM);
2N/A }
2N/A
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A
2N/A if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
2N/A array_obj_id = raid_handle_to_obj(&raid_tab_sys,
2N/A hsp_relations->array_handle);
2N/A if (array_obj_id < OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (array_obj_id);
2N/A }
2N/A if (array_obj_id == OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A if (raidcfg_get_type(hsp_relations->array_handle) !=
2N/A OBJ_TYPE_ARRAY) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A } else
2N/A array_obj_id = OBJ_ATTR_NONE;
2N/A
2N/A disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
2N/A hsp_relations->disk_handle);
2N/A if (disk_obj_id < OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (disk_obj_id);
2N/A }
2N/A if (disk_obj_id == OBJ_NONE) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_NOENT);
2N/A }
2N/A if (raidcfg_get_type(hsp_relations->disk_handle) !=
2N/A OBJ_TYPE_DISK) {
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A hsp_relation_objs[0] = array_obj_id;
2N/A hsp_relation_objs[1] = disk_obj_id;
2N/A
2N/A ret = raid_obj_op_sys[OBJ_TYPE_HSP].unbind_obj(&raid_tab_sys,
2N/A hsp_relation_objs, plugin_err_str);
2N/A
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A free(hsp_relation_objs);
2N/A (void) mutex_unlock(&raidcfg_mp);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/A/*
2N/A * RaidCfg lib routines
2N/A */
2N/Avoid
2N/Araidcfg_init(void)
2N/A{
2N/A (void) mutex_init(&raidcfg_mp, NULL, NULL);
2N/A raid_plugin_init();
2N/A (void) raid_handle_init();
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A}
2N/A
2N/Avoid
2N/Araidcfg_fini(void)
2N/A{
2N/A /*
2N/A * Need to close all opened controllers before destroying object table
2N/A */
2N/A (void) obj_rescan(&raid_tab_sys);
2N/A raid_handle_fini();
2N/A raid_obj_tab_destroy(&raid_tab_sys);
2N/A raid_plugin_init();
2N/A (void) mutex_destroy(&raidcfg_mp);
2N/A}
2N/A
2N/A/*
2N/A * Support routines
2N/A */
2N/Astatic int
2N/Aintcompare(const void *p1, const void *p2)
2N/A{
2N/A int i, j;
2N/A i = *((int *)p1);
2N/A j = *((int *)p2);
2N/A return (i - j);
2N/A}
2N/A
2N/Astatic uint64_t
2N/Araid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
2N/A raid_obj_id_t *disk_objs, arraypart_attr_t *arraypart_attrs)
2N/A{
2N/A disk_attr_t *disk_attr;
2N/A diskseg_attr_t *diskseg_attr;
2N/A raid_obj_id_t obj_id;
2N/A uint64_t offset, capacity;
2N/A int i, disk_num, sub_array_num, disk_layer;
2N/A
2N/A /* Find out the maximum available space for all disks */
2N/A for (i = 0; i < num; ++i) {
2N/A if ((disk_objs[i] == OBJ_SEPARATOR_BEGIN) ||
2N/A (disk_objs[i] == OBJ_SEPARATOR_END))
2N/A continue;
2N/A
2N/A (void) obj_get_attr(raid_tab, disk_objs[i],
2N/A (void **)(&disk_attr));
2N/A obj_id = obj_get_comp(raid_tab, disk_objs[i],
2N/A OBJ_TYPE_DISK_SEG);
2N/A if (obj_id == OBJ_NONE) {
2N/A arraypart_attrs[i].offset = 0;
2N/A arraypart_attrs[i].size = disk_attr->capacity;
2N/A continue;
2N/A }
2N/A
2N/A (void) obj_get_attr(raid_tab, obj_id, (void **)
2N/A (&diskseg_attr));
2N/A arraypart_attrs[i].offset = 0;
2N/A arraypart_attrs[i].size = diskseg_attr->offset;
2N/A offset = diskseg_attr->offset + diskseg_attr->size;
2N/A
2N/A while ((obj_id = obj_get_sibling(raid_tab, obj_id)) !=
2N/A OBJ_NONE) {
2N/A (void) obj_get_attr(raid_tab, obj_id,
2N/A (void **)(&diskseg_attr));
2N/A if ((diskseg_attr->offset - offset) >
2N/A arraypart_attrs[i].size) {
2N/A arraypart_attrs[i].offset = offset;
2N/A arraypart_attrs[i].size = diskseg_attr->offset -
2N/A offset;
2N/A }
2N/A
2N/A offset = diskseg_attr->offset + diskseg_attr->size;
2N/A }
2N/A
2N/A if ((disk_attr->capacity - offset) > arraypart_attrs[i].size) {
2N/A arraypart_attrs[i].offset = offset;
2N/A arraypart_attrs[i].size = disk_attr->capacity -
2N/A offset;
2N/A }
2N/A }
2N/A
2N/A capacity = OBJ_ATTR_NONE;
2N/A disk_num = 0;
2N/A disk_layer = 0;
2N/A sub_array_num = 0;
2N/A for (i = 0; i < num; ++i) {
2N/A if (disk_objs[i] == OBJ_SEPARATOR_BEGIN) {
2N/A ++ disk_layer;
2N/A continue;
2N/A }
2N/A if (disk_objs[i] == OBJ_SEPARATOR_END) {
2N/A -- disk_layer;
2N/A if (disk_layer != 0)
2N/A ++ sub_array_num;
2N/A continue;
2N/A }
2N/A
2N/A if (capacity > arraypart_attrs[i].size)
2N/A capacity = arraypart_attrs[i].size;
2N/A ++disk_num;
2N/A }
2N/A
2N/A switch (raid_level) {
2N/A case RAID_LEVEL_0:
2N/A capacity = capacity * disk_num;
2N/A break;
2N/A case RAID_LEVEL_1:
2N/A capacity = capacity * disk_num / 2;
2N/A break;
2N/A case RAID_LEVEL_1E:
2N/A capacity = capacity * disk_num / 2;
2N/A break;
2N/A case RAID_LEVEL_5:
2N/A capacity = capacity * (disk_num - 1);
2N/A break;
2N/A case RAID_LEVEL_10:
2N/A capacity = capacity * disk_num / 2;
2N/A break;
2N/A case RAID_LEVEL_50:
2N/A capacity = capacity * (disk_num - sub_array_num);
2N/A break;
2N/A default:
2N/A return (ERR_ARRAY_LEVEL);
2N/A /* NOTREACHED */
2N/A break;
2N/A }
2N/A
2N/A return (capacity);
2N/A}
2N/A
2N/A/*
2N/A * Raid handle maintenance routines
2N/A */
2N/Astatic int
2N/Araid_handle_init()
2N/A{
2N/A int i;
2N/A void *ptr;
2N/A
2N/A raid_handle_sys.handle_num += HANDLER_SLOTS;
2N/A ptr = realloc(raid_handle_sys.handles,
2N/A raid_handle_sys.handle_num * sizeof (handle_attr_t));
2N/A if (ptr == NULL)
2N/A return (ERR_NOMEM);
2N/A raid_handle_sys.handles = ptr;
2N/A
2N/A /* Clean up the new allocated handles */
2N/A for (i = raid_handle_sys.handle_num - HANDLER_SLOTS;
2N/A i < raid_handle_sys.handle_num; ++i) {
2N/A bzero(&raid_handle_sys.handles[i], sizeof (handle_attr_t));
2N/A raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
2N/A raid_handle_sys.handles[i].next = i + 1;
2N/A }
2N/A
2N/A /* For the first time of allocation, set up the system object handle */
2N/A if (raid_handle_sys.handle_num == HANDLER_SLOTS) {
2N/A raid_handle_sys.handles[0].type = OBJ_TYPE_SYSTEM;
2N/A raid_handle_sys.handles[0].next = 0;
2N/A raid_handle_sys.unused = 1;
2N/A raid_handle_sys.used = 0;
2N/A }
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic void
2N/Araid_handle_fini()
2N/A{
2N/A raid_obj_handle_t i;
2N/A
2N/A i = raid_handle_sys.used;
2N/A
2N/A /* Close all opened controllers */
2N/A while (i != 0) {
2N/A if ((raid_handle_sys.handles[i].type == OBJ_TYPE_CONTROLLER) &&
2N/A (raid_handle_sys.handles[i].fd != 0) &&
2N/A (raid_handle_sys.handles[i].raid_lib != NULL))
2N/A raid_handle_sys.handles[i].raid_lib->close_controller(
2N/A raid_handle_sys.handles[i].controller_id, NULL);
2N/A i = raid_handle_sys.handles[i].next;
2N/A }
2N/A
2N/A /* Clean up handle space */
2N/A raid_handle_sys.handle_num = 0;
2N/A raid_handle_sys.unused = 0;
2N/A raid_handle_sys.used = 0;
2N/A free(raid_handle_sys.handles);
2N/A raid_handle_sys.handles = NULL;
2N/A}
2N/A
2N/Astatic raid_obj_handle_t
2N/Araid_handle_new(raid_obj_type_id_t type)
2N/A{
2N/A int ret;
2N/A
2N/A if (raid_handle_sys.unused == raid_handle_sys.handle_num - 1) {
2N/A ret = raid_handle_init();
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A }
2N/A
2N/A ret = raid_handle_sys.unused;
2N/A raid_handle_sys.unused = raid_handle_sys.handles[ret].next;
2N/A
2N/A raid_handle_sys.handles[ret].next = raid_handle_sys.used;
2N/A raid_handle_sys.used = ret;
2N/A raid_handle_sys.handles[ret].type = type;
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic void
2N/Araid_handle_delete(raid_obj_handle_t handle)
2N/A{
2N/A int i = raid_handle_sys.used, j = 0;
2N/A
2N/A if (handle == 0)
2N/A return;
2N/A
2N/A while (i != 0 && i != handle) {
2N/A j = i;
2N/A i = raid_handle_sys.handles[i].next;
2N/A }
2N/A
2N/A if (i == handle) {
2N/A if (j != 0)
2N/A raid_handle_sys.handles[j].next =
2N/A raid_handle_sys.handles[i].next;
2N/A else
2N/A raid_handle_sys.used =
2N/A raid_handle_sys.handles[i].next;
2N/A
2N/A raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
2N/A raid_handle_sys.handles[i].next =
2N/A raid_handle_sys.unused;
2N/A raid_handle_sys.unused = i;
2N/A }
2N/A}
2N/A
2N/Astatic void
2N/Araid_handle_delete_controller_comp(uint32_t controller_id)
2N/A{
2N/A int i = raid_handle_sys.used, j;
2N/A
2N/A while (i != 0) {
2N/A j = i;
2N/A i = raid_handle_sys.handles[i].next;
2N/A if ((raid_handle_sys.handles[j].controller_id ==
2N/A controller_id) &&
2N/A (raid_handle_sys.handles[j].type !=
2N/A OBJ_TYPE_CONTROLLER))
2N/A raid_handle_delete(j);
2N/A }
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_handle_to_obj(raid_obj_tab_t *raid_tab, raid_obj_handle_t handle)
2N/A{
2N/A handle_attr_t *handle_attr;
2N/A raid_obj_id_t obj_id;
2N/A
2N/A if (handle == OBJ_SYSTEM)
2N/A return (OBJ_SYSTEM);
2N/A
2N/A handle_attr = raid_handle_sys.handles + handle;
2N/A
2N/A switch (handle_attr->type) {
2N/A case OBJ_TYPE_SYSTEM:
2N/A return (OBJ_SYSTEM);
2N/A case OBJ_TYPE_CONTROLLER:
2N/A obj_id = obj_locate_controller(raid_tab,
2N/A handle_attr->controller_id);
2N/A break;
2N/A case OBJ_TYPE_ARRAY:
2N/A obj_id = obj_locate_array(raid_tab,
2N/A handle_attr->controller_id, handle_attr->array_id);
2N/A break;
2N/A case OBJ_TYPE_HSP:
2N/A obj_id = obj_locate_hsp(raid_tab,
2N/A handle_attr->controller_id, handle_attr->disk_id,
2N/A handle_attr->array_id);
2N/A break;
2N/A case OBJ_TYPE_DISK:
2N/A obj_id = obj_locate_disk(raid_tab,
2N/A handle_attr->controller_id, handle_attr->disk_id);
2N/A break;
2N/A case OBJ_TYPE_ARRAY_PART:
2N/A obj_id = obj_locate_arraypart(raid_tab,
2N/A handle_attr->controller_id, handle_attr->array_id,
2N/A handle_attr->disk_id);
2N/A break;
2N/A case OBJ_TYPE_DISK_SEG:
2N/A obj_id = obj_locate_diskseg(raid_tab,
2N/A handle_attr->controller_id,
2N/A handle_attr->disk_id, handle_attr->seq_id);
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A obj_id = obj_locate_task(raid_tab,
2N/A handle_attr->controller_id, handle_attr->task_id);
2N/A break;
2N/A case OBJ_TYPE_PROP:
2N/A obj_id = obj_locate_prop(raid_tab,
2N/A handle_attr->controller_id, handle_attr->disk_id,
2N/A handle_attr->prop_id);
2N/A break;
2N/A default:
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A if (obj_id == OBJ_NONE)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A (void) raid_obj_set_handle(raid_tab, obj_id, handle);
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_handle_t
2N/Araid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_id_t obj_id_backup = obj_id;
2N/A raid_obj_type_id_t type;
2N/A raid_obj_handle_t handle;
2N/A controller_attr_t *controller_attr;
2N/A array_attr_t *array_attr;
2N/A hsp_attr_t *hsp_attr;
2N/A disk_attr_t *disk_attr;
2N/A arraypart_attr_t *arraypart_attr;
2N/A diskseg_attr_t *diskseg_attr;
2N/A task_attr_t *task_attr;
2N/A property_attr_t *prop_attr;
2N/A
2N/A if (obj_id == OBJ_SYSTEM)
2N/A return (OBJ_SYSTEM);
2N/A
2N/A /* If the object mapped by a handle */
2N/A handle = raid_obj_get_handle(raid_tab, obj_id);
2N/A if (handle != 0)
2N/A return (handle);
2N/A
2N/A /* Search for existing handles */
2N/A for (handle = raid_handle_sys.used; handle != 0;
2N/A handle = raid_handle_sys.handles[handle].next)
2N/A if (raid_handle_to_obj(raid_tab, handle) == obj_id)
2N/A break;
2N/A
2N/A if (handle != 0)
2N/A return (handle);
2N/A
2N/A /* Allocate new handle for this object */
2N/A type = raid_obj_get_type(raid_tab, obj_id);
2N/A handle = raid_handle_new(type);
2N/A (void) raid_obj_set_handle(raid_tab, obj_id, handle);
2N/A raid_handle_sys.handles[handle].type = type;
2N/A
2N/A switch (type) {
2N/A case OBJ_TYPE_SYSTEM:
2N/A break;
2N/A case OBJ_TYPE_CONTROLLER:
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_ARRAY:
2N/A array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].array_id = array_attr->array_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_HSP:
2N/A hsp_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].array_id =
2N/A hsp_attr->associated_id;
2N/A obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_DISK:
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_ARRAY_PART:
2N/A arraypart_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].disk_id =
2N/A arraypart_attr->disk_id;
2N/A obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].array_id =
2N/A array_attr->array_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_DISK_SEG:
2N/A diskseg_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].seq_id = diskseg_attr->seq_no;
2N/A obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].disk_id =
2N/A disk_attr->disk_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A task_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].task_id = task_attr->task_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A case OBJ_TYPE_PROP:
2N/A prop_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].prop_id =
2N/A prop_attr->prop_id;
2N/A obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
2N/A obj_id = obj_get_controller(raid_tab, obj_id);
2N/A controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A raid_handle_sys.handles[handle].controller_id =
2N/A controller_attr->controller_id;
2N/A break;
2N/A default:
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A (void) raid_obj_set_handle(raid_tab, obj_id_backup, handle);
2N/A return (handle);
2N/A}
2N/A
2N/Astatic raid_lib_t *
2N/Araid_obj_get_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_handle_t handle;
2N/A controller_attr_t *attr;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (NULL);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A handle = raid_handle_sys.used;
2N/A while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
2N/A raid_handle_sys.handles[handle].controller_id !=
2N/A attr->controller_id)
2N/A handle = raid_handle_sys.handles[handle].next;
2N/A
2N/A if (handle == 0)
2N/A return (NULL);
2N/A
2N/A return (raid_handle_sys.handles[handle].raid_lib);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_lib_t *raid_lib)
2N/A{
2N/A raid_obj_handle_t handle;
2N/A controller_attr_t *attr;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A handle = raid_handle_sys.used;
2N/A while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
2N/A raid_handle_sys.handles[handle].controller_id !=
2N/A attr->controller_id)
2N/A handle = raid_handle_sys.handles[handle].next;
2N/A
2N/A if (handle == 0)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A raid_handle_sys.handles[handle].raid_lib = raid_lib;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_get_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_handle_t handle;
2N/A controller_attr_t *attr;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A handle = raid_handle_sys.used;
2N/A while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
2N/A raid_handle_sys.handles[handle].controller_id !=
2N/A attr->controller_id)
2N/A handle = raid_handle_sys.handles[handle].next;
2N/A
2N/A if (handle == 0)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (raid_handle_sys.handles[handle].fd);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, int fd)
2N/A{
2N/A raid_obj_handle_t handle;
2N/A controller_attr_t *attr;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A handle = raid_handle_sys.used;
2N/A while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
2N/A raid_handle_sys.handles[handle].controller_id !=
2N/A attr->controller_id)
2N/A handle = raid_handle_sys.handles[handle].next;
2N/A
2N/A if (handle == 0)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A raid_handle_sys.handles[handle].fd = fd;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/A/*
2N/A * Raid object maintenance routines
2N/A */
2N/Astatic int
2N/Aobj_scan_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_status_t status;
2N/A raid_obj_type_id_t type;
2N/A int ret, i, obj_type_cnt, comp_num;
2N/A raid_obj_id_t *comp_list;
2N/A
2N/A status = raid_obj_get_status(raid_tab, obj_id);
2N/A if (status < SUCCESS)
2N/A return (status);
2N/A
2N/A if (status & OBJ_STATUS_SCANCOMP)
2N/A return (SUCCESS);
2N/A
2N/A type = raid_obj_get_type(raid_tab, obj_id);
2N/A /* type less than OBJ_TYPE_SYSTEM means error */
2N/A if (type < OBJ_TYPE_SYSTEM)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A for (obj_type_cnt = OBJ_SYSTEM; obj_type_cnt < OBJ_TYPE_ALL;
2N/A ++obj_type_cnt) {
2N/A if (raid_obj_op_sys[type].compnum != NULL)
2N/A comp_num = raid_obj_op_sys[type].compnum(
2N/A raid_tab, obj_id, obj_type_cnt);
2N/A else
2N/A comp_num = 0;
2N/A
2N/A if (comp_num < SUCCESS)
2N/A return (comp_num);
2N/A if (comp_num == 0)
2N/A continue;
2N/A
2N/A comp_list = calloc(comp_num, sizeof (raid_obj_id_t));
2N/A if (comp_list == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A for (i = 0; i < comp_num; ++i) {
2N/A *(comp_list + i) = raid_obj_create(raid_tab,
2N/A obj_type_cnt);
2N/A if (*(comp_list + i) < SUCCESS) {
2N/A ret = *(comp_list + i);
2N/A free(comp_list);
2N/A return (ret);
2N/A }
2N/A
2N/A (void) raid_obj_clear_status(raid_tab,
2N/A *(comp_list + i), OBJ_STATUS_CMD_CLEAN);
2N/A (void) raid_obj_add_org(raid_tab, *(comp_list + i),
2N/A obj_id);
2N/A }
2N/A
2N/A if (raid_obj_op_sys[type].complist != NULL)
2N/A raid_obj_op_sys[type].complist(raid_tab,
2N/A obj_id, comp_num, comp_list, obj_type_cnt);
2N/A free(comp_list);
2N/A }
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_SCANCOMP);
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_rescan(raid_obj_tab_t *raid_tab)
2N/A{
2N/A int ret;
2N/A
2N/A raid_obj_tab_destroy(raid_tab);
2N/A
2N/A if (raid_obj_tab_create(raid_tab, HASH_SLOTS) != SUCCESS)
2N/A return (ERR_NOMEM);
2N/A
2N/A if ((ret = raid_obj_create_system_obj(raid_tab)) != SUCCESS) {
2N/A raid_obj_tab_destroy(raid_tab);
2N/A return (ret);
2N/A }
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_get_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t obj_type)
2N/A{
2N/A raid_obj_id_t id;
2N/A raid_obj_type_id_t type;
2N/A raid_obj_status_t status;
2N/A int ret;
2N/A
2N/A if ((obj_type < OBJ_TYPE_SYSTEM) || (obj_type > OBJ_TYPE_ALL))
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A status = raid_obj_get_status(raid_tab, obj_id);
2N/A if (status < SUCCESS)
2N/A return (status);
2N/A
2N/A if (!(status & OBJ_STATUS_SCANCOMP)) {
2N/A ret = obj_scan_comp(raid_tab, obj_id);
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A }
2N/A
2N/A id = raid_obj_get_comp(raid_tab, obj_id);
2N/A if (id <= OBJ_NONE)
2N/A return (id);
2N/A
2N/A type = raid_obj_get_type(raid_tab, id);
2N/A if (type < OBJ_TYPE_SYSTEM)
2N/A return (type);
2N/A
2N/A if (type == obj_type)
2N/A return (id);
2N/A
2N/A while (id > OBJ_NONE) {
2N/A id = raid_obj_get_sibling(raid_tab, id);
2N/A if (id <= OBJ_NONE)
2N/A return (id);
2N/A
2N/A type = raid_obj_get_type(raid_tab, id);
2N/A if (type < OBJ_TYPE_SYSTEM)
2N/A return (type);
2N/A
2N/A if (type == obj_type)
2N/A break;
2N/A };
2N/A
2N/A return (id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_get_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_id_t id;
2N/A raid_obj_type_id_t type, obj_type;
2N/A
2N/A id = obj_id;
2N/A obj_type = raid_obj_get_type(raid_tab, id);
2N/A if (obj_type < OBJ_TYPE_SYSTEM)
2N/A return (obj_type);
2N/A
2N/A do {
2N/A id = raid_obj_get_sibling(raid_tab, id);
2N/A if (id < OBJ_NONE)
2N/A return (id);
2N/A
2N/A type = raid_obj_get_type(raid_tab, id);
2N/A if (type < OBJ_TYPE_SYSTEM)
2N/A return (type);
2N/A } while ((type != obj_type) && (id != OBJ_NONE));
2N/A
2N/A return (id);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, void **data)
2N/A{
2N/A raid_obj_type_id_t type;
2N/A raid_obj_status_t status;
2N/A void *attr;
2N/A int ret = SUCCESS;
2N/A
2N/A status = raid_obj_get_status(raid_tab, obj_id);
2N/A if (status < SUCCESS)
2N/A return (status);
2N/A
2N/A type = raid_obj_get_type(raid_tab, obj_id);
2N/A if (type < OBJ_TYPE_SYSTEM)
2N/A return (type);
2N/A
2N/A if (!(status & OBJ_STATUS_OPENED)) {
2N/A if (raid_obj_op_sys[type].get_attr == NULL)
2N/A (void) raid_obj_set_status(raid_tab, obj_id,
2N/A OBJ_STATUS_OPENED);
2N/A else
2N/A ret = raid_obj_op_sys[type].get_attr(raid_tab, obj_id);
2N/A }
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL && type != OBJ_TYPE_SYSTEM)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A *data = attr;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_controller(raid_obj_tab_t *raid_tab, uint32_t controller_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A controller_attr_t *attr;
2N/A
2N/A obj_id = obj_get_comp(raid_tab, OBJ_SYSTEM, OBJ_TYPE_CONTROLLER);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->controller_id == controller_id)
2N/A break;
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) != OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_array(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t array_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A
2N/A obj_id = obj_locate_controller(raid_tab, controller_id);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_locate_array_recur(raid_tab, obj_id, array_id);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_array_recur(raid_obj_tab_t *raid_tab,
2N/A raid_obj_id_t container_obj_id, uint32_t array_id)
2N/A{
2N/A raid_obj_id_t obj_id, ret;
2N/A array_attr_t *attr;
2N/A
2N/A obj_id = obj_get_comp(raid_tab, container_obj_id, OBJ_TYPE_ARRAY);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->array_id == array_id)
2N/A break;
2N/A
2N/A ret = obj_locate_array_recur(raid_tab, obj_id, array_id);
2N/A if (ret != OBJ_NONE)
2N/A return (ret);
2N/A
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_hsp(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t disk_id, uint32_t array_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A hsp_attr_t *hsp_attr;
2N/A
2N/A obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_HSP);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A (void) obj_get_attr(raid_tab, obj_id, (void **)(&hsp_attr));
2N/A if (hsp_attr->associated_id == array_id)
2N/A break;
2N/A
2N/A obj_id = obj_get_sibling(raid_tab, obj_id);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A } while (obj_id > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_disk(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t disk_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A disk_attr_t *attr;
2N/A
2N/A obj_id = obj_locate_controller(raid_tab, controller_id);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->disk_id == disk_id)
2N/A break;
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_arraypart(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t array_id, uint32_t disk_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A
2N/A arraypart_attr_t *attr;
2N/A
2N/A obj_id = obj_locate_array(raid_tab, controller_id, array_id);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY_PART);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->disk_id == disk_id)
2N/A break;
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) >
2N/A OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_diskseg(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t disk_id, uint32_t seq_no)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A diskseg_attr_t *attr;
2N/A
2N/A obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK_SEG);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->seq_no == seq_no)
2N/A break;
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_task(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t task_id)
2N/A{
2N/A raid_obj_id_t obj_id, obj_id2, task_obj_id;
2N/A task_attr_t *attr;
2N/A
2N/A obj_id = obj_locate_controller(raid_tab, controller_id);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A obj_id2 = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY);
2N/A while (obj_id2 != OBJ_NONE) {
2N/A task_obj_id = obj_get_comp(raid_tab, obj_id2,
2N/A OBJ_TYPE_TASK);
2N/A
2N/A if (task_obj_id < OBJ_NONE)
2N/A return (task_obj_id);
2N/A
2N/A if (task_obj_id == OBJ_NONE) {
2N/A obj_id2 = obj_get_sibling(raid_tab, obj_id2);
2N/A continue;
2N/A }
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->task_id == task_id)
2N/A return (task_obj_id);
2N/A
2N/A obj_id2 = obj_get_sibling(raid_tab, obj_id2);
2N/A }
2N/A
2N/A task_obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_TASK);
2N/A if (task_obj_id < OBJ_NONE)
2N/A return (task_obj_id);
2N/A
2N/A if (task_obj_id == OBJ_NONE)
2N/A continue;
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->task_id == task_id)
2N/A return (task_obj_id);
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);
2N/A
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_locate_controller(raid_tab, controller_id);
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A task_obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_TASK);
2N/A if (task_obj_id < OBJ_NONE)
2N/A return (task_obj_id);
2N/A
2N/A if (task_obj_id == OBJ_NONE)
2N/A continue;
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->task_id == task_id)
2N/A return (task_obj_id);
2N/A } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_locate_prop(raid_obj_tab_t *raid_tab, uint32_t controller_id,
2N/A uint32_t disk_id, uint32_t prop_id)
2N/A{
2N/A raid_obj_id_t obj_id;
2N/A property_attr_t *prop_attr;
2N/A
2N/A obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_PROP);
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A
2N/A do {
2N/A (void) obj_get_attr(raid_tab, obj_id, (void **)(&prop_attr));
2N/A if (prop_attr->prop_id == prop_id)
2N/A break;
2N/A
2N/A obj_id = obj_get_sibling(raid_tab, obj_id);
2N/A if (obj_id < OBJ_NONE)
2N/A return (obj_id);
2N/A } while (obj_id > OBJ_NONE);
2N/A
2N/A return (obj_id);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Aobj_get_controller(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_id_t id = obj_id;
2N/A
2N/A while (raid_obj_get_type(raid_tab, id) != OBJ_TYPE_CONTROLLER) {
2N/A id = raid_obj_get_container(raid_tab, id);
2N/A if ((id == OBJ_SYSTEM) || (id < OBJ_NONE))
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A return (id);
2N/A}
2N/A
2N/A/*
2N/A * Raid object operation routines
2N/A */
2N/Astatic int
2N/Aobj_sys_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t comp_type)
2N/A{
2N/A DIR *dir;
2N/A struct dirent *dp;
2N/A int num = 0;
2N/A
2N/A if ((raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_SYSTEM))
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (comp_type != OBJ_TYPE_CONTROLLER)
2N/A return (0);
2N/A
2N/A if ((dir = opendir(CFGDIR)) == NULL)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A
2N/A while ((dp = readdir(dir)) != NULL) {
2N/A uint32_t controller_id;
2N/A char path[MAX_PATH_LEN];
2N/A
2N/A if (strcmp(dp->d_name, ".") == 0 ||
2N/A strcmp(dp->d_name, "..") == 0)
2N/A continue;
2N/A
2N/A if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
2N/A continue;
2N/A
2N/A if (controller_id_to_path(controller_id, path) == SUCCESS)
2N/A ++ num;
2N/A }
2N/A
2N/A (void) closedir(dir);
2N/A return (num);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_sys_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A int num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
2N/A{
2N/A DIR *dir;
2N/A struct dirent *dp;
2N/A controller_attr_t *attr;
2N/A uint32_t controller_id;
2N/A uint32_t *tmplist;
2N/A char path[MAX_PATH_LEN];
2N/A int i = 0;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_SYSTEM)
2N/A return (ERR_DEVICE_TYPE);
2N/A if ((num <= 0) || (comp_list == NULL))
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A if (comp_type != OBJ_TYPE_CONTROLLER)
2N/A return (0);
2N/A
2N/A if ((dir = opendir(CFGDIR)) == NULL)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A tmplist = calloc(num, sizeof (uint32_t));
2N/A if (tmplist == NULL) {
2N/A return (ERR_NOMEM);
2N/A }
2N/A while ((dp = readdir(dir)) != NULL) {
2N/A if (strcmp(dp->d_name, ".") == 0 ||
2N/A strcmp(dp->d_name, "..") == 0)
2N/A continue;
2N/A
2N/A if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
2N/A continue;
2N/A
2N/A if (controller_id_to_path(controller_id, path) == SUCCESS) {
2N/A tmplist[i] = controller_id;
2N/A ++ i;
2N/A }
2N/A }
2N/A qsort((void *)tmplist, num, sizeof (uint32_t), intcompare);
2N/A for (i = 0; i < num; i++) {
2N/A attr = raid_obj_get_data_ptr(raid_tab,
2N/A *(comp_list + i));
2N/A
2N/A if (attr == NULL) {
2N/A free(tmplist);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A attr->controller_id = tmplist[i];
2N/A }
2N/A free(tmplist);
2N/A (void) closedir(dir);
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_controller_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t comp_type)
2N/A{
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A controller_attr_t *ctl_attrp;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if ((comp_type != OBJ_TYPE_ARRAY) && (comp_type != OBJ_TYPE_DISK))
2N/A return (0);
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, obj_id);
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if ((raid_lib == NULL) || (ctl_attrp == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->compnum(ctl_attrp->controller_id, 0,
2N/A OBJ_TYPE_CONTROLLER, comp_type);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_controller_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
2N/A{
2N/A raid_lib_t *raid_lib;
2N/A controller_attr_t *ctl_attrp;
2N/A int ret, i, fd;
2N/A uint32_t *ids;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if ((comp_type != OBJ_TYPE_ARRAY) && (comp_type != OBJ_TYPE_DISK))
2N/A return (0);
2N/A
2N/A if ((comp_num <= 0) || (comp_list == NULL))
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A for (i = 0; i < comp_num; ++i)
2N/A if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
2N/A comp_type)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, obj_id);
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, obj_id);
2N/A if ((raid_lib == NULL) || (ctl_attrp == NULL)|| (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ids = malloc(comp_num * sizeof (uint32_t));
2N/A if (ids == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A ret = raid_lib->complist(ctl_attrp->controller_id, 0,
2N/A OBJ_TYPE_CONTROLLER, comp_type, comp_num, ids);
2N/A if (ret < SUCCESS) {
2N/A free(ids);
2N/A return (ret);
2N/A }
2N/A qsort((void *)ids, comp_num, sizeof (uint32_t), intcompare);
2N/A for (i = 0; i < comp_num; ++ i) {
2N/A array_attr_t *array_attr;
2N/A disk_attr_t *disk_attr;
2N/A void *attr_buf;
2N/A
2N/A attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
2N/A if (attr_buf == NULL) {
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A switch (comp_type) {
2N/A case OBJ_TYPE_ARRAY:
2N/A array_attr = attr_buf;
2N/A array_attr->array_id = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_DISK:
2N/A disk_attr = attr_buf;
2N/A disk_attr->disk_id = *(ids + i);
2N/A break;
2N/A default:
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A }
2N/A
2N/A free(ids);
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_controller_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A controller_attr_t *attr;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, obj_id);
2N/A
2N/A /*
2N/A * For a controller, even it's not opened, we can still
2N/A * get the driver name
2N/A */
2N/A
2N/A if (fd == 0)
2N/A return (SUCCESS);
2N/A
2N/A if (raid_lib == NULL) {
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A ret = raid_lib->get_attr(attr->controller_id, OBJ_ATTR_NONE,
2N/A OBJ_ATTR_NONE, OBJ_TYPE_CONTROLLER, attr);
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A uint32_t sub_cmd, void *prop_list, char **plugin_err_str)
2N/A{
2N/A controller_attr_t *attr;
2N/A raid_lib_t *raid_lib;
2N/A int ret, fd;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, obj_id);
2N/A
2N/A switch (sub_cmd) {
2N/A case ACT_CONTROLLER_OPEN:
2N/A /* Check if already opened */
2N/A
2N/A if (fd > 0)
2N/A return (SUCCESS);
2N/A
2N/A /* Check if plugin is already attached */
2N/A if (raid_lib == NULL) {
2N/A raid_lib = raid_find_lib(raid_tab, obj_id);
2N/A if (raid_lib == NULL)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A }
2N/A
2N/A ret = raid_lib->open_controller(attr->controller_id,
2N/A plugin_err_str);
2N/A if (ret == SUCCESS) {
2N/A (void) raid_obj_set_lib(raid_tab, obj_id, raid_lib);
2N/A (void) raid_obj_set_fd(raid_tab, obj_id, 1);
2N/A }
2N/A break;
2N/A case ACT_CONTROLLER_CLOSE:
2N/A
2N/A if (fd <= 0)
2N/A return (SUCCESS);
2N/A
2N/A if (raid_lib == NULL) {
2N/A return (SUCCESS);
2N/A }
2N/A ret = raid_lib->close_controller(attr->controller_id,
2N/A plugin_err_str);
2N/A if (ret == SUCCESS) {
2N/A (void) raid_obj_set_fd(raid_tab, obj_id, 0);
2N/A (void) raid_obj_set_lib(raid_tab, obj_id, NULL);
2N/A raid_handle_delete_controller_comp(attr->controller_id);
2N/A }
2N/A break;
2N/A case ACT_CONTROLLER_FLASH_FW:
2N/A {
2N/A char *filebuf;
2N/A int image_fd;
2N/A uint32_t size;
2N/A struct stat statbuf;
2N/A
2N/A if (prop_list == NULL)
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A /* Open firmware image file */
2N/A image_fd = open((const char *)prop_list,
2N/A O_RDONLY | O_NDELAY);
2N/A if (image_fd == -1)
2N/A return (ERR_OP_FAILED);
2N/A
2N/A if (fstat(image_fd, &statbuf) != 0) {
2N/A (void) close(image_fd);
2N/A return (ERR_OP_FAILED);
2N/A }
2N/A
2N/A filebuf = malloc(statbuf.st_size);
2N/A if (filebuf == NULL) {
2N/A (void) close(image_fd);
2N/A return (ERR_NOMEM);
2N/A }
2N/A
2N/A size = read(image_fd, filebuf, statbuf.st_size);
2N/A if (size != statbuf.st_size) {
2N/A (void) close(image_fd);
2N/A free(filebuf);
2N/A return (ERR_OP_FAILED);
2N/A }
2N/A
2N/A if (fd <= 0) {
2N/A (void) close(image_fd);
2N/A free(filebuf);
2N/A return (ERR_DRIVER_CLOSED);
2N/A }
2N/A
2N/A if (raid_lib == NULL) {
2N/A (void) close(image_fd);
2N/A free(filebuf);
2N/A return (ERR_DRIVER_CLOSED);
2N/A }
2N/A if (raid_lib->flash_fw == NULL) {
2N/A (void) close(image_fd);
2N/A free(filebuf);
2N/A return (ERR_OP_NO_IMPL);
2N/A }
2N/A
2N/A ret = raid_lib->flash_fw(attr->controller_id,
2N/A filebuf, size, plugin_err_str);
2N/A }
2N/A break;
2N/A default:
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t comp_type)
2N/A{
2N/A array_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_obj_id_t controller_obj_id;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (comp_type != OBJ_TYPE_ARRAY_PART &&
2N/A comp_type != OBJ_TYPE_ARRAY &&
2N/A comp_type != OBJ_TYPE_TASK)
2N/A return (0);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->compnum(ctl_attrp->controller_id, attr->array_id,
2N/A OBJ_TYPE_ARRAY, comp_type);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
2N/A{
2N/A array_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_obj_id_t controller_obj_id;
2N/A raid_lib_t *raid_lib;
2N/A int ret, i, fd;
2N/A uint32_t *ids;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (comp_type != OBJ_TYPE_ARRAY_PART &&
2N/A comp_type != OBJ_TYPE_ARRAY &&
2N/A comp_type != OBJ_TYPE_TASK)
2N/A return (0);
2N/A
2N/A if (comp_num <= 0 || comp_list == NULL)
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A for (i = 0; i < comp_num; ++i)
2N/A if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
2N/A comp_type)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ids = malloc(comp_num * sizeof (uint32_t));
2N/A if (ids == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A ret = raid_lib->complist(ctl_attrp->controller_id,
2N/A attr->array_id, OBJ_TYPE_ARRAY, comp_type, comp_num, ids);
2N/A
2N/A if (ret < SUCCESS) {
2N/A free(ids);
2N/A return (ret);
2N/A }
2N/A
2N/A for (i = 0; i < comp_num; ++ i) {
2N/A array_attr_t *array_attr;
2N/A arraypart_attr_t *arraypart_attr;
2N/A task_attr_t *task_attr;
2N/A void *attr_buf;
2N/A
2N/A attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
2N/A if (attr_buf == NULL) {
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A switch (comp_type) {
2N/A case OBJ_TYPE_ARRAY:
2N/A array_attr = attr_buf;
2N/A array_attr->array_id = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_ARRAY_PART:
2N/A arraypart_attr = attr_buf;
2N/A arraypart_attr->disk_id = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A task_attr = attr_buf;
2N/A task_attr->task_id = *(ids + i);
2N/A break;
2N/A default:
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A }
2N/A
2N/A
2N/A free(ids);
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A array_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A attr->array_id, 0, OBJ_TYPE_ARRAY, attr);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_set_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A uint32_t sub_cmd, uint32_t *value, char **plugin_err_str)
2N/A{
2N/A array_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A switch (sub_cmd) {
2N/A case SET_CACHE_WR_PLY:
2N/A if (*value != CACHE_WR_OFF &&
2N/A *value != CACHE_WR_ON)
2N/A return (ERR_OP_ILLEGAL);
2N/A break;
2N/A case SET_CACHE_RD_PLY:
2N/A if (*value != CACHE_RD_OFF &&
2N/A *value != CACHE_RD_ON)
2N/A return (ERR_OP_ILLEGAL);
2N/A break;
2N/A case SET_ACTIVATION_PLY:
2N/A if (*value != ARRAY_ACT_ACTIVATE)
2N/A return (ERR_OP_ILLEGAL);
2N/A break;
2N/A default:
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A (void) obj_get_attr(raid_tab, obj_id, (void **)(&attr));
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A if (raid_lib->set_attr == NULL)
2N/A return (ERR_OP_NO_IMPL);
2N/A
2N/A ret = raid_lib->set_attr(ctl_attrp->controller_id,
2N/A attr->array_id, sub_cmd, value, plugin_err_str);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_disk_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t comp_type)
2N/A{
2N/A disk_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_obj_id_t controller_obj_id;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (comp_type != OBJ_TYPE_DISK_SEG &&
2N/A comp_type != OBJ_TYPE_HSP &&
2N/A comp_type != OBJ_TYPE_TASK &&
2N/A comp_type != OBJ_TYPE_PROP)
2N/A return (0);
2N/A ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
2N/A if ((ret != SUCCESS) || (attr == NULL)) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A if (attr->state == DISK_STATE_FAILED) {
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->compnum(ctl_attrp->controller_id,
2N/A attr->disk_id, OBJ_TYPE_DISK, comp_type);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_disk_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
2N/A{
2N/A disk_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_obj_id_t controller_obj_id;
2N/A raid_lib_t *raid_lib;
2N/A int ret, i, fd;
2N/A uint32_t *ids;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (comp_type != OBJ_TYPE_DISK_SEG &&
2N/A comp_type != OBJ_TYPE_HSP &&
2N/A comp_type != OBJ_TYPE_TASK &&
2N/A comp_type != OBJ_TYPE_PROP)
2N/A return (0);
2N/A
2N/A if (comp_num <= 0 || comp_list == NULL)
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A for (i = 0; i < comp_num; ++i)
2N/A if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
2N/A comp_type)
2N/A return (ERR_DEVICE_TYPE);
2N/A ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
2N/A if ((ret != SUCCESS) || (attr == NULL)) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A if (attr->state == DISK_STATE_FAILED) {
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ids = malloc(comp_num * sizeof (uint32_t));
2N/A if (ids == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A ret = raid_lib->complist(ctl_attrp->controller_id,
2N/A attr->disk_id, OBJ_TYPE_DISK, comp_type, comp_num, ids);
2N/A
2N/A if (ret < SUCCESS) {
2N/A free(ids);
2N/A return (ret);
2N/A }
2N/A
2N/A for (i = 0; i < comp_num; ++ i) {
2N/A diskseg_attr_t *diskseg_attr;
2N/A hsp_attr_t *hsp_attr;
2N/A task_attr_t *task_attr;
2N/A property_attr_t *prop_attr;
2N/A void *attr_buf;
2N/A
2N/A attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
2N/A if (attr_buf == NULL) {
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A switch (comp_type) {
2N/A case OBJ_TYPE_DISK_SEG:
2N/A diskseg_attr = attr_buf;
2N/A diskseg_attr->seq_no = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_HSP:
2N/A hsp_attr = attr_buf;
2N/A hsp_attr->associated_id = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A task_attr = attr_buf;
2N/A task_attr->task_id = *(ids + i);
2N/A break;
2N/A case OBJ_TYPE_PROP:
2N/A prop_attr = attr_buf;
2N/A prop_attr->prop_id = *(ids + i);
2N/A break;
2N/A default:
2N/A free(ids);
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A }
2N/A
2N/A
2N/A free(ids);
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_disk_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A disk_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A attr->disk_id, 0, OBJ_TYPE_DISK, attr);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_hsp_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A hsp_attr_t *attr;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_HSP)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A if (attr->associated_id == (uint32_t)OBJ_ATTR_NONE)
2N/A attr->type = HSP_TYPE_GLOBAL;
2N/A else
2N/A attr->type = HSP_TYPE_LOCAL;
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_arraypart_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A arraypart_attr_t *attr;
2N/A array_attr_t *array_attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id, array_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY_PART)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A array_obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A if (array_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A array_attr = raid_obj_get_data_ptr(raid_tab, array_obj_id);
2N/A if (array_attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A array_attr->array_id, attr->disk_id,
2N/A OBJ_TYPE_ARRAY_PART, attr);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_diskseg_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A diskseg_attr_t *attr;
2N/A disk_attr_t *disk_attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id, disk_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK_SEG)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A disk_obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A if (disk_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, disk_obj_id);
2N/A if (disk_attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A disk_attr->disk_id, attr->seq_no, OBJ_TYPE_DISK_SEG, attr);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_task_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A task_attr_t *attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_TASK)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A attr->task_id, OBJ_ATTR_NONE, OBJ_TYPE_TASK, attr);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_prop_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A property_attr_t *attr, *attr_new;
2N/A disk_attr_t *disk_attr;
2N/A controller_attr_t *ctl_attrp;
2N/A raid_lib_t *raid_lib;
2N/A int ret = SUCCESS, fd;
2N/A raid_obj_id_t controller_obj_id, disk_obj_id;
2N/A
2N/A if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_PROP)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
2N/A return (SUCCESS);
2N/A
2N/A attr = raid_obj_get_data_ptr(raid_tab, obj_id);
2N/A if (attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A disk_obj_id = raid_obj_get_container(raid_tab, obj_id);
2N/A if (disk_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A disk_attr = raid_obj_get_data_ptr(raid_tab, disk_obj_id);
2N/A if (disk_attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, obj_id);
2N/A if (controller_obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
2N/A if (ctl_attrp == NULL) {
2N/A return (ERR_DEVICE_INVALID);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A /* Get the property size at first */
2N/A attr->prop_size = 0;
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A disk_attr->disk_id, OBJ_ATTR_NONE, OBJ_TYPE_PROP, attr);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A /* Allocate memory for property and fill the buffer */
2N/A attr_new = realloc(attr, sizeof (property_attr_t) + attr->prop_size);
2N/A if (attr_new == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A (void) raid_obj_set_data_ptr(raid_tab, obj_id, attr_new);
2N/A
2N/A ret = raid_lib->get_attr(ctl_attrp->controller_id,
2N/A disk_attr->disk_id, OBJ_ATTR_NONE, OBJ_TYPE_PROP, attr_new);
2N/A
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
2N/A int num_of_comp, raid_obj_id_t *disk_list, char **plugin_err_str)
2N/A{
2N/A controller_attr_t *controller_attr;
2N/A array_attr_t *array_attr, array_attr2;
2N/A disk_attr_t *disk_attr;
2N/A arraypart_attr_t *arraypart_attrs;
2N/A raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
2N/A raid_lib_t *raid_lib;
2N/A int i, j, ret, fd;
2N/A int disk_cnt = 0, disk_set_num = 0, set_num = 0, layer_cnt = 0;
2N/A uint64_t min_disk_capacity = 0;
2N/A
2N/A array_attr = raid_obj_get_data_ptr(raid_tab, array_obj_id);
2N/A if (array_attr == NULL)
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A /* Check the disk layout expression */
2N/A if (disk_list[0] != OBJ_SEPARATOR_BEGIN ||
2N/A disk_list[num_of_comp - 1] != OBJ_SEPARATOR_END)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A for (i = 0; i < num_of_comp; ++i) {
2N/A if (disk_list[i] == OBJ_SEPARATOR_BEGIN) {
2N/A if (disk_cnt != 0)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A ++layer_cnt;
2N/A continue;
2N/A }
2N/A if (disk_list[i] == OBJ_SEPARATOR_END) {
2N/A if (disk_set_num == 0)
2N/A disk_set_num = disk_cnt;
2N/A else if (disk_set_num != disk_cnt && disk_cnt != 0)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A disk_cnt = 0;
2N/A ++set_num;
2N/A --layer_cnt;
2N/A continue;
2N/A }
2N/A switch (array_attr->raid_level) {
2N/A case RAID_LEVEL_0:
2N/A case RAID_LEVEL_1:
2N/A case RAID_LEVEL_1E:
2N/A case RAID_LEVEL_5:
2N/A if (layer_cnt != 1)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A case RAID_LEVEL_10:
2N/A case RAID_LEVEL_50:
2N/A if (layer_cnt != 2)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A default:
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A ++disk_cnt;
2N/A }
2N/A
2N/A if (layer_cnt != 0)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A
2N/A switch (array_attr->raid_level) {
2N/A case RAID_LEVEL_0:
2N/A if (disk_set_num < 2 || set_num != 1)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A case RAID_LEVEL_1:
2N/A if (disk_set_num != 2 || set_num != 1)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A case RAID_LEVEL_1E:
2N/A case RAID_LEVEL_5:
2N/A if (disk_set_num < 3 || set_num != 1)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A case RAID_LEVEL_10:
2N/A if (disk_set_num != 2 || set_num < 2)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A case RAID_LEVEL_50:
2N/A if (disk_set_num < 3 || set_num < 2)
2N/A return (ERR_ARRAY_LAYOUT);
2N/A break;
2N/A default:
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A
2N/A arraypart_attrs = calloc(num_of_comp, sizeof (arraypart_attr_t));
2N/A if (arraypart_attrs == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A for (i = 0; i < num_of_comp; ++i) {
2N/A /* Keep separators */
2N/A if (*(disk_list + i) == OBJ_SEPARATOR_BEGIN) {
2N/A arraypart_attrs[i].disk_id =
2N/A (uint32_t)OBJ_SEPARATOR_BEGIN;
2N/A continue;
2N/A }
2N/A
2N/A if (*(disk_list + i) == OBJ_SEPARATOR_END) {
2N/A arraypart_attrs[i].disk_id =
2N/A (uint32_t)OBJ_SEPARATOR_END;
2N/A continue;
2N/A }
2N/A
2N/A disk_cnt++;
2N/A /* Check if it's a disk */
2N/A if (raid_obj_get_type(raid_tab, *(disk_list + i)) !=
2N/A OBJ_TYPE_DISK)
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A /* Check if it's duplicated with other disks */
2N/A for (j = 0; j < i; ++j)
2N/A if (*(disk_list + j) == *(disk_list + i)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DEVICE_DUP);
2N/A }
2N/A
2N/A /* Check disk status */
2N/A ret = obj_get_attr(raid_tab, *(disk_list + i),
2N/A (void **)(&disk_attr));
2N/A if (ret != SUCCESS)
2N/A return (ret);
2N/A
2N/A if (disk_attr->state != DISK_STATE_GOOD) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DISK_STATE);
2N/A }
2N/A
2N/A /* All disks must belong to the same controller */
2N/A obj_id = obj_get_controller(raid_tab, *(disk_list + i));
2N/A if (obj_id <= OBJ_NONE)
2N/A return (obj_id);
2N/A if (controller_obj_id == OBJ_NONE) {
2N/A controller_obj_id = obj_id;
2N/A ret = obj_get_attr(raid_tab, controller_obj_id,
2N/A (void **)(&controller_attr));
2N/A } else if (obj_id != controller_obj_id) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DRIVER_ACROSS);
2N/A }
2N/A
2N/A /* Check if the disk contains too many segments */
2N/A obj_id = obj_get_comp(raid_tab, *(disk_list + i),
2N/A OBJ_TYPE_DISK_SEG);
2N/A j = 0;
2N/A while (obj_id > OBJ_NONE) {
2N/A ++j;
2N/A obj_id = obj_get_sibling(raid_tab, obj_id);
2N/A }
2N/A if (j > controller_attr->max_seg_per_disk) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DISK_SEG_AMOUNT);
2N/A }
2N/A
2N/A /* Check if controller is a hostraid controller */
2N/A if (controller_attr->capability & RAID_CAP_DISK_TRANS) {
2N/A /*
2N/A * For hostraid, the first disk should
2N/A * be with of minimum capacity
2N/A */
2N/A if (min_disk_capacity == 0) {
2N/A min_disk_capacity = disk_attr->capacity;
2N/A
2N/A /* Can not specify capacity for hostraid */
2N/A if (array_attr->capacity != 0) {
2N/A free(arraypart_attrs);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A } else if (min_disk_capacity > disk_attr->capacity) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DISK_SPACE);
2N/A }
2N/A
2N/A /* Disk should not be used for hostraid */
2N/A obj_id = obj_get_comp(raid_tab, *(disk_list + i),
2N/A OBJ_TYPE_DISK_SEG);
2N/A if (obj_id < OBJ_NONE) {
2N/A free(arraypart_attrs);
2N/A return (obj_id);
2N/A } else if (obj_id > OBJ_NONE) {
2N/A free(arraypart_attrs);
2N/A return (ERR_DISK_NOT_EMPTY);
2N/A }
2N/A }
2N/A
2N/A arraypart_attrs[i].disk_id = disk_attr->disk_id;
2N/A arraypart_attrs[i].offset = OBJ_ATTR_NONE;
2N/A arraypart_attrs[i].size = OBJ_ATTR_NONE;
2N/A }
2N/A
2N/A /* Check if array amount exceeds limit */
2N/A if (controller_attr->max_array_num <=
2N/A obj_controller_compnum(raid_tab, controller_obj_id,
2N/A OBJ_TYPE_ARRAY))
2N/A return (ERR_ARRAY_AMOUNT);
2N/A
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A /* Check if the controller can support the array RAID level */
2N/A switch (array_attr->raid_level) {
2N/A case RAID_LEVEL_0:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID0)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A case RAID_LEVEL_1:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID1)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A case RAID_LEVEL_1E:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID1E)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A case RAID_LEVEL_5:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID5)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A case RAID_LEVEL_10:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID10)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A case RAID_LEVEL_50:
2N/A if (!(controller_attr->capability & RAID_CAP_RAID50)) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A break;
2N/A default:
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A
2N/A /* Check if plug in can calculate the maximum size */
2N/A (void) memcpy(&array_attr2, array_attr, sizeof (array_attr_t));
2N/A array_attr2.capacity = OBJ_ATTR_NONE;
2N/A ret = raid_lib->array_create(controller_attr->controller_id,
2N/A &array_attr2, num_of_comp, arraypart_attrs, plugin_err_str);
2N/A
2N/A /* If plugin/driver will not calculate space */
2N/A if (ret == ERR_OP_NO_IMPL) {
2N/A /* Calculate the maximum capacity */
2N/A array_attr2.capacity = raid_space_noalign(raid_tab,
2N/A array_attr2.raid_level, num_of_comp, disk_list,
2N/A arraypart_attrs);
2N/A
2N/A /*
2N/A * If controller is capable to allocate space,
2N/A * set offset and size attributes to OBJ_ATTR_NONE
2N/A * and let the controller to determine these value
2N/A */
2N/A if (controller_attr->capability & RAID_CAP_SMART_ALLOC)
2N/A for (i = 0; i < num_of_comp; ++i) {
2N/A arraypart_attrs[i].offset =
2N/A OBJ_ATTR_NONE;
2N/A arraypart_attrs[i].size =
2N/A OBJ_ATTR_NONE;
2N/A }
2N/A
2N/A /* There's no enough space for specified capacity */
2N/A if (array_attr->capacity > array_attr2.capacity) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_SIZE);
2N/A }
2N/A
2N/A /* capacity == 0, allocate maximum space */
2N/A if (array_attr->capacity == 0)
2N/A array_attr->capacity = array_attr2.capacity;
2N/A } else if (ret < SUCCESS) {
2N/A free(arraypart_attrs);
2N/A return (ret);
2N/A } else if (array_attr2.capacity < array_attr->capacity) {
2N/A /* Return the maximum size */
2N/A array_attr->capacity = array_attr2.capacity;
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_SIZE);
2N/A }
2N/A
2N/A if (array_attr->capacity < ARRAYPART_MIN_SIZE * disk_cnt) {
2N/A free(arraypart_attrs);
2N/A return (ERR_ARRAY_SIZE);
2N/A }
2N/A
2N/A
2N/A ret = raid_lib->array_create(controller_attr->controller_id,
2N/A array_attr, num_of_comp, arraypart_attrs, plugin_err_str);
2N/A free(arraypart_attrs);
2N/A
2N/A if (ret != SUCCESS)
2N/A return (ret);
2N/A
2N/A /* Add array object into device tree so that we can map the handle */
2N/A (void) raid_obj_add_org(raid_tab, array_obj_id, controller_obj_id);
2N/A
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_array_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t controller_obj_id;
2N/A controller_attr_t *controller_attr;
2N/A array_attr_t *array_attr;
2N/A raid_lib_t *raid_lib;
2N/A int ret, fd;
2N/A uint32_t *disk_ids = NULL;
2N/A
2N/A controller_obj_id = obj_get_controller(raid_tab, array_obj_id);
2N/A if (controller_obj_id <= OBJ_NONE)
2N/A return (controller_obj_id);
2N/A
2N/A ret = obj_get_attr(raid_tab, controller_obj_id,
2N/A (void **)(&controller_attr));
2N/A if (ret < SUCCESS) {
2N/A return (ret);
2N/A }
2N/A ret = obj_get_attr(raid_tab, array_obj_id, (void **)(&array_attr));
2N/A if (ret < SUCCESS)
2N/A return (ret);
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A ret = raid_lib->array_delete(controller_attr->controller_id,
2N/A array_attr->array_id, plugin_err_str);
2N/A if (ret < SUCCESS) {
2N/A if (disk_ids)
2N/A free(disk_ids);
2N/A return (ret);
2N/A }
2N/A
2N/A if (disk_ids)
2N/A free(disk_ids);
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_hsp_bind(raid_obj_tab_t *raid_tab, raid_obj_id_t *obj_ids,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
2N/A raid_obj_id_t array_obj_id, disk_obj_id;
2N/A hsp_relation_t *hsp_relation;
2N/A controller_attr_t *controller_attr;
2N/A array_attr_t *array_attr;
2N/A arraypart_attr_t *arraypart_attr;
2N/A disk_attr_t *disk_attr;
2N/A diskseg_attr_t *diskseg_attr;
2N/A hsp_attr_t *hsp_attr;
2N/A raid_lib_t *raid_lib;
2N/A int ret, fd;
2N/A
2N/A hsp_relation = malloc(sizeof (hsp_relation_t));
2N/A if (hsp_relation == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A array_obj_id = *(obj_ids);
2N/A disk_obj_id = *(obj_ids + 1);
2N/A
2N/A if (raid_obj_get_type(raid_tab, disk_obj_id) != OBJ_TYPE_DISK ||
2N/A (array_obj_id != OBJ_ATTR_NONE &&
2N/A raid_obj_get_type(raid_tab, array_obj_id) !=
2N/A OBJ_TYPE_ARRAY)) {
2N/A free(hsp_relation);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A /* Get controller attributes */
2N/A if (controller_obj_id == OBJ_NONE)
2N/A controller_obj_id = obj_get_controller(raid_tab,
2N/A disk_obj_id);
2N/A else if (controller_obj_id != obj_get_controller(raid_tab,
2N/A disk_obj_id)) {
2N/A free(hsp_relation);
2N/A return (ERR_DRIVER_ACROSS);
2N/A }
2N/A
2N/A ret = obj_get_attr(raid_tab, controller_obj_id,
2N/A (void **)(&controller_attr));
2N/A
2N/A /* Get disk attributes */
2N/A ret = obj_get_attr(raid_tab, disk_obj_id,
2N/A (void **)(&disk_attr));
2N/A if (disk_attr->state == DISK_STATE_FAILED) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_STATE);
2N/A }
2N/A
2N/A /* If it's not a hsp disk, check if there's occupied space */
2N/A if (obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP) ==
2N/A OBJ_NONE) {
2N/A obj_id = obj_get_comp(raid_tab, disk_obj_id,
2N/A OBJ_TYPE_DISK_SEG);
2N/A while (obj_id != OBJ_NONE) {
2N/A ret = obj_get_attr(raid_tab, obj_id,
2N/A (void **)(&diskseg_attr));
2N/A if (!(diskseg_attr->state &
2N/A DISKSEG_STATE_RESERVED)) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_NOT_EMPTY);
2N/A }
2N/A obj_id = obj_get_sibling(raid_tab, obj_id);
2N/A }
2N/A }
2N/A
2N/A if (array_obj_id != OBJ_ATTR_NONE) {
2N/A /* If local hsp is supported */
2N/A if (!(controller_attr->capability & RAID_CAP_L_HSP)) {
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A if (raid_obj_get_type(raid_tab, array_obj_id) !=
2N/A OBJ_TYPE_ARRAY) {
2N/A free(hsp_relation);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A /* Get array attributes */
2N/A ret = obj_get_attr(raid_tab, array_obj_id,
2N/A (void **)(&array_attr));
2N/A /* RAID 0 array can not use hsp */
2N/A if (array_attr->raid_level == RAID_LEVEL_0) {
2N/A free(hsp_relation);
2N/A return (ERR_ARRAY_LEVEL);
2N/A }
2N/A
2N/A /* If It's belong to another controller */
2N/A if (controller_obj_id != obj_get_controller(raid_tab,
2N/A array_obj_id)) {
2N/A free(hsp_relation);
2N/A return (ERR_DRIVER_ACROSS);
2N/A }
2N/A
2N/A /* Get an array part attributes */
2N/A if ((array_attr->raid_level == RAID_LEVEL_10) ||
2N/A (array_attr->raid_level == RAID_LEVEL_50))
2N/A obj_id = obj_get_comp(raid_tab, array_obj_id,
2N/A OBJ_TYPE_ARRAY);
2N/A else
2N/A obj_id = array_obj_id;
2N/A obj_id = obj_get_comp(raid_tab, obj_id,
2N/A OBJ_TYPE_ARRAY_PART);
2N/A ret = obj_get_attr(raid_tab, obj_id,
2N/A (void **)(&arraypart_attr));
2N/A
2N/A /* Check if disk space is enough for array */
2N/A if (arraypart_attr->size > disk_attr->capacity) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_SPACE);
2N/A }
2N/A if (controller_attr->capability & RAID_CAP_ARRAY_ALIGN)
2N/A if ((arraypart_attr->size +
2N/A arraypart_attr->offset) >
2N/A disk_attr->capacity) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_SPACE);
2N/A }
2N/A } else if (!(controller_attr->capability & RAID_CAP_G_HSP)) {
2N/A /* if global hsp is supported */
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A /*
2N/A * If the array is already associated with the
2N/A * local hsp, or it's a global hsp, ignore it
2N/A */
2N/A obj_id = obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP);
2N/A if (obj_id > OBJ_NONE) {
2N/A if (obj_get_attr(raid_tab, obj_id,
2N/A (void **)&hsp_attr) >= SUCCESS) {
2N/A if (((hsp_attr->type == HSP_TYPE_GLOBAL) &&
2N/A (array_obj_id != OBJ_ATTR_NONE)) ||
2N/A ((hsp_attr->type == HSP_TYPE_LOCAL) &&
2N/A (array_obj_id == OBJ_ATTR_NONE))) {
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A }
2N/A }
2N/A
2N/A if (array_obj_id != OBJ_ATTR_NONE)
2N/A hsp_relation->array_id = array_attr->array_id;
2N/A else
2N/A hsp_relation->array_id = (uint32_t)OBJ_ATTR_NONE;
2N/A hsp_relation->disk_id = disk_attr->disk_id;
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A if (raid_lib->hsp_bind == NULL) {
2N/A free(hsp_relation);
2N/A return (ERR_OP_NO_IMPL);
2N/A }
2N/A
2N/A ret = raid_lib->hsp_bind(controller_attr->controller_id,
2N/A hsp_relation, plugin_err_str);
2N/A
2N/A free(hsp_relation);
2N/A return (ret);
2N/A}
2N/A
2N/Astatic int
2N/Aobj_hsp_unbind(raid_obj_tab_t *raid_tab, raid_obj_id_t *obj_ids,
2N/A char **plugin_err_str)
2N/A{
2N/A raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
2N/A raid_obj_id_t array_obj_id, disk_obj_id;
2N/A hsp_relation_t *hsp_relation;
2N/A controller_attr_t *controller_attr;
2N/A array_attr_t *array_attr;
2N/A disk_attr_t *disk_attr;
2N/A hsp_attr_t *hsp_attr;
2N/A raid_lib_t *raid_lib;
2N/A int ret, fd;
2N/A
2N/A hsp_relation = malloc(sizeof (hsp_relation_t));
2N/A if (hsp_relation == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A array_obj_id = *(obj_ids);
2N/A disk_obj_id = *(obj_ids + 1);
2N/A
2N/A if (raid_obj_get_type(raid_tab, disk_obj_id) != OBJ_TYPE_DISK) {
2N/A free(hsp_relation);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A /* Get controller attributes */
2N/A if (controller_obj_id == OBJ_NONE)
2N/A controller_obj_id = obj_get_controller(raid_tab,
2N/A disk_obj_id);
2N/A else if (controller_obj_id != obj_get_controller(raid_tab,
2N/A disk_obj_id)) {
2N/A free(hsp_relation);
2N/A return (ERR_DRIVER_ACROSS);
2N/A }
2N/A
2N/A ret = obj_get_attr(raid_tab, controller_obj_id,
2N/A (void **)(&controller_attr));
2N/A
2N/A /* Get disk attributes */
2N/A ret = obj_get_attr(raid_tab, disk_obj_id,
2N/A (void **)(&disk_attr));
2N/A if (disk_attr->state == DISK_STATE_FAILED) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_STATE);
2N/A }
2N/A
2N/A /* If it's not a hsp disk */
2N/A obj_id = obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP);
2N/A if (obj_id == OBJ_NONE) {
2N/A free(hsp_relation);
2N/A return (ERR_DISK_STATE);
2N/A }
2N/A ret = obj_get_attr(raid_tab, obj_id, (void **)(&hsp_attr));
2N/A
2N/A if (array_obj_id != OBJ_ATTR_NONE) {
2N/A if (raid_obj_get_type(raid_tab, array_obj_id) !=
2N/A OBJ_TYPE_ARRAY) {
2N/A free(hsp_relation);
2N/A return (ERR_DEVICE_TYPE);
2N/A }
2N/A
2N/A /* Get array attributes */
2N/A ret = obj_get_attr(raid_tab, array_obj_id,
2N/A (void **)(&array_attr));
2N/A
2N/A /* If It's belong to another controller */
2N/A if (controller_obj_id != obj_get_controller(raid_tab,
2N/A array_obj_id)) {
2N/A free(hsp_relation);
2N/A return (ERR_DRIVER_ACROSS);
2N/A }
2N/A
2N/A /* If want to remove an array from a global hsp */
2N/A if (hsp_attr->type == HSP_TYPE_GLOBAL) {
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A do {
2N/A (void) obj_get_attr(raid_tab, obj_id,
2N/A (void **)(&hsp_attr));
2N/A
2N/A if (hsp_attr->associated_id ==
2N/A array_attr->array_id ||
2N/A hsp_attr->type == HSP_TYPE_GLOBAL)
2N/A break;
2N/A
2N/A obj_id = obj_get_sibling(raid_tab, obj_id);
2N/A } while (obj_id > OBJ_NONE);
2N/A } else if (hsp_attr->type != HSP_TYPE_GLOBAL) {
2N/A /* if global hsp is supported */
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A /*
2N/A * If array is associated with a local hsp, or remove a
2N/A * global hsp disk
2N/A */
2N/A if ((obj_id && (array_obj_id != OBJ_ATTR_NONE)) ||
2N/A (array_obj_id == OBJ_ATTR_NONE)) {
2N/A if (array_obj_id != OBJ_ATTR_NONE)
2N/A hsp_relation->array_id = array_attr->array_id;
2N/A else
2N/A hsp_relation->array_id =
2N/A (uint32_t)OBJ_ATTR_NONE;
2N/A hsp_relation->disk_id = disk_attr->disk_id;
2N/A } else {
2N/A free(hsp_relation);
2N/A return (ERR_OP_ILLEGAL);
2N/A }
2N/A
2N/A raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
2N/A fd = raid_obj_get_fd(raid_tab, controller_obj_id);
2N/A if ((raid_lib == NULL) || (fd == 0))
2N/A return (ERR_DRIVER_CLOSED);
2N/A
2N/A if (raid_lib->hsp_unbind == NULL) {
2N/A free(hsp_relation);
2N/A return (ERR_OP_NO_IMPL);
2N/A }
2N/A
2N/A ret = raid_lib->hsp_unbind(controller_attr->controller_id,
2N/A hsp_relation, plugin_err_str);
2N/A
2N/A free(hsp_relation);
2N/A return (ret);
2N/A}
2N/A
2N/A/*
2N/A * Object maintennance routines
2N/A */
2N/Astatic int
2N/Araid_obj_create_system_obj(raid_obj_tab_t *raid_tab)
2N/A{
2N/A raid_obj_t *raid_obj;
2N/A int ret;
2N/A
2N/A raid_obj = calloc(1, sizeof (raid_obj_t));
2N/A if (raid_obj == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A raid_obj->obj_id = OBJ_SYSTEM;
2N/A raid_obj->obj_type_id = OBJ_TYPE_SYSTEM;
2N/A raid_obj->data = NULL;
2N/A
2N/A ret = raid_obj_tab_insert(raid_tab, raid_obj->obj_id, raid_obj);
2N/A if (ret == ERR_DEVICE_DUP) {
2N/A free(raid_obj);
2N/A return (ERR_DEVICE_UNCLEAN);
2N/A }
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_obj_id_new(raid_obj_tab_t *raid_tab)
2N/A{
2N/A ++ raid_tab->obj_id_cnt;
2N/A if (raid_tab->obj_id_cnt <= 0)
2N/A return (ERR_DEVICE_OVERFLOW);
2N/A
2N/A return (raid_tab->obj_id_cnt);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_obj_attr_new(raid_obj_type_id_t obj_type)
2N/A{
2N/A void *obj_attr = NULL;
2N/A
2N/A switch (obj_type) {
2N/A case OBJ_TYPE_CONTROLLER:
2N/A obj_attr = calloc(1, sizeof (controller_attr_t));
2N/A break;
2N/A case OBJ_TYPE_ARRAY:
2N/A obj_attr = calloc(1, sizeof (array_attr_t));
2N/A break;
2N/A case OBJ_TYPE_DISK:
2N/A obj_attr = calloc(1, sizeof (disk_attr_t));
2N/A break;
2N/A case OBJ_TYPE_HSP:
2N/A obj_attr = calloc(1, sizeof (hsp_attr_t));
2N/A break;
2N/A case OBJ_TYPE_ARRAY_PART:
2N/A obj_attr = calloc(1, sizeof (arraypart_attr_t));
2N/A break;
2N/A case OBJ_TYPE_DISK_SEG:
2N/A obj_attr = calloc(1, sizeof (diskseg_attr_t));
2N/A break;
2N/A case OBJ_TYPE_TASK:
2N/A obj_attr = calloc(1, sizeof (task_attr_t));
2N/A break;
2N/A case OBJ_TYPE_PROP:
2N/A obj_attr = calloc(1, sizeof (property_attr_t));
2N/A break;
2N/A default:
2N/A break;
2N/A }
2N/A
2N/A return (obj_attr);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_obj_create(raid_obj_tab_t *raid_tab, raid_obj_type_id_t obj_type)
2N/A{
2N/A raid_obj_t *raid_obj;
2N/A int ret;
2N/A void *data_ptr;
2N/A
2N/A raid_obj = calloc(1, sizeof (raid_obj_t));
2N/A if (raid_obj == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A raid_obj->obj_id = raid_obj_id_new(raid_tab);
2N/A if (raid_obj->obj_id < OBJ_NONE)
2N/A return (ERR_DEVICE_OVERFLOW);
2N/A
2N/A ret = raid_obj_tab_insert(raid_tab, raid_obj->obj_id, raid_obj);
2N/A if (ret == ERR_DEVICE_DUP) {
2N/A free(raid_obj);
2N/A return (ERR_DEVICE_DUP);
2N/A }
2N/A
2N/A data_ptr = raid_obj_attr_new(obj_type);
2N/A if (data_ptr == NULL) {
2N/A (void) raid_obj_delete(raid_tab, raid_obj->obj_id);
2N/A return (ERR_NOMEM);
2N/A }
2N/A
2N/A (void) raid_obj_set_data_ptr(raid_tab, raid_obj->obj_id, data_ptr);
2N/A
2N/A (void) raid_obj_set_type(raid_tab, raid_obj->obj_id, obj_type);
2N/A return (raid_obj->obj_id);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t raid_obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_remove(raid_tab, raid_obj_id);
2N/A if (obj != NULL) {
2N/A free(obj->data);
2N/A free(obj);
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A return (ERR_DEVICE_NOENT);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_add_org(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_id_t container_id)
2N/A{
2N/A raid_obj_id_t tmp, tmp1;
2N/A
2N/A tmp = raid_obj_get_comp(raid_tab, container_id);
2N/A if (tmp < OBJ_NONE)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A if (tmp == OBJ_NONE) {
2N/A (void) raid_obj_set_container(raid_tab, obj_id, container_id);
2N/A (void) raid_obj_set_comp(raid_tab, container_id, obj_id);
2N/A return (SUCCESS);
2N/A }
2N/A
2N/A while ((tmp1 = raid_obj_get_sibling(raid_tab, tmp)) != OBJ_NONE)
2N/A tmp = tmp1;
2N/A
2N/A if (raid_obj_set_sibling(raid_tab, tmp, obj_id) < SUCCESS)
2N/A return (ERR_DEVICE_NOENT);
2N/A (void) raid_obj_set_container(raid_tab, obj_id, container_id);
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_type_id_t
2N/Araid_obj_get_type(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A if ((obj->obj_type_id < OBJ_TYPE_SYSTEM) ||
2N/A (obj->obj_type_id >= OBJ_TYPE_ALL))
2N/A return (ERR_DEVICE_INVALID);
2N/A
2N/A return (obj->obj_type_id);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_type(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_type_id_t type)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A if ((type < OBJ_TYPE_SYSTEM) || (type >= OBJ_TYPE_ALL))
2N/A return (ERR_DEVICE_TYPE);
2N/A
2N/A obj->obj_type_id = type;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_status_t
2N/Araid_obj_get_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (obj->status);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_status_t status)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->status = obj->status | status;
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_clear_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_status_t status)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->status = obj->status & ~status;
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_obj_get_container(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (obj->container);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_container(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_id_t container_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->container = container_id;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_obj_get_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (obj->component);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_id_t comp)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->component = comp;
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_id_t
2N/Araid_obj_get_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (obj->sibling);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_id_t sibling)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->sibling = sibling;
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_obj_get_data_ptr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (NULL);
2N/A
2N/A return (obj->data);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_data_ptr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A void *data)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->data = data;
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic raid_obj_handle_t
2N/Araid_obj_get_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A return (obj->handle);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_set_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
2N/A raid_obj_handle_t handle)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A obj = raid_obj_tab_find(raid_tab, obj_id);
2N/A if (obj == NULL)
2N/A return (ERR_DEVICE_NOENT);
2N/A
2N/A obj->handle = handle;
2N/A return (SUCCESS);
2N/A}
2N/A/*
2N/A * Object list maintennance routines
2N/A */
2N/Astatic void
2N/Araid_list_create(raid_list_t *list, size_t offset)
2N/A{
2N/A list->head = NULL;
2N/A list->tail = NULL;
2N/A list->offset = offset;
2N/A}
2N/A
2N/Astatic void *
2N/Araid_list_head(raid_list_t *list)
2N/A{
2N/A return (list->head);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_list_next(raid_list_t *list, void *obj)
2N/A{
2N/A raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj);
2N/A
2N/A return (el->next);
2N/A}
2N/A
2N/Astatic void
2N/Araid_list_insert_tail(raid_list_t *list, void *obj)
2N/A{
2N/A raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj), *el1;
2N/A
2N/A el->prev = list->tail;
2N/A list->tail = obj;
2N/A
2N/A el->next = NULL;
2N/A
2N/A if (list->head == NULL)
2N/A list->head = obj;
2N/A
2N/A if (el->prev != NULL) {
2N/A el1 = LIST_OBJ_TO_EL(list, el->prev);
2N/A el1->next = obj;
2N/A }
2N/A}
2N/A
2N/Astatic void
2N/Araid_list_remove(raid_list_t *list, void *obj)
2N/A{
2N/A raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj), *el1;
2N/A
2N/A if (list->head == obj)
2N/A list->head = el->next;
2N/A
2N/A if (list->tail == obj)
2N/A list->tail = el->prev;
2N/A
2N/A if (el->next != NULL) {
2N/A el1 = LIST_OBJ_TO_EL(list, el->next);
2N/A el1->prev = el->prev;
2N/A }
2N/A
2N/A if (el->prev != NULL) {
2N/A el1 = LIST_OBJ_TO_EL(list, el->prev);
2N/A el1->next = el->next;
2N/A }
2N/A
2N/A el->prev = el->next = NULL;
2N/A}
2N/A
2N/Astatic void *
2N/Araid_list_remove_head(raid_list_t *list)
2N/A{
2N/A void *obj = list->head;
2N/A
2N/A if (obj != NULL)
2N/A raid_list_remove(list, obj);
2N/A
2N/A return (obj);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_list_find(raid_list_t *list, raid_obj_id_t obj_id)
2N/A{
2N/A raid_obj_t *obj;
2N/A
2N/A for (obj = raid_list_head(list); obj != NULL;
2N/A obj = raid_list_next(list, obj))
2N/A if (obj->obj_id == obj_id)
2N/A break;
2N/A
2N/A return (obj);
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_tab_create(raid_obj_tab_t *tab, size_t hash_slots)
2N/A{
2N/A unsigned i;
2N/A
2N/A if (hash_slots == 0)
2N/A return (ERR_OP_ILLEGAL);
2N/A
2N/A tab->slots = hash_slots;
2N/A
2N/A if ((tab->table = calloc(hash_slots, sizeof (raid_list_t))) == NULL)
2N/A return (ERR_NOMEM);
2N/A
2N/A for (i = 0; i < hash_slots; i++)
2N/A raid_list_create(&tab->table[i], offsetof(raid_obj_t, el));
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic void
2N/Araid_obj_tab_destroy(raid_obj_tab_t *tab)
2N/A{
2N/A unsigned i;
2N/A
2N/A for (i = 0; i < tab->slots; i++) {
2N/A struct raid_obj_t *obj;
2N/A
2N/A while ((obj = raid_list_remove_head(&tab->table[i])) != NULL)
2N/A free(obj);
2N/A
2N/A raid_list_destroy(&tab->table[i]);
2N/A }
2N/A
2N/A if (tab->table)
2N/A free(tab->table);
2N/A
2N/A tab->table = NULL;
2N/A tab->slots = 0;
2N/A tab->obj_id_cnt = 0;
2N/A}
2N/A
2N/Astatic int
2N/Araid_obj_tab_insert(raid_obj_tab_t *tab, raid_obj_id_t id, void *obj)
2N/A{
2N/A raid_list_t *list;
2N/A
2N/A list = OBJ_TAB_SLOT(tab, id);
2N/A
2N/A if (raid_list_find(list, id) != NULL)
2N/A return (ERR_DEVICE_DUP);
2N/A
2N/A raid_list_insert_tail(list, obj);
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_obj_tab_remove(raid_obj_tab_t *tab, raid_obj_id_t id)
2N/A{
2N/A raid_list_t *list;
2N/A raid_obj_t *obj;
2N/A
2N/A list = OBJ_TAB_SLOT(tab, id);
2N/A
2N/A if ((obj = raid_list_find(list, id)) != NULL)
2N/A raid_list_remove(list, obj);
2N/A
2N/A return (obj);
2N/A}
2N/A
2N/Astatic void *
2N/Araid_obj_tab_find(raid_obj_tab_t *tab, raid_obj_id_t id)
2N/A{
2N/A raid_list_t *list;
2N/A raid_obj_t *obj;
2N/A
2N/A list = OBJ_TAB_SLOT(tab, id);
2N/A obj = raid_list_find(list, id);
2N/A
2N/A return (obj);
2N/A}
2N/A
2N/Astatic void
2N/Araid_list_destroy(raid_list_t *list)
2N/A{
2N/A list->head = NULL;
2N/A list->tail = NULL;
2N/A list->offset = 0;
2N/A}
2N/A
2N/A/*
2N/A * Plug-in maintennance routines
2N/A */
2N/Astatic int
2N/Acontroller_id_to_path(uint32_t controller_id, char *path)
2N/A{
2N/A int fd;
2N/A char buf[MAX_PATH_LEN] = {0}, buf1[MAX_PATH_LEN] = {0}, *colon;
2N/A
2N/A (void) snprintf(buf, MAX_PATH_LEN, "%s/c%d", CFGDIR, controller_id);
2N/A if (readlink(buf, buf1, sizeof (buf1)) < 0)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A
2N/A if (buf1[0] != '/')
2N/A (void) snprintf(buf, sizeof (buf), "%s/", CFGDIR);
2N/A else
2N/A buf[0] = 0;
2N/A (void) strlcat(buf, buf1, MAX_PATH_LEN);
2N/A
2N/A colon = strrchr(buf, ':');
2N/A if (colon == NULL)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A else
2N/A *colon = 0;
2N/A
2N/A (void) snprintf(path, MAX_PATH_LEN, "%s:devctl", buf);
2N/A
2N/A fd = open(path, O_RDONLY | O_NDELAY);
2N/A
2N/A if (fd < 0)
2N/A return (ERR_DRIVER_NOT_FOUND);
2N/A
2N/A (void) close(fd);
2N/A
2N/A return (SUCCESS);
2N/A}
2N/A
2N/Astatic char *
2N/Acontroller_id_to_driver_name(uint32_t controller_id)
2N/A{
2N/A char buf[MAX_PATH_LEN];
2N/A di_node_t di_node;
2N/A char *name, *tmp;
2N/A int ret;
2N/A
2N/A ret = controller_id_to_path(controller_id, buf);
2N/A if (ret < SUCCESS)
2N/A return (NULL);
2N/A
2N/A tmp = strrchr(buf, ':');
2N/A if (tmp != NULL)
2N/A *tmp = 0;
2N/A
2N/A tmp = strstr(buf, "pci");
2N/A if (tmp == NULL)
2N/A return (NULL);
2N/A
2N/A di_node = di_init(tmp, DINFOPROP);
2N/A if (di_node == DI_NODE_NIL)
2N/A return (NULL);
2N/A
2N/A name = di_driver_name(di_node);
2N/A
2N/A return (name);
2N/A}
2N/A
2N/Astatic void
2N/Araid_plugin_init()
2N/A{
2N/A raid_lib_t *raid_lib = raid_lib_sys;
2N/A
2N/A while (raid_lib) {
2N/A raid_lib_sys = raid_lib->next;
2N/A (void) dlclose(raid_lib->lib_handle);
2N/A free(raid_lib);
2N/A raid_lib = raid_lib_sys;
2N/A }
2N/A}
2N/A
2N/Astatic raid_lib_t *
2N/Araid_plugin_load(char *driver_name)
2N/A{
2N/A char buf[MAX_PATH_LEN] = {0};
2N/A raid_lib_t *supplib;
2N/A void *sym;
2N/A
2N/A supplib = calloc(1, sizeof (raid_lib_t));
2N/A if (supplib == NULL)
2N/A return (NULL);
2N/A
2N/A (void) snprintf(buf, MAX_PATH_LEN, "%s/%s.so.1",
2N/A SUPP_PLUGIN_DIR, driver_name);
2N/A
2N/A supplib->lib_handle = dlopen(buf, RTLD_LAZY);
2N/A if (supplib->lib_handle == NULL) {
2N/A free(supplib);
2N/A return (NULL);
2N/A }
2N/A
2N/A supplib->name = driver_name;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_version")) == NULL)
2N/A supplib->version = RDCFG_PLUGIN_V1;
2N/A else {
2N/A supplib->version = *((uint32_t *)sym);
2N/A if (supplib->version != RDCFG_PLUGIN_V1) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_open_controller")) ==
2N/A NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->open_controller = (int(*)(uint32_t, char **))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_close_controller")) ==
2N/A NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->close_controller = (int (*)(uint32_t, char **))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_compnum")) == NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->compnum = (int (*)(uint32_t, uint32_t,
2N/A raid_obj_type_id_t, raid_obj_type_id_t))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_complist")) == NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->complist = (int (*)(uint32_t, uint32_t,
2N/A raid_obj_type_id_t, raid_obj_type_id_t, int, void *))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_get_attr")) == NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->get_attr = (int (*)(uint32_t, uint32_t, uint32_t,
2N/A raid_obj_type_id_t, void*))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_array_create")) == NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->array_create = (int (*)(uint32_t, array_attr_t *, int,
2N/A arraypart_attr_t *, char **))sym;
2N/A
2N/A if ((sym = dlsym(supplib->lib_handle, "rdcfg_array_delete")) == NULL) {
2N/A (void) dlclose(supplib->lib_handle);
2N/A free(supplib);
2N/A return (NULL);
2N/A } else
2N/A supplib->array_delete =
2N/A (int (*)(uint32_t, uint32_t, char **))sym;
2N/A
2N/A supplib->hsp_bind = (int (*)(uint32_t, hsp_relation_t *,
2N/A char **))dlsym(supplib->lib_handle, "rdcfg_hsp_bind");
2N/A supplib->hsp_unbind = (int (*)(uint32_t, hsp_relation_t *,
2N/A char **))dlsym(supplib->lib_handle, "rdcfg_hsp_unbind");
2N/A supplib->set_attr = (int (*)(uint32_t, uint32_t, uint32_t, uint32_t *,
2N/A char **))dlsym(supplib->lib_handle, "rdcfg_set_attr");
2N/A supplib->flash_fw = (int (*)(uint32_t, char *, uint32_t, char **))
2N/A dlsym(supplib->lib_handle, "rdcfg_flash_fw");
2N/A
2N/A supplib->next = raid_lib_sys;
2N/A raid_lib_sys = supplib;
2N/A return (supplib);
2N/A}
2N/A
2N/Astatic raid_lib_t *
2N/Araid_find_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t controller_obj_id)
2N/A{
2N/A controller_attr_t *controller_attr;
2N/A raid_lib_t *raid_lib;
2N/A char *driver_name;
2N/A raid_obj_handle_t handle;
2N/A
2N/A /* Check if it's mapped to handle structure */
2N/A handle = raid_obj_to_handle(raid_tab, controller_obj_id);
2N/A if (raid_handle_sys.handles[handle].raid_lib != NULL)
2N/A return (raid_handle_sys.handles[handle].raid_lib);
2N/A
2N/A (void) obj_get_attr(raid_tab, controller_obj_id,
2N/A (void **)(&controller_attr));
2N/A
2N/A /* Check if the plugin module is already loaded */
2N/A driver_name = controller_id_to_driver_name(
2N/A controller_attr->controller_id);
2N/A if (driver_name == NULL)
2N/A return (NULL);
2N/A
2N/A raid_lib = raid_lib_sys;
2N/A while (raid_lib != NULL) {
2N/A if (raid_lib->name != NULL &&
2N/A strcmp(driver_name, raid_lib->name) == 0)
2N/A return (raid_lib);
2N/A
2N/A raid_lib = raid_lib->next;
2N/A }
2N/A
2N/A /* Loading the plugin module */
2N/A raid_lib = raid_plugin_load(driver_name);
2N/A
2N/A return (raid_lib);
2N/A}