xref: /illumos-gate/usr/src/lib/libdiskmgt/common/entry.c (revision 7c478bd9)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <fcntl.h>
#include <libdevinfo.h>
#include <stdio.h>
#include <sys/sunddi.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include "libdiskmgt.h"
#include "disks_private.h"
#include "partition.h"


extern dm_desc_type_t drive_assoc_types[];
extern dm_desc_type_t bus_assoc_types[];
extern dm_desc_type_t controller_assoc_types[];
extern dm_desc_type_t media_assoc_types[];
extern dm_desc_type_t slice_assoc_types[];
extern dm_desc_type_t partition_assoc_types[];
extern dm_desc_type_t path_assoc_types[];
extern dm_desc_type_t alias_assoc_types[];

static dm_descriptor_t *ptr_array_to_desc_array(descriptor_t **ptrs, int *errp);
static descriptor_t **desc_array_to_ptr_array(dm_descriptor_t *da, int *errp);

void
dm_free_descriptor(dm_descriptor_t desc)
{
	descriptor_t	*dp;

	if (desc == NULL) {
	    return;
	}
	dp = (descriptor_t *)desc;

	cache_wlock();
	cache_free_descriptor(dp);
	cache_unlock();
}

void
dm_free_descriptors(dm_descriptor_t *desc_list)
{
	descriptor_t	**dp;
	int		error;

	if (desc_list == NULL) {
	    return;
	}
	dp = desc_array_to_ptr_array(desc_list, &error);
	if (error != 0) {
	    free(desc_list);
	    return;
	}

	cache_wlock();
	cache_free_descriptors(dp);
	cache_unlock();
}

/*ARGSUSED*/
void
dm_free_name(char *name)
{
	free(name);
}

dm_descriptor_t *
dm_get_associated_descriptors(dm_descriptor_t desc, dm_desc_type_t type,
    int *errp)
{
	descriptor_t **descs = NULL;
	descriptor_t  *dp;


	dp = (descriptor_t *)desc;

	cache_wlock();

	if (!cache_is_valid_desc(dp)) {
	    cache_unlock();
	    *errp = EBADF;
	    return (NULL);
	}

	/* verify that the descriptor is still valid */
	if (dp->p.generic == NULL) {
	    cache_unlock();
	    *errp = ENODEV;
	    return (NULL);
	}

	switch (dp->type) {
	case DM_DRIVE:
	    descs = drive_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_BUS:
	    descs = bus_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_CONTROLLER:
	    descs = controller_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_MEDIA:
	    descs = media_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_SLICE:
	    descs = slice_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_PARTITION:
	    descs = partition_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_PATH:
	    descs = path_get_assoc_descriptors(dp, type, errp);
	    break;
	case DM_ALIAS:
	    descs = alias_get_assoc_descriptors(dp, type, errp);
	    break;
	default:
	    *errp = EINVAL;
	    break;
	}

	cache_unlock();

	return (ptr_array_to_desc_array(descs, errp));
}

dm_desc_type_t *
dm_get_associated_types(dm_desc_type_t type)
{
	switch (type) {
	case DM_DRIVE:
	    return (drive_assoc_types);
	case DM_BUS:
	    return (bus_assoc_types);
	case DM_CONTROLLER:
	    return (controller_assoc_types);
	case DM_MEDIA:
	    return (media_assoc_types);
	case DM_SLICE:
	    return (slice_assoc_types);
	case DM_PARTITION:
	    return (partition_assoc_types);
	case DM_PATH:
	    return (path_assoc_types);
	case DM_ALIAS:
	    return (alias_assoc_types);
	}

	return (NULL);
}

nvlist_t *
dm_get_attributes(dm_descriptor_t desc, int *errp)
{
	descriptor_t	*dp;
	nvlist_t	*attrs = NULL;


	dp = (descriptor_t *)desc;

	cache_rlock();

	if (!cache_is_valid_desc(dp)) {
	    cache_unlock();
	    *errp = EBADF;
	    return (NULL);
	}

	/* verify that the descriptor is still valid */
	if (dp->p.generic == NULL) {
	    cache_unlock();
	    *errp = ENODEV;
	    return (NULL);
	}

	switch (dp->type) {
	case DM_DRIVE:
	    attrs = drive_get_attributes(dp, errp);
	    break;
	case DM_BUS:
	    attrs = bus_get_attributes(dp, errp);
	    break;
	case DM_CONTROLLER:
	    attrs = controller_get_attributes(dp, errp);
	    break;
	case DM_MEDIA:
	    attrs = media_get_attributes(dp, errp);
	    break;
	case DM_SLICE:
	    attrs = slice_get_attributes(dp, errp);
	    break;
	case DM_PARTITION:
	    attrs = partition_get_attributes(dp, errp);
	    break;
	case DM_PATH:
	    attrs = path_get_attributes(dp, errp);
	    break;
	case DM_ALIAS:
	    attrs = alias_get_attributes(dp, errp);
	    break;
	default:
	    *errp = EINVAL;
	    break;
	}

	cache_unlock();

	return (attrs);
}

dm_descriptor_t
dm_get_descriptor_by_name(dm_desc_type_t desc_type, char *name, int *errp)
{
	dm_descriptor_t desc = NULL;


	cache_wlock();

	switch (desc_type) {
	case DM_DRIVE:
	    desc = (uintptr_t)drive_get_descriptor_by_name(name, errp);
	    break;
	case DM_BUS:
	    desc = (uintptr_t)bus_get_descriptor_by_name(name, errp);
	    break;
	case DM_CONTROLLER:
	    desc = (uintptr_t)controller_get_descriptor_by_name(name,
		errp);
	    break;
	case DM_MEDIA:
	    desc = (uintptr_t)media_get_descriptor_by_name(name, errp);
	    break;
	case DM_SLICE:
	    desc = (uintptr_t)slice_get_descriptor_by_name(name, errp);
	    break;
	case DM_PARTITION:
	    desc = (uintptr_t)partition_get_descriptor_by_name(name,
		errp);
	    break;
	case DM_PATH:
	    desc = (uintptr_t)path_get_descriptor_by_name(name, errp);
	    break;
	case DM_ALIAS:
	    desc = (uintptr_t)alias_get_descriptor_by_name(name, errp);
	    break;
	default:
	    *errp = EINVAL;
	    break;
	}

	cache_unlock();

	return (desc);
}

dm_descriptor_t *
dm_get_descriptors(dm_desc_type_t type, int filter[], int *errp)
{
	descriptor_t **descs = NULL;


	cache_wlock();

	switch (type) {
	case DM_DRIVE:
	    descs = drive_get_descriptors(filter, errp);
	    break;
	case DM_BUS:
	    descs = bus_get_descriptors(filter, errp);
	    break;
	case DM_CONTROLLER:
	    descs = controller_get_descriptors(filter, errp);
	    break;
	case DM_MEDIA:
	    descs = media_get_descriptors(filter, errp);
	    break;
	case DM_SLICE:
	    descs = slice_get_descriptors(filter, errp);
	    break;
	case DM_PARTITION:
	    descs = partition_get_descriptors(filter, errp);
	    break;
	case DM_PATH:
	    descs = path_get_descriptors(filter, errp);
	    break;
	case DM_ALIAS:
	    descs = alias_get_descriptors(filter, errp);
	    break;
	default:
	    *errp = EINVAL;
	    break;
	}

	cache_unlock();

	return (ptr_array_to_desc_array(descs, errp));
}

char *
dm_get_name(dm_descriptor_t desc, int *errp)
{
	descriptor_t	*dp;
	char		*nm = NULL;
	char		*name = NULL;

	dp = (descriptor_t *)desc;

	cache_rlock();

	if (!cache_is_valid_desc(dp)) {
	    cache_unlock();
	    *errp = EBADF;
	    return (NULL);
	}

	/* verify that the descriptor is still valid */
	if (dp->p.generic == NULL) {
	    cache_unlock();
	    *errp = ENODEV;
	    return (NULL);
	}

	switch (dp->type) {
	case DM_DRIVE:
	    nm = (drive_get_name(dp));
	    break;
	case DM_BUS:
	    nm = (bus_get_name(dp));
	    break;
	case DM_CONTROLLER:
	    nm = (controller_get_name(dp));
	    break;
	case DM_MEDIA:
	    nm = (media_get_name(dp));
	    break;
	case DM_SLICE:
	    nm = (slice_get_name(dp));
	    break;
	case DM_PARTITION:
	    nm = (partition_get_name(dp));
	    break;
	case DM_PATH:
	    nm = (path_get_name(dp));
	    break;
	case DM_ALIAS:
	    nm = (alias_get_name(dp));
	    break;
	}

	cache_unlock();

	*errp = 0;
	if (nm != NULL) {
	    name = strdup(nm);
	    if (name == NULL) {
		*errp = ENOMEM;
		return (NULL);
	    }
	    return (name);
	}
	return (NULL);
}

nvlist_t *
dm_get_stats(dm_descriptor_t desc, int stat_type, int *errp)
{
	descriptor_t  *dp;
	nvlist_t	*stats = NULL;


	dp = (descriptor_t *)desc;

	cache_rlock();

	if (!cache_is_valid_desc(dp)) {
	    cache_unlock();
	    *errp = EBADF;
	    return (NULL);
	}

	/* verify that the descriptor is still valid */
	if (dp->p.generic == NULL) {
	    cache_unlock();
	    *errp = ENODEV;
	    return (NULL);
	}

	switch (dp->type) {
	case DM_DRIVE:
	    stats = drive_get_stats(dp, stat_type, errp);
	    break;
	case DM_BUS:
	    stats = bus_get_stats(dp, stat_type, errp);
	    break;
	case DM_CONTROLLER:
	    stats = controller_get_stats(dp, stat_type, errp);
	    break;
	case DM_MEDIA:
	    stats = media_get_stats(dp, stat_type, errp);
	    break;
	case DM_SLICE:
	    stats = slice_get_stats(dp, stat_type, errp);
	    break;
	case DM_PARTITION:
	    stats = partition_get_stats(dp, stat_type, errp);
	    break;
	case DM_PATH:
	    stats = path_get_stats(dp, stat_type, errp);
	    break;
	case DM_ALIAS:
	    stats = alias_get_stats(dp, stat_type, errp);
	    break;
	default:
	    *errp = EINVAL;
	    break;
	}

	cache_unlock();

	return (stats);
}

dm_desc_type_t
dm_get_type(dm_descriptor_t desc)
{
	descriptor_t  *dp;

	dp = (descriptor_t *)desc;

	cache_rlock();

	if (!cache_is_valid_desc(dp)) {
	    cache_unlock();
	    return (-1);
	}

	cache_unlock();

	return (dp->type);
}

void
libdiskmgt_add_str(nvlist_t *attrs, char *name, char *val, int *errp)
{
	if (*errp == 0) {
		*errp = nvlist_add_string(attrs, name, val);
	}
}

descriptor_t **
libdiskmgt_empty_desc_array(int *errp)
{
	descriptor_t	**empty;

	empty = (descriptor_t **)calloc(1, sizeof (descriptor_t *));
	if (empty == NULL) {
	    *errp = ENOMEM;
	    return (NULL);
	}
	empty[0] = NULL;

	*errp = 0;
	return (empty);
}

void
libdiskmgt_init_debug()
{
	char	*valp;

	if ((valp = getenv(DM_DEBUG)) != NULL) {
	    dm_debug = atoi(valp);
	}
}

int
libdiskmgt_str_eq(char *nm1, char *nm2)
{
	if (nm1 == NULL) {
	    if (dm_debug) {
		(void) fprintf(stderr, "WARNING: str_eq nm1 NULL\n");
	    }

	    if (nm2 == NULL) {
		return (1);
	    } else {
		return (0);
	    }
	}

	/* nm1 != NULL */

	if (nm2 == NULL) {
	    if (dm_debug) {
		(void) fprintf(stderr, "WARNING: str_eq nm2 NULL\n");
	    }
	    return (0);
	}

	if (strcmp(nm1, nm2) == 0) {
	    return (1);
	}

	return (0);
}

/*ARGSUSED*/
static descriptor_t **
desc_array_to_ptr_array(dm_descriptor_t *descs, int *errp)
{
#ifdef _LP64
	return ((descriptor_t **)descs);
#else
	/* convert the 64 bit descriptors to 32 bit ptrs */
	int	cnt;
	int	i;
	descriptor_t **da;

	for (cnt = 0; descs[cnt]; cnt++);

	da = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *));
	if (da == NULL) {
	    *errp = ENOMEM;
	    return (NULL);
	}

	for (i = 0; descs[i]; i++) {
	    da[i] = (descriptor_t *)descs[i];
	}
	*errp = 0;
	free(descs);

	return (da);
#endif
}

/*ARGSUSED*/
static dm_descriptor_t *
ptr_array_to_desc_array(descriptor_t **ptrs, int *errp)
{
#ifdef _LP64
	return ((dm_descriptor_t *)ptrs);
#else
	/* convert the 32 bit ptrs to the 64 bit descriptors */
	int	cnt;
	int	i;
	dm_descriptor_t *da;

	if (*errp != 0 || ptrs == NULL) {
	    return (NULL);
	}

	for (cnt = 0; ptrs[cnt]; cnt++);

	da = (dm_descriptor_t *)calloc(cnt + 1, sizeof (dm_descriptor_t));
	if (da == NULL) {
	    *errp = ENOMEM;
	    return (NULL);
	}

	for (i = 0; ptrs[i]; i++) {
	    da[i] = (uintptr_t)ptrs[i];
	}
	*errp = 0;
	free(ptrs);

	return (da);
#endif
}