/*
* Take the deviceID property from the object path and get the raw devpath
* of the drive that corresponds to the given device ID.
*/
static dm_descriptor_t *
get_partition_descs(CCIMObjectPath *op)
{
CCIMPropertyList *prop_list = NULL;
CCIMProperty *prop = NULL;
int error;
dm_descriptor_t dp;
dm_descriptor_t *da;
dm_descriptor_t *dpa;
if (op != NULL) {
prop_list = op->mKeyProperties;
}
for (; prop_list; prop_list = prop_list->mNext) {
if (((prop = prop_list->mDataObject) != NULL &&
prop->mName != NULL &&
strcasecmp(prop->mName, "deviceid")) == 0) {
break;
}
}
if (prop == NULL || prop->mValue == NULL) {
return (NULL);
}
dp = dm_get_descriptor_by_name(DM_DRIVE, prop->mValue, &error);
if (error != 0) {
return (NULL);
}
da = dm_get_associated_descriptors(dp, DM_MEDIA, &error);
dm_free_descriptor(dp);
if (error != 0 || da == NULL) {
return (NULL);
}
if (da[0] == NULL) {
dm_free_descriptors(da);
return (NULL);
}
dpa = dm_get_associated_descriptors(da[0], DM_PARTITION, &error);
dm_free_descriptors(da);
if (error != 0 || dpa == NULL) {
return (NULL);
}
if (dpa[0] == NULL) {
dm_free_descriptors(dpa);
return (NULL);
}
return (dpa);
}
/*
* Return: 1 if fails, 0 if ok. geometry array contains:
* 0. SectorsPerCylinder
* 1. HeadsPerCylinder
* 2. BytesPerCylinder
* 3. PhysicalCylinders
* 4. DataCylinders
* 5. AlternateCylinders
* 6. ActualCylinders
*/
static int
disk_geometry(char *media_name, ulong_t *geometry)
{
int error;
dm_descriptor_t d;
nvlist_t *attrs;
uint32_t val32;
d = dm_get_descriptor_by_name(DM_MEDIA, media_name, &error);
if (error != 0) {
return (1);
}
attrs = dm_get_attributes(d, &error);
dm_free_descriptor(d);
if (error != 0) {
return (1);
}
/*
* If nsect is not in the attr list then we have media that does
* not have geometry info on it (e.g. EFI label). So return a failure
* in this case. Otherwise, just get the attrs we can and return
* their values.
*/
if (nvlist_lookup_uint32(attrs, DM_NSECTORS, &val32) != 0) {
nvlist_free(attrs);
return (1);
}
geometry[0] = val32;
val32 = 0;
nvlist_lookup_uint32(attrs, DM_NHEADS, &val32);
geometry[1] = val32;
val32 = 0;
nvlist_lookup_uint32(attrs, DM_BLOCKSIZE, &val32);
geometry[2] = (geometry[1] * geometry[0]) * val32;
val32 = 0;
nvlist_lookup_uint32(attrs, DM_NPHYSCYLINDERS, &val32);
geometry[3] = val32;
val32 = 0;
nvlist_lookup_uint32(attrs, DM_NCYLINDERS, &val32);
geometry[4] = val32;
val32 = 0;
nvlist_lookup_uint32(attrs, DM_NALTCYLINDERS, &val32);
geometry[5] = val32;
val32 = 0;
/* This one is probably there only in x86 machines. */
nvlist_lookup_uint32(attrs, DM_NACTUALCYLINDERS, &val32);
geometry[6] = val32;
nvlist_free(attrs);
return (0);
}
/*ARGSUSED*/
static int
disk_temp_reading(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
nvlist_t *in, nvlist_t **out)
{
char *devid;
uint32_t temp;
dm_descriptor_t drive_descr = NULL;
nvlist_t *drive_stats, *pargs, *nvl;
int err;
if (vers > TOPO_METH_DISK_TEMP_VERSION)
return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
if (nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &pargs) != 0 ||
nvlist_lookup_string(pargs, TOPO_IO_DEVID, &devid) != 0) {
topo_mod_dprintf(mod, "Failed to lookup %s arg",
TOPO_IO_DEVID);
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
if ((drive_descr = dm_get_descriptor_by_name(DM_DRIVE, devid,
&err)) == NULL) {
topo_mod_dprintf(mod, "failed to get drive decriptor for %s",
devid);
return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
}
if ((drive_stats = dm_get_stats(drive_descr, DM_DRV_STAT_TEMPERATURE,
&err)) == NULL ||
nvlist_lookup_uint32(drive_stats, DM_TEMPERATURE, &temp) != 0) {
topo_mod_dprintf(mod, "failed to read disk temp for %s",
devid);
dm_free_descriptor(drive_descr);
return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
}
dm_free_descriptor(drive_descr);
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
TOPO_SENSOR_READING) != 0 ||
nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_DOUBLE) !=
0 || nvlist_add_double(nvl, TOPO_PROP_VAL_VAL, (double)temp) != 0) {
topo_mod_dprintf(mod, "Failed to allocate 'out' nvlist\n");
nvlist_free(nvl);
return (topo_mod_seterrno(mod, EMOD_NOMEM));
}
*out = nvl;
return (0);
}
/*
* Validate a device.
*/
int
check_device(const char *path, boolean_t force, boolean_t isspare)
{
dm_descriptor_t desc;
int err;
char *dev;
/*
* For whole disks, libdiskmgt does not include the leading dev path.
*/
dev = strrchr(path, '/');
assert(dev != NULL);
dev++;
if ((desc = dm_get_descriptor_by_name(DM_ALIAS, dev, &err)) != NULL) {
err = check_disk(path, desc, force, isspare);
dm_free_descriptor(desc);
return (err);
}
return (check_slice(path, force, B_FALSE, isspare));
}
/*
* Convenience function to get slice stats
*/
void
dm_get_slice_stats(char *slice, nvlist_t **dev_stats, int *errp)
{
dm_descriptor_t devp;
*dev_stats = NULL;
*errp = 0;
if (slice == NULL) {
return;
}
/*
* Errors must be handled by the caller. The dm_descriptor_t *
* values will be NULL if an error occured in these calls.
*/
devp = dm_get_descriptor_by_name(DM_SLICE, slice, errp);
if (devp != NULL) {
*dev_stats = dm_get_stats(devp, DM_SLICE_STAT_USE,
errp);
dm_free_descriptor(devp);
}
}
/*
* Returns, via slices paramater, a dm_descriptor_t list of
* slices for the named disk drive.
*/
void
dm_get_slices(char *drive, dm_descriptor_t **slices, int *errp)
{
dm_descriptor_t alias;
dm_descriptor_t *media;
dm_descriptor_t *disk;
*slices = NULL;
*errp = 0;
if (drive == NULL) {
return;
}
alias = dm_get_descriptor_by_name(DM_ALIAS, drive, errp);
/*
* Errors must be handled by the caller. The dm_descriptor_t *
* values will be NULL if an error occured in these calls.
*/
if (alias != NULL) {
disk = dm_get_associated_descriptors(alias, DM_DRIVE, errp);
dm_free_descriptor(alias);
if (disk != NULL) {
media = dm_get_associated_descriptors(*disk,
DM_MEDIA, errp);
dm_free_descriptors(disk);
if (media != NULL) {
*slices = dm_get_associated_descriptors(*media,
DM_SLICE, errp);
dm_free_descriptors(media);
}
}
}
}
/*
* Take the deviceID property from the object path and get the raw devpath
* of the drive that corresponds to the given device ID.
*/
static CIMBool
get_devpath(CCIMObjectPath *op, char *devpath, int len)
{
CCIMPropertyList *prop_list = NULL;
CCIMProperty *prop = NULL;
int error;
dm_descriptor_t dp;
dm_descriptor_t *da;
nvlist_t *attrs;
char *opath;
char *keyprop;
int type = 0;
char *p;
if (strcasecmp(op->mName, "Solaris_Disk") == 0) {
keyprop = "Tag";
type = 1;
} else if (strcasecmp(op->mName, "Solaris_DiskDrive") == 0) {
keyprop = "deviceid";
type = 2;
} else if (strcasecmp(op->mName, "Solaris_DiskPartition") == 0) {
keyprop = "deviceid";
type = 3;
} else {
return (cim_false);
}
if (op != NULL) {
prop_list = op->mKeyProperties;
}
for (; prop_list; prop_list = prop_list->mNext) {
if (((prop = prop_list->mDataObject) != NULL &&
prop->mName != NULL && strcasecmp(prop->mName, keyprop)) == 0) {
break;
}
}
if (prop == NULL || prop->mValue == NULL) {
return (cim_false);
}
switch (type) {
case 1:
dp = dm_get_descriptor_by_name(DM_MEDIA, prop->mValue, &error);
if (error != 0) {
return (cim_false);
}
da = dm_get_associated_descriptors(dp, DM_DRIVE, &error);
dm_free_descriptor(dp);
if (error != 0 || da == NULL) {
return (cim_false);
}
if (da[0] == NULL) {
dm_free_descriptors(da);
return (cim_false);
}
attrs = dm_get_attributes(da[0], &error);
dm_free_descriptors(da);
if (error != 0) {
return (cim_false);
}
if (nvlist_lookup_string(attrs, DM_OPATH, &opath) != 0) {
nvlist_free(attrs);
return (cim_false);
}
(void) strlcpy(devpath, opath, len);
nvlist_free(attrs);
break;
case 2:
dp = dm_get_descriptor_by_name(DM_DRIVE, prop->mValue, &error);
if (error != 0) {
return (cim_false);
}
attrs = dm_get_attributes(dp, &error);
dm_free_descriptor(dp);
if (error != 0) {
return (cim_false);
}
if (nvlist_lookup_string(attrs, DM_OPATH, &opath) != 0) {
nvlist_free(attrs);
return (cim_false);
}
(void) strlcpy(devpath, opath, len);
nvlist_free(attrs);
break;
case 3:
/* Convert the Solaris_DiskPartition value to rdsk. */
p = strstr(prop->mValue, "/dsk/");
if (p == NULL || (strlen(prop->mValue) + 2) > len) {
(void) strlcpy(devpath, prop->mValue, len);
} else {
p++;
*p = 0;
(void) strcpy(devpath, prop->mValue); /* copy up to dsk/ */
*p = 'd';
(void) strcat(devpath, "r"); /* prefix 'r' to dsk/ */
(void) strcat(devpath, p); /* append the rest */
}
break;
}
return (cim_true);
}
/*
* Set the properties of the disk node, from dev_di_node_t data.
* Properties include:
* group: protocol properties: resource, asru, label, fru
* group: authority properties: product-id, chasis-id, server-id
* group: io properties: devfs-path, devid
* group: storage properties:
* - logical-disk, disk-model, disk-manufacturer, serial-number
* - firmware-revision, capacity-in-bytes
*
* NOTE: the io and storage groups won't be present if the dnode passed in is
* NULL. This happens when a disk is found through ses, but is not enumerated
* in the devinfo tree.
*/
static int
disk_set_props(topo_mod_t *mod, tnode_t *parent,
tnode_t *dtn, dev_di_node_t *dnode)
{
nvlist_t *asru = NULL, *drive_attrs;
char *label = NULL;
nvlist_t *fmri = NULL;
dm_descriptor_t drive_descr = NULL;
uint32_t rpm;
int err;
/* pull the label property down from our parent 'bay' node */
if (topo_node_label(parent, &label, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"label error %s\n", topo_strerror(err));
goto error;
}
if (topo_node_label_set(dtn, label, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"label_set error %s\n", topo_strerror(err));
goto error;
}
/* get the resource fmri, and use it as the fru */
if (topo_node_resource(dtn, &fmri, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"resource error: %s\n", topo_strerror(err));
goto error;
}
if (topo_node_fru_set(dtn, fmri, 0, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"fru_set error: %s\n", topo_strerror(err));
goto error;
}
/* create/set the authority group */
if ((topo_pgroup_create(dtn, &disk_auth_pgroup, &err) != 0) &&
(err != ETOPO_PROP_DEFD)) {
topo_mod_dprintf(mod, "disk_set_props: "
"create disk_auth error %s\n", topo_strerror(err));
goto error;
}
/* create the storage group */
if (topo_pgroup_create(dtn, &storage_pgroup, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"create storage error %s\n", topo_strerror(err));
goto error;
}
/* no dnode was found for this disk - skip the io and storage groups */
if (dnode == NULL) {
err = 0;
goto out;
}
/* form and set the asru */
if ((asru = topo_mod_devfmri(mod, FM_DEV_SCHEME_VERSION,
dnode->ddn_dpath, dnode->ddn_devid)) == NULL) {
err = ETOPO_FMRI_UNKNOWN;
topo_mod_dprintf(mod, "disk_set_props: "
"asru error %s\n", topo_strerror(err));
goto error;
}
if (topo_node_asru_set(dtn, asru, 0, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"asru_set error %s\n", topo_strerror(err));
goto error;
}
/* create/set the devfs-path and devid in the io group */
if (topo_pgroup_create(dtn, &io_pgroup, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"create io error %s\n", topo_strerror(err));
goto error;
}
if (topo_prop_set_string(dtn, TOPO_PGROUP_IO, TOPO_IO_DEV_PATH,
TOPO_PROP_IMMUTABLE, dnode->ddn_dpath, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set dev error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_devid && topo_prop_set_string(dtn, TOPO_PGROUP_IO,
TOPO_IO_DEVID, TOPO_PROP_IMMUTABLE, dnode->ddn_devid, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set devid error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_ppath_count != 0 &&
topo_prop_set_string_array(dtn, TOPO_PGROUP_IO, TOPO_IO_PHYS_PATH,
TOPO_PROP_IMMUTABLE, (const char **)dnode->ddn_ppath,
dnode->ddn_ppath_count, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set phys-path error %s\n", topo_strerror(err));
goto error;
}
/* set the storage group public /dev name */
if (dnode->ddn_lpath != NULL &&
topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_LOGICAL_DISK_NAME, TOPO_PROP_IMMUTABLE,
dnode->ddn_lpath, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set disk_name error %s\n", topo_strerror(err));
goto error;
}
/* populate other misc storage group properties */
if (dnode->ddn_mfg && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_MANUFACTURER, TOPO_PROP_IMMUTABLE,
dnode->ddn_mfg, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set mfg error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_model && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_MODEL, TOPO_PROP_IMMUTABLE,
dnode->ddn_model, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set model error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_serial && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_SERIAL_NUM, TOPO_PROP_IMMUTABLE,
dnode->ddn_serial, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set serial error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_firm && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE,
dnode->ddn_firm, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set firm error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_cap && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE,
TOPO_STORAGE_CAPACITY, TOPO_PROP_IMMUTABLE,
dnode->ddn_cap, &err) != 0)) {
topo_mod_dprintf(mod, "disk_set_props: "
"set cap error %s\n", topo_strerror(err));
goto error;
}
if (dnode->ddn_devid == NULL ||
(drive_descr = dm_get_descriptor_by_name(DM_DRIVE,
dnode->ddn_devid, &err)) == NULL ||
(drive_attrs = dm_get_attributes(drive_descr, &err)) == NULL)
goto out;
if (nvlist_lookup_boolean(drive_attrs, DM_SOLIDSTATE) == 0 ||
nvlist_lookup_uint32(drive_attrs, DM_RPM, &rpm) != 0)
goto out;
if (topo_prop_set_uint32(dtn, TOPO_PGROUP_STORAGE, TOPO_STORAGE_RPM,
TOPO_PROP_IMMUTABLE, rpm, &err) != 0) {
topo_mod_dprintf(mod, "disk_set_props: "
"set rpm error %s\n", topo_strerror(err));
dm_free_descriptor(drive_descr);
goto error;
}
err = 0;
out:
if (drive_descr != NULL)
dm_free_descriptor(drive_descr);
nvlist_free(fmri);
if (label)
topo_mod_strfree(mod, label);
nvlist_free(asru);
return (err);
error: err = topo_mod_seterrno(mod, err);
goto out;
}
/*
* Checks for overlapping slices. If the given device is a slice, and it
* overlaps with any non-backup slice on the disk, return true with a detailed
* description similar to dm_inuse().
*/
int
dm_isoverlapping(char *slicename, char **overlaps_with, int *errp)
{
dm_descriptor_t slice = NULL;
dm_descriptor_t *media = NULL;
dm_descriptor_t *slices = NULL;
int i = 0;
uint32_t in_snum;
uint64_t start_block = 0;
uint64_t end_block = 0;
uint64_t media_size = 0;
uint64_t size = 0;
nvlist_t *media_attrs = NULL;
nvlist_t *slice_attrs = NULL;
int ret = 0;
slice = dm_get_descriptor_by_name(DM_SLICE, slicename, errp);
if (slice == NULL)
goto out;
/*
* Get the list of slices be fetching the associated media, and then all
* associated slices.
*/
media = dm_get_associated_descriptors(slice, DM_MEDIA, errp);
if (media == NULL || *media == NULL || *errp != 0)
goto out;
slices = dm_get_associated_descriptors(*media, DM_SLICE, errp);
if (slices == NULL || *slices == NULL || *errp != 0)
goto out;
media_attrs = dm_get_attributes(*media, errp);
if (media_attrs == NULL || *errp)
goto out;
*errp = nvlist_lookup_uint64(media_attrs, DM_NACCESSIBLE, &media_size);
if (*errp != 0)
goto out;
slice_attrs = dm_get_attributes(slice, errp);
if (slice_attrs == NULL || *errp != 0)
goto out;
*errp = nvlist_lookup_uint64(slice_attrs, DM_START, &start_block);
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint64(slice_attrs, DM_SIZE, &size);
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint32(slice_attrs, DM_INDEX, &in_snum);
if (*errp != 0)
goto out;
end_block = (start_block + size) - 1;
for (i = 0; slices[i]; i ++) {
uint64_t other_start;
uint64_t other_end;
uint64_t other_size;
uint32_t snum;
nvlist_t *other_attrs = dm_get_attributes(slices[i], errp);
if (other_attrs == NULL)
continue;
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint64(other_attrs, DM_START,
&other_start);
if (*errp) {
nvlist_free(other_attrs);
goto out;
}
*errp = nvlist_lookup_uint64(other_attrs, DM_SIZE,
&other_size);
if (*errp) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
other_end = (other_size + other_start) - 1;
*errp = nvlist_lookup_uint32(other_attrs, DM_INDEX,
&snum);
if (*errp) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
/*
* Check to see if there are > 2 overlapping regions
* on this media in the same region as this slice.
* This is done by assuming the following:
* Slice 2 is the backup slice if it is the size
* of the whole disk
* If slice 2 is the overlap and slice 2 is the size of
* the whole disk, continue. If another slice is found
* that overlaps with our slice, return it.
* There is the potential that there is more than one slice
* that our slice overlaps with, however, we only return
* the first overlapping slice we find.
*
*/
if (start_block >= other_start && start_block <= other_end) {
if ((snum == 2 && (other_size == media_size)) ||
snum == in_snum) {
continue;
} else {
char *str = dm_get_name(slices[i], errp);
if (*errp != 0) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
*overlaps_with = strdup(str);
dm_free_name(str);
nvlist_free(other_attrs);
ret = 1;
goto out;
}
} else if (other_start >= start_block &&
other_start <= end_block) {
if ((snum == 2 && (other_size == media_size)) ||
snum == in_snum) {
continue;
} else {
char *str = dm_get_name(slices[i], errp);
if (*errp != 0) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
*overlaps_with = strdup(str);
dm_free_name(str);
nvlist_free(other_attrs);
ret = 1;
goto out;
}
}
nvlist_free(other_attrs);
}
out:
if (media_attrs)
nvlist_free(media_attrs);
if (slice_attrs)
nvlist_free(slice_attrs);
if (slices)
dm_free_descriptors(slices);
if (media)
dm_free_descriptors(media);
if (slice)
dm_free_descriptor(slice);
return (ret);
}
/* ARGSUSED */
CCIMInstance*
cp_getInstance_Solaris_IDEInterface(CCIMObjectPath* pOP)
{
CCIMInstance* inst = NULL;
CCIMPropertyList* pCurPropList;
dm_descriptor_t d_descriptor;
dm_descriptor_t c_descriptor;
CCIMObjectPath *antOp = NULL;
CCIMObjectPath *depOp = NULL;
int error;
char *name;
if (pOP == NULL) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstance *)NULL);
}
if ((pCurPropList = pOP->mKeyProperties) == NULL) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstance *)NULL);
}
antOp = (CCIMObjectPath *)util_getKeyValue(pCurPropList, reference,
ANTECEDENT, &error);
if (error == 0) {
depOp = (CCIMObjectPath *)util_getKeyValue(pCurPropList, reference,
DEPENDENT, &error);
}
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER,
NULL, NULL, &error);
return ((CCIMInstance *)NULL);
}
/*
* Now, get the name of the antecedent from the object path.
*/
if ((pCurPropList = antOp->mKeyProperties) == NULL) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstance *)NULL);
}
name = (cimchar *)util_getKeyValue(pCurPropList, string, DEVICEID,
&error);
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER,
NULL, NULL, &error);
}
/*
* The only reason it is needed to get the descriptor for these
* two devices is to verify that they still exist and are valid.
* If they are not found, then getting the instance for this
* association as passed in by the client is not possible.
*/
c_descriptor = dm_get_descriptor_by_name(DM_CONTROLLER, name,
&error);
/*
* Not found. Return a null instance.
*/
if (c_descriptor == NULL || error == ENODEV) {
return ((CCIMInstance *)NULL);
}
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_FAILED,
DM_GET_DESC_BYNAME_FAILURE, NULL, &error);
return ((CCIMInstance*)NULL);
}
dm_free_descriptor(c_descriptor);
/*
* Now, get the name of the dependent from the object path.
*/
if ((pCurPropList = depOp->mKeyProperties) == NULL) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstance *)NULL);
}
name = (cimchar *)util_getKeyValue(pCurPropList, string, DEVICEID,
&error);
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_INVALID_PARAMETER,
NULL, NULL, &error);
return ((CCIMInstance *)NULL);
}
d_descriptor = dm_get_descriptor_by_name(DM_DRIVE, name,
&error);
/*
* Not found. Return a null instance.
*/
if (d_descriptor == NULL || error == ENODEV) {
d_descriptor = dm_get_descriptor_by_name(DM_ALIAS, name,
&error);
if (d_descriptor == NULL || error == ENODEV) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_NOT_FOUND,
NULL, NULL, &error);
return ((CCIMInstance *)NULL);
}
}
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_FAILED,
DM_GET_DESC_BYNAME_FAILURE, NULL, &error);
return ((CCIMInstance *)NULL);
}
dm_free_descriptor(d_descriptor);
/*
* At this point I have verified I have the two devices that
* are part of this association. Use the object paths I got
* earlier to create the ideinterface instance.
*/
inst = ideIntAssocToInst(antOp, ANTECEDENT, depOp, DEPENDENT, &error);
if (error != 0) {
util_handleError(IDE_GETINSTANCE, CIM_ERR_FAILED,
IDEINT_ASSOC_TO_INSTANCE_FAILURE, NULL, &error);
return ((CCIMInstance *)NULL);
}
return (inst);
}
/* ARGSUSED */
CCIMInstanceList *
cp_associators_Solaris_IDEInterface(CCIMObjectPath *pAssocName,
CCIMObjectPath *pObjectName, cimchar *pResultClass, cimchar *pRole,
cimchar *pResultRole)
{
CCIMPropertyList *pCurPropList;
CCIMInstanceList *instList = NULL;
dm_descriptor_t *assoc_descriptors = NULL;
dm_descriptor_t *tmpList = NULL;
dm_descriptor_t obj_desc = NULL;
char *name;
int error = 0;
int isAntecedent = 0;
int isAlias = 0;
if ((pObjectName == NULL ||
(pCurPropList = pObjectName->mKeyProperties) == NULL)) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstanceList *)NULL);
}
if (strcasecmp(pObjectName->mName, IDE_CONTROLLER) == 0) {
isAntecedent = 1;
}
if (pRole != NULL) {
if (strcasecmp(pRole, ANTECEDENT) == 0) {
if (isAntecedent != 1) {
util_handleError(IDE_ASSOCIATORS,
CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
} else if (strcasecmp(pRole, DEPENDENT) == 0) {
if (isAntecedent == 1) {
util_handleError(IDE_ASSOCIATORS,
CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
}
}
/*
* Both ide controller and disk drive have deviceid as the
* key.
*/
name = (cimchar *)util_getKeyValue(pCurPropList, string, DEVICEID,
&error);
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_INVALID_PARAMETER, NULL,
NULL, &error);
return ((CCIMInstanceList *)NULL);
}
if (isAntecedent) {
obj_desc = dm_get_descriptor_by_name(DM_CONTROLLER, name,
&error);
} else {
obj_desc = dm_get_descriptor_by_name(DM_DRIVE, name,
&error);
if (obj_desc == NULL || error == ENODEV) {
isAlias = 1;
obj_desc = dm_get_descriptor_by_name(DM_ALIAS, name, &error);
}
}
if (obj_desc == NULL) {
return ((CCIMInstanceList *)NULL);
}
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_FAILED,
DM_GET_DESC_BYNAME_FAILURE, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
if (isAlias) {
tmpList = dm_get_associated_descriptors(obj_desc, DM_DRIVE,
&error);
if (tmpList == NULL) {
return ((CCIMInstanceList *)NULL);
}
if (tmpList[0] == NULL) {
dm_free_descriptors(tmpList);
return ((CCIMInstanceList *)NULL);
}
}
if (isAntecedent) {
/*
* Get associated descriptors.
*/
assoc_descriptors = dm_get_associated_descriptors(obj_desc,
DM_DRIVE, &error);
dm_free_descriptor(obj_desc);
if (assoc_descriptors == NULL) {
return (instList);
}
if (assoc_descriptors[0] == NULL) {
dm_free_descriptors(assoc_descriptors);
return (instList);
}
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_FAILED,
DM_GET_ASSOC_FAILURE, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
/*
* Generate the inst list of the associated disk drives.
*/
instList = drive_descriptors_toCCIMObjPathInstList(DISK_DRIVE,
assoc_descriptors, &error);
dm_free_descriptors(assoc_descriptors);
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_FAILED,
DRIVE_DESC_TO_INSTANCE_FAILURE, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
} else {
/*
* This is the disk drive calling this function. Return the
* controllers that are associated with this disk.
*/
if (tmpList == NULL && obj_desc == NULL) {
return ((CCIMInstanceList *)NULL);
}
if (tmpList != NULL) {
assoc_descriptors = dm_get_associated_descriptors(tmpList[0],
DM_CONTROLLER, &error);
dm_free_descriptors(tmpList);
} else {
assoc_descriptors = dm_get_associated_descriptors(obj_desc,
DM_CONTROLLER, &error);
dm_free_descriptor(obj_desc);
}
if (assoc_descriptors == NULL) {
return ((CCIMInstanceList *)NULL);
}
if (assoc_descriptors[0] == NULL) {
dm_free_descriptors(assoc_descriptors);
return ((CCIMInstanceList *)NULL);
}
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_FAILED,
DM_GET_ASSOC_FAILURE, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
instList = ctrl_descriptors_toCCIMInstanceList(IDE_CONTROLLER,
assoc_descriptors, &error, 2, "ata", "pcata");
dm_free_descriptors(assoc_descriptors);
if (error != 0) {
util_handleError(IDE_ASSOCIATORS, CIM_ERR_FAILED,
IDECTRL_DESC_TO_INSTANCE_FAILURE, NULL, &error);
return ((CCIMInstanceList *)NULL);
}
}
return (instList);
}
/* ARGSUSED */
CCIMInstanceList*
cp_enumInstances_Solaris_IDEInterface(CCIMObjectPath* pOP)
{
CCIMInstanceList *instList = NULL;
CCIMObjectPathList *cObjList = NULL;
CCIMObjectPathList *tmpObjList;
CCIMObjectPath *objPath;
CCIMInstance *inst;
CCIMException *ex;
dm_descriptor_t *d_descriptorp = NULL;
int error = 0;
/*
* Get the list of IDE Controllers. Then get the associated drives
* via the device api.
*/
objPath = cim_createEmptyObjectPath(IDE_CONTROLLER);
if (objPath == NULL) {
ex = cim_getLastError();
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
CREATE_OBJECT_PATH, ex, &error);
return ((CCIMInstanceList *)NULL);
}
cObjList = cimom_enumerateInstanceNames(objPath, cim_false);
cim_freeObjectPath(objPath);
/*
* NULL means error.
*/
if (cObjList == NULL) {
ex = cim_getLastError();
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
ENUM_INSTANCENAMES_FAILURE, ex, &error);
return ((CCIMInstanceList *)NULL);
}
if (cObjList->mDataObject == NULL) {
return ((CCIMInstanceList *)NULL);
}
instList = cim_createInstanceList();
if (instList == NULL) {
ex = cim_getLastError();
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
CREATE_INSTANCE_LIST_FAILURE, ex, &error);
return ((CCIMInstanceList *)NULL);
}
/*
* Loop through all of these controller objects and get the associated
* disks.
*/
for (tmpObjList = cObjList;
tmpObjList != NULL && tmpObjList->mDataObject != NULL;
tmpObjList = tmpObjList->mNext) {
char *name = NULL;
CCIMObjectPath *cOp;
CCIMInstanceList *tmpList = NULL;
CCIMInstanceList *tmpList1;
CCIMPropertyList *pCurPropList;
CCIMObjectPathList *dObjList;
CCIMInstanceList *tL;
dm_descriptor_t c_descriptor = NULL;
error = 0;
cOp = tmpObjList->mDataObject;
if ((pCurPropList = cOp->mKeyProperties) == NULL) {
util_handleError(IDE_ENUMINSTANCES,
CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
cim_freeObjectPathList(cObjList);
cim_freeInstanceList(instList);
return ((CCIMInstanceList *)NULL);
}
name = (cimchar *)util_getKeyValue(pCurPropList, string, DEVICEID,
&error);
if (error != 0) {
util_handleError(IDE_ENUMINSTANCES,
CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
cim_freeObjectPathList(cObjList);
cim_freeInstanceList(instList);
return ((CCIMInstanceList *)NULL);
}
c_descriptor = dm_get_descriptor_by_name(DM_CONTROLLER, name,
&error);
if (c_descriptor == NULL || error == ENODEV) {
continue;
}
if (error != 0) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
DM_GET_DESC_BYNAME_FAILURE, NULL,
&error);
cim_freeObjectPathList(cObjList);
cim_freeInstanceList(instList);
return ((CCIMInstanceList *)NULL);
}
d_descriptorp = dm_get_associated_descriptors(c_descriptor,
DM_DRIVE, &error);
dm_free_descriptor(c_descriptor);
/*
* If there are no drives associated with this controller,
* continue on to the next controller.
*/
if (d_descriptorp == NULL) {
continue;
}
if (d_descriptorp[0] == NULL) {
dm_free_descriptors(d_descriptorp);
continue;
}
if (error == ENODEV) {
continue;
}
if (error != 0) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
DM_GET_ASSOC_FAILURE, NULL, &error);
cim_freeInstanceList(instList);
cim_freeObjectPathList(cObjList);
return ((CCIMInstanceList *)NULL);
}
tmpList = drive_descriptors_toCCIMObjPathInstList(
DISK_DRIVE, d_descriptorp, &error);
dm_free_descriptors(d_descriptorp);
d_descriptorp = NULL;
if (error != 0) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
DRIVE_DESC_TO_INSTANCE_FAILURE, NULL, &error);
cim_freeInstanceList(instList);
cim_freeObjectPathList(cObjList);
return ((CCIMInstanceList *)NULL);
}
/*
* It is possible that the controller does not have a drive
* associated with it. If this is true, the list will be
* NULL.
*/
if (tmpList == NULL) {
continue;
}
dObjList = cim_createObjectPathList(tmpList);
cim_freeInstanceList(tmpList);
if (dObjList == NULL) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
DRIVE_DESC_TO_INSTANCE_FAILURE, NULL, &error);
cim_freeInstanceList(instList);
cim_freeObjectPathList(cObjList);
return ((CCIMInstanceList *)NULL);
}
tmpList1 = ideIntAssocToInstList(
cOp, ANTECEDENT, dObjList, DEPENDENT, &error);
cim_freeObjectPathList(dObjList);
if (error != 0) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
IDECTRL_DESC_TO_INSTANCE_FAILURE, NULL, &error);
cim_freeInstanceList(instList);
cim_freeObjectPathList(cObjList);
return ((CCIMInstanceList *)NULL);
}
tL = tmpList1;
do {
inst = cim_copyInstance(tL->mDataObject);
instList = cim_addInstance(instList, inst);
if (instList == NULL) {
util_handleError(IDE_ENUMINSTANCES, CIM_ERR_FAILED,
ADD_INSTANCE_FAILURE, NULL, &error);
cim_freeObjectPathList(cObjList);
cim_freeObjectPathList(tmpList1);
return ((CCIMInstanceList *)NULL);
}
tL = tL->mNext;
} while (tL && tL->mDataObject != NULL);
cim_freeInstanceList(tmpList1);
} /* end for */
cim_freeObjectPathList(cObjList);
/*
* It is possible I will have an empty instance list at
* this point. So, I must check and NULL this out if
* there are no entries.
*/
if (instList->mDataObject == NULL) {
cim_freeInstanceList(instList);
instList = NULL;
}
return (instList);
}
