/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (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

 */

/*

 * Use is subject to license terms.

 */

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

#include <fcntl.h>

#include <libdevinfo.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/sunddi.h>

#include <sys/types.h>

#include <ctype.h>

#include <libgen.h>

#include <unistd.h>

#include <devid.h>

#include "libdiskmgt.h"

#include "disks_private.h"

#define	CLUSTER_DEV	"did"

/* specify which disk links to use in the /dev directory */

#define	DEVLINK_REGEX		"rdsk/.*"

#define	DEVLINK_FLOPPY_REGEX	"rdiskette[0-9]"

#define	DEVLINK_DID_REGEX	"did/rdsk/.*"

#define	FLOPPY_NAME	"rdiskette"

#define	MAXPROPLEN		1024

#define	DEVICE_ID_PROP		"devid"

#define	PROD_ID_PROP		"inquiry-product-id"

#define	PROD_ID_USB_PROP	"usb-product-name"

#define	REMOVABLE_PROP		"removable-media"

#define	HOTPLUGGABLE_PROP	"hotpluggable"

#define	SCSI_OPTIONS_PROP	"scsi-options"

#define	VENDOR_ID_PROP		"inquiry-vendor-id"

#define	VENDOR_ID_USB_PROP	"usb-vendor-name"

#define	WWN_PROP		"node-wwn"

/* The list of names of possible disk types used by libdevinfo. */

static char *disktypes[] = {

	DDI_NT_BLOCK,

	DDI_NT_BLOCK_CHAN,

	DDI_NT_BLOCK_WWN,

	DDI_NT_BLOCK_FABRIC,

	DDI_NT_CD_CHAN,

	DDI_NT_CD,

	DDI_NT_FD,

	NULL

};

/*

 * Most of the removable media will be lumped under here; CD, DVD, MO, etc.

 */

static char *cdromtypes[] = {

	DDI_NT_CD_CHAN,

	DDI_NT_CD,

	NULL

};

static char *ctrltypes[] = {

	DDI_NT_SCSI_NEXUS,

	DDI_NT_SCSI_ATTACHMENT_POINT,

	DDI_NT_FC_ATTACHMENT_POINT,

	NULL

};

static char *bustypes[] = {

	"sbus",

	"pci",

	"usb",

	NULL

};

static bus_t		*add_bus(struct search_args *args, di_node_t node,

			    di_minor_t minor, controller_t *cp);

static int		add_cluster_devs(di_node_t node, di_minor_t minor,

			    void *arg);

static controller_t	*add_controller(struct search_args *args,

			    di_node_t node, di_minor_t minor);

static int		add_devpath(di_devlink_t devlink, void *arg);

static int		add_devs(di_node_t node, di_minor_t minor, void *arg);

static int		add_disk2controller(disk_t *diskp,

			    struct search_args *args);

static int		add_disk2path(disk_t *dp, path_t *pp,

			    di_path_state_t st, char *wwn);

static int		add_int2array(int p, int **parray);

static int		add_ptr2array(void *p, void ***parray);

static char		*bus_type(di_node_t node, di_minor_t minor,

			    di_prom_handle_t ph);

static int		can_remove_controller(controller_t *cp,

			    controller_t *currp);

static void		clean_paths(struct search_args *args);

static disk_t		*create_disk(char *deviceid, char *kernel_name,

			    struct search_args *args);

static char		*ctype(di_node_t node, di_minor_t minor);

static boolean_t	disk_is_cdrom(char *type);

static alias_t		*find_alias(disk_t *diskp, char *kernel_name);

static bus_t		*find_bus(struct search_args *args, char *name);

static controller_t	*find_controller(struct search_args *args, char *name);

static int		fix_cluster_devpath(di_devlink_t devlink, void *arg);

static disk_t		*get_disk_by_deviceid(disk_t *listp, char *devid);

static void		get_disk_name_from_path(char *path, char *name,

			    int size);

static char		*get_byte_prop(char *prop_name, di_node_t node);

static di_node_t	get_parent_bus(di_node_t node,

			    struct search_args *args);

static int		get_prom_int(char *prop_name, di_node_t node,

			    di_prom_handle_t ph);

static char		*get_prom_str(char *prop_name, di_node_t node,

			    di_prom_handle_t ph);

static int		get_prop(char *prop_name, di_node_t node);

static char		*get_str_prop(char *prop_name, di_node_t node);

static int		have_disk(struct search_args *args, char *devid,

			    char *kernel_name, disk_t **diskp);

static int		is_cluster_disk(di_node_t node, di_minor_t minor);

static int		is_ctds(char *name);

static int		is_drive(di_minor_t minor);

static int		is_HBA(di_node_t node, di_minor_t minor);

static int		new_alias(disk_t *diskp, char *kernel_path,

			    char *devlink_path, struct search_args *args);

static int		new_devpath(alias_t *ap, char *devpath);

static path_t		*new_path(controller_t *cp, disk_t *diskp,

			    di_node_t node, di_path_state_t st, char *wwn);

static void		remove_invalid_controller(char *name,

			    controller_t *currp, struct search_args *args);

static char		*str_case_index(register char *s1, register char *s2);

/*

 * The functions in this file do a dev tree walk to build up a model of the

 * disks, controllers and paths on the system.  This model is returned in the

 * args->disk_listp and args->controller_listp members of the args param.

 * There is no global data for this file so it is thread safe.  It is up to

 * the caller to merge the resulting model with any existing model that is

 * cached.  The caller must also free the memory for this model when it is

 * no longer needed.

 */

void

findevs(struct search_args *args)

{

	uint_t			flags;

	di_node_t		di_root;

	args->dev_walk_status = 0;

	args->disk_listp = NULL;

	args->controller_listp = NULL;

	args->bus_listp = NULL;

	args->handle = di_devlink_init(NULL, 0);

	/*

	 * Have to make several passes at this with the new devfs caching.

	 * First, we find non-mpxio devices. Then we find mpxio/multipath

	 * devices. Finally, we get cluster devices.

	 */

	flags = DINFOCACHE;

	di_root = di_init("/", flags);

	args->ph = di_prom_init();

	(void) di_walk_minor(di_root, NULL, 0, args, add_devs);

	di_fini(di_root);

	flags = DINFOCPYALL | DINFOPATH;

	di_root = di_init("/", flags);

	(void) di_walk_minor(di_root, NULL, 0, args, add_devs);

	di_fini(di_root);

	/* do another pass to clean up cluster devpaths */

	flags = DINFOCACHE;

	di_root = di_init("/", flags);

	(void) di_walk_minor(di_root, DDI_PSEUDO, 0, args, add_cluster_devs);

	if (args->ph != DI_PROM_HANDLE_NIL) {

	    (void) di_prom_fini(args->ph);

	}

	di_fini(di_root);

	(void) di_devlink_fini(&(args->handle));

	clean_paths(args);

}

/*

 * Definitions of private functions

 */

static bus_t *

add_bus(struct search_args *args, di_node_t node, di_minor_t minor,

	controller_t *cp)

{

	char		*btype;

	char		*devpath;

	bus_t		*bp;

	char		kstat_name[MAXPATHLEN];

	di_node_t	pnode;

	if (node == DI_NODE_NIL) {

	    return (NULL);

	}

	if ((btype = bus_type(node, minor, args->ph)) == NULL) {

	    return (add_bus(args, di_parent_node(node),

		di_minor_next(di_parent_node(node), NULL), cp));

	}

	devpath = di_devfs_path(node);

	if ((bp = find_bus(args, devpath)) != NULL) {

	    di_devfs_path_free((void *) devpath);

	    if (cp != NULL) {

		if (add_ptr2array(cp, (void ***)&bp->controllers) != 0) {

		    args->dev_walk_status = ENOMEM;

		    return (NULL);

		}

	    }

	    return (bp);

	}

	/* Special handling for root node. */

	if (strcmp(devpath, "/") == 0) {

	    di_devfs_path_free((void *) devpath);

	    return (NULL);

	}

	if (dm_debug) {

	    (void) fprintf(stderr, "INFO: add_bus %s\n", devpath);

	}

	bp = (bus_t *)calloc(1, sizeof (bus_t));

	if (bp == NULL) {

	    return (NULL);

	}

	bp->name = strdup(devpath);

	di_devfs_path_free((void *) devpath);

	if (bp->name == NULL) {

	    args->dev_walk_status = ENOMEM;

	    cache_free_bus(bp);

	    return (NULL);

	}

	bp->btype = strdup(btype);

	if (bp->btype == NULL) {

	    args->dev_walk_status = ENOMEM;

	    cache_free_bus(bp);

	    return (NULL);

	}

	(void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",

	    di_node_name(node), di_instance(node));

	if ((bp->kstat_name = strdup(kstat_name)) == NULL) {

	    args->dev_walk_status = ENOMEM;

	    cache_free_bus(bp);

	    return (NULL);

	}

	/* if parent node is a bus, get its name */

	if ((pnode = get_parent_bus(node, args)) != NULL) {

	    devpath = di_devfs_path(pnode);

	    bp->pname = strdup(devpath);

	    di_devfs_path_free((void *) devpath);

	    if (bp->pname == NULL) {

		args->dev_walk_status = ENOMEM;

		cache_free_bus(bp);

		return (NULL);

	    }

	} else {

	    bp->pname = NULL;

	}

	bp->freq = get_prom_int("clock-frequency", node, args->ph);

	bp->controllers = (controller_t **)calloc(1, sizeof (controller_t *));

	if (bp->controllers == NULL) {

	    args->dev_walk_status = ENOMEM;

	    cache_free_bus(bp);

	    return (NULL);

	}

	bp->controllers[0] = NULL;

	if (cp != NULL) {

	    if (add_ptr2array(cp, (void ***)&bp->controllers) != 0) {

		args->dev_walk_status = ENOMEM;

		return (NULL);

	    }

	}

	bp->next = args->bus_listp;

	args->bus_listp = bp;

	return (bp);

}

static int

add_cluster_devs(di_node_t node, di_minor_t minor, void *arg)

{

	struct search_args	*args;

	char			*devpath;

	char			slice_path[MAXPATHLEN];

	int			result = DI_WALK_CONTINUE;

	if (!is_cluster_disk(node, minor)) {

	    return (DI_WALK_CONTINUE);

	}

	args = (struct search_args *)arg;

	if (dm_debug > 1) {

	    /* This is all just debugging code */

	    char	*devpath;

	    char	dev_name[MAXPATHLEN];

	    devpath = di_devfs_path(node);

	    (void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,

		di_minor_name(minor));

	    di_devfs_path_free((void *) devpath);

	    (void) fprintf(stderr, "INFO: cluster dev: %s\n", dev_name);

	}

	args->node = node;

	args->minor = minor;

	args->dev_walk_status = 0;

	/*

	 * Fix the devpaths for the cluster drive.

	 *

	 * We will come through here once for each raw slice device name.

	 */

	devpath = di_devfs_path(node);

	(void) snprintf(slice_path, sizeof (slice_path), "%s:%s", devpath,

	    di_minor_name(minor));

	di_devfs_path_free((void *) devpath);

	/* Walk the /dev tree to get the cluster devlinks. */

	(void) di_devlink_walk(args->handle, DEVLINK_DID_REGEX, slice_path,

	    DI_PRIMARY_LINK, arg, fix_cluster_devpath);

	if (args->dev_walk_status != 0) {

	    result = DI_WALK_TERMINATE;

	}

	return (result);

}

static controller_t *

add_controller(struct search_args *args, di_node_t node, di_minor_t minor)

{

	char		*devpath;

	controller_t	*cp;

	char		kstat_name[MAXPATHLEN];

	char		*c_type = DM_CTYPE_UNKNOWN;

	devpath = di_devfs_path(node);

	if ((cp = find_controller(args, devpath)) != NULL) {

	    di_devfs_path_free((void *) devpath);

	    return (cp);

	}

	/* Special handling for fp attachment node. */

	if (strcmp(di_node_name(node), "fp") == 0) {

	    di_node_t pnode;

	    pnode = di_parent_node(node);

	    if (pnode != DI_NODE_NIL) {

		di_devfs_path_free((void *) devpath);

		devpath = di_devfs_path(pnode);

		if ((cp = find_controller(args, devpath)) != NULL) {

		    di_devfs_path_free((void *) devpath);

		    return (cp);

		}

		/* not in the list, create it */

		node = pnode;

		c_type = DM_CTYPE_FIBRE;

	    }

	}

	if (dm_debug) {

	    (void) fprintf(stderr, "INFO: add_controller %s\n", devpath);

	}

	cp = (controller_t *)calloc(1, sizeof (controller_t));

	if (cp == NULL) {

	    return (NULL);

	}

	cp->name = strdup(devpath);

	di_devfs_path_free((void *) devpath);

	if (cp->name == NULL) {

	    cache_free_controller(cp);

	    return (NULL);

	}

	if (strcmp(c_type, DM_CTYPE_UNKNOWN) == 0) {

	    c_type = ctype(node, minor);

	}

	cp->ctype = c_type;

	(void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",

	    di_node_name(node), di_instance(node));

	if ((cp->kstat_name = strdup(kstat_name)) == NULL) {

	    cache_free_controller(cp);

	    return (NULL);

	}

	if (libdiskmgt_str_eq(cp->ctype, "scsi")) {

	    cp->scsi_options = get_prop(SCSI_OPTIONS_PROP, node);

	}

	if (libdiskmgt_str_eq(di_node_name(node), "scsi_vhci")) {

	    cp->multiplex = 1;

	} else {

	    cp->multiplex = 0;

	}

	cp->freq = get_prom_int("clock-frequency", node, args->ph);

	cp->disks = (disk_t **)calloc(1, sizeof (disk_t *));

	if (cp->disks == NULL) {

	    cache_free_controller(cp);

	    return (NULL);

	}

	cp->disks[0] = NULL;

	cp->next = args->controller_listp;

	args->controller_listp = cp;

	cp->bus = add_bus(args, di_parent_node(node),

	    di_minor_next(di_parent_node(node), NULL), cp);

	return (cp);

}

static int

add_devpath(di_devlink_t devlink, void *arg)

{

	struct search_args *args;

	char		*devidstr;

	disk_t		*diskp;

	char		kernel_name[MAXPATHLEN];

	args =	(struct search_args *)arg;

	/*

	 * Get the diskp value from calling have_disk. Can either be found

	 * by kernel name or devid.

	 */

	diskp = NULL;

	devidstr = get_str_prop(DEVICE_ID_PROP, args->node);

	(void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",

	    di_node_name(args->node), di_instance(args->node));

	(void) have_disk(args, devidstr, kernel_name, &diskp);

	/*

	 * The devlink_path is usually of the form /dev/rdsk/c0t0d0s0.

	 * For diskettes it is /dev/rdiskette*.

	 * On Intel we would also get each fdisk partition as well

	 * (e.g. /dev/rdsk/c0t0d0p0).

	 */

	if (diskp != NULL) {

	    alias_t	*ap;

	    char	*devlink_path;

	    if (diskp->drv_type != DM_DT_FLOPPY) {

		/*

		 * Add other controllers for multipath disks.  This will have

		 * no effect if the controller relationship is already set up.

		 */

		if (add_disk2controller(diskp, args) != 0) {

		    args->dev_walk_status = ENOMEM;

		}

	    }

	    (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",

		di_node_name(args->node), di_instance(args->node));

	    devlink_path = (char *)di_devlink_path(devlink);

	    if (dm_debug > 1) {

		(void) fprintf(stderr, "INFO:     devpath %s\n", devlink_path);

	    }

	    if ((ap = find_alias(diskp, kernel_name)) == NULL) {

		if (new_alias(diskp, kernel_name, devlink_path, args) != 0) {

		    args->dev_walk_status = ENOMEM;

		}

	    } else {

		/*

		 * It is possible that we have already added this devpath.

		 * Do not add it again. new_devpath will return a 0 if

		 * found, and not add the path.

		 */

		if (new_devpath(ap, devlink_path) != 0) {

		    args->dev_walk_status = ENOMEM;

		}