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 * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A#include <fcntl.h>
2N/A#include <libdevinfo.h>
2N/A#include <stdio.h>
2N/A#include <stdlib.h>
2N/A#include <string.h>
2N/A#include <sys/stat.h>
2N/A#include <sys/sunddi.h>
2N/A#include <sys/types.h>
2N/A#include <sys/mkdev.h>
2N/A#include <ctype.h>
2N/A#include <libgen.h>
2N/A#include <unistd.h>
2N/A#include <devid.h>
2N/A#include <sys/fs/zfs.h>
2N/A#include <strings.h>
2N/A
2N/A#include "libdiskmgt.h"
2N/A#include "disks_private.h"
2N/A
2N/A#define CLUSTER_DEV "did"
2N/A
2N/A/* specify which disk links to use in the /dev directory */
2N/A#define DEVLINK_REGEX "rdsk/.*"
2N/A#define DEVLINK_FLOPPY_REGEX "rdiskette[0-9]"
2N/A#define DEVLINK_DID_REGEX "did/rdsk/.*"
2N/A
2N/A#define FLOPPY_NAME "rdiskette"
2N/A
2N/A#define MAXPROPLEN 1024
2N/A#define DEVICE_ID_PROP "devid"
2N/A#define PROD_ID_PROP "inquiry-product-id"
2N/A#define PROD_ID_USB_PROP "usb-product-name"
2N/A#define REMOVABLE_PROP "removable-media"
2N/A#define HOTPLUGGABLE_PROP "hotpluggable"
2N/A#define SCSI_OPTIONS_PROP "scsi-options"
2N/A#define VENDOR_ID_PROP "inquiry-vendor-id"
2N/A#define VENDOR_ID_USB_PROP "usb-vendor-name"
2N/A#define WWN_PROP "node-wwn"
2N/A
2N/Astatic char *ctrltypes[] = {
2N/A DDI_NT_SCSI_NEXUS,
2N/A DDI_NT_SCSI_ATTACHMENT_POINT,
2N/A DDI_NT_FC_ATTACHMENT_POINT,
2N/A NULL
2N/A};
2N/A
2N/Astatic char *bustypes[] = {
2N/A "sbus",
2N/A "pci",
2N/A "usb",
2N/A NULL
2N/A};
2N/A
2N/Astatic bus_t *add_bus(struct search_args *args, di_node_t node,
2N/A di_minor_t minor, controller_t *cp);
2N/Astatic int add_cluster_devs(di_node_t node, di_minor_t minor,
2N/A void *arg);
2N/Astatic controller_t *add_controller(struct search_args *args,
2N/A di_node_t node, di_minor_t minor);
2N/Astatic int add_devpath(di_devlink_t devlink, void *arg);
2N/Astatic int add_devs(di_node_t node, di_minor_t minor, void *arg);
2N/Astatic int add_disk2controller(disk_t *diskp,
2N/A struct search_args *args);
2N/Astatic int add_disk2path(disk_t *dp, path_t *pp,
2N/A di_path_state_t st, char *wwn);
2N/Astatic int add_int2array(int p, int **parray);
2N/Astatic int add_ptr2array(void *p, void ***parray);
2N/Astatic char *bus_type(di_node_t node, di_minor_t minor,
2N/A di_prom_handle_t ph);
2N/Astatic void clean_paths(struct search_args *args);
2N/Astatic disk_t *create_disk(char *deviceid, char *kernel_name,
2N/A struct search_args *args);
2N/Astatic char *ctype(di_node_t node, di_minor_t minor);
2N/Astatic boolean_t disk_is_cdrom(const char *type);
2N/Astatic alias_t *find_alias(disk_t *diskp, char *kernel_name);
2N/Astatic bus_t *find_bus(struct search_args *args, char *name);
2N/Astatic controller_t *find_controller(struct search_args *args, char *name);
2N/Astatic int fix_cluster_devpath(di_devlink_t devlink, void *arg);
2N/Astatic disk_t *get_disk_by_deviceid(disk_t *listp, char *devid);
2N/Astatic void get_disk_name_from_path(char *path, char *name,
2N/A int size);
2N/Astatic char *get_byte_prop(char *prop_name, di_node_t node);
2N/Astatic di_node_t get_parent_bus(di_node_t node,
2N/A struct search_args *args);
2N/Astatic int get_prom_int(char *prop_name, di_node_t node,
2N/A di_prom_handle_t ph);
2N/Astatic char *get_prom_str(char *prop_name, di_node_t node,
2N/A di_prom_handle_t ph);
2N/Astatic int get_prop(char *prop_name, di_node_t node);
2N/Astatic char *get_str_prop(char *prop_name, di_node_t node);
2N/Astatic int have_disk(struct search_args *args, char *devid,
2N/A char *kernel_name, disk_t **diskp);
2N/Astatic int is_cluster_disk(di_node_t node, di_minor_t minor);
2N/Astatic int is_ctds(char *name);
2N/Astatic int is_drive(di_minor_t minor);
2N/Astatic int is_zvol(di_node_t node, di_minor_t minor);
2N/Astatic int is_HBA(di_node_t node, di_minor_t minor);
2N/Astatic int new_alias(disk_t *diskp, char *kernel_path,
2N/A char *devlink_path, struct search_args *args);
2N/Astatic int new_devpath(alias_t *ap, char *devpath);
2N/Astatic path_t *new_path(controller_t *cp, disk_t *diskp,
2N/A di_node_t node, di_path_state_t st, char *wwn);
2N/Astatic void remove_controller_reference(char *name,
2N/A controller_t **ctra);
2N/Astatic void remove_invalid_controller(char *name,
2N/A controller_t *currp, struct search_args *args);
2N/Astatic char *str_case_index(register char *s1, register char *s2);
2N/A
2N/A/*
2N/A * The functions in this file do a dev tree walk to build up a model of the
2N/A * disks, controllers and paths on the system. This model is returned in the
2N/A * args->disk_listp and args->controller_listp members of the args param.
2N/A * There is no global data for this file so it is thread safe. It is up to
2N/A * the caller to merge the resulting model with any existing model that is
2N/A * cached. The caller must also free the memory for this model when it is
2N/A * no longer needed.
2N/A */
2N/Avoid
2N/Afindevs(struct search_args *args)
2N/A{
2N/A uint_t flags;
2N/A di_node_t di_root;
2N/A
2N/A args->dev_walk_status = 0;
2N/A args->disk_listp = NULL;
2N/A args->controller_listp = NULL;
2N/A args->bus_listp = NULL;
2N/A
2N/A args->handle = di_devlink_init(NULL, 0);
2N/A
2N/A /*
2N/A * Have to make several passes at this with the new devfs caching.
2N/A * First, we find non-mpxio devices. Then we find mpxio/multipath
2N/A * devices. Finally, we get cluster devices.
2N/A */
2N/A flags = DINFOCACHE;
2N/A di_root = di_init("/", flags);
2N/A args->ph = di_prom_init();
2N/A (void) di_walk_minor(di_root, NULL, 0, args, add_devs);
2N/A di_fini(di_root);
2N/A
2N/A flags = DINFOCPYALL | DINFOPATH;
2N/A di_root = di_init("/", flags);
2N/A (void) di_walk_minor(di_root, NULL, 0, args, add_devs);
2N/A di_fini(di_root);
2N/A
2N/A /* do another pass to clean up cluster devpaths */
2N/A flags = DINFOCACHE;
2N/A di_root = di_init("/", flags);
2N/A (void) di_walk_minor(di_root, DDI_PSEUDO, 0, args, add_cluster_devs);
2N/A if (args->ph != DI_PROM_HANDLE_NIL) {
2N/A (void) di_prom_fini(args->ph);
2N/A }
2N/A di_fini(di_root);
2N/A
2N/A (void) di_devlink_fini(&(args->handle));
2N/A
2N/A clean_paths(args);
2N/A}
2N/A
2N/A/*
2N/A * Definitions of private functions
2N/A */
2N/A
2N/Astatic bus_t *
2N/Aadd_bus(struct search_args *args, di_node_t node, di_minor_t minor,
2N/A controller_t *cp)
2N/A{
2N/A char *btype;
2N/A char *devpath;
2N/A bus_t *bp;
2N/A char kstat_name[MAXPATHLEN];
2N/A di_node_t pnode;
2N/A
2N/A if (node == DI_NODE_NIL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A if ((btype = bus_type(node, minor, args->ph)) == NULL) {
2N/A return (add_bus(args, di_parent_node(node),
2N/A di_minor_next(di_parent_node(node), NULL), cp));
2N/A }
2N/A
2N/A devpath = di_devfs_path(node);
2N/A
2N/A if ((bp = find_bus(args, devpath)) != NULL) {
2N/A di_devfs_path_free((void *) devpath);
2N/A
2N/A if (cp != NULL) {
2N/A if (add_ptr2array(cp,
2N/A (void ***)&bp->controllers) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A return (NULL);
2N/A }
2N/A }
2N/A return (bp);
2N/A }
2N/A
2N/A /* Special handling for root node. */
2N/A if (strcmp(devpath, "/") == 0) {
2N/A di_devfs_path_free((void *) devpath);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (dm_debug) {
2N/A (void) fprintf(stderr, "INFO: add_bus %s\n", devpath);
2N/A }
2N/A
2N/A bp = (bus_t *)calloc(1, sizeof (bus_t));
2N/A if (bp == NULL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A bp->name = strdup(devpath);
2N/A di_devfs_path_free((void *) devpath);
2N/A if (bp->name == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A cache_free_bus(bp);
2N/A return (NULL);
2N/A }
2N/A
2N/A bp->btype = strdup(btype);
2N/A if (bp->btype == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A cache_free_bus(bp);
2N/A return (NULL);
2N/A }
2N/A
2N/A (void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",
2N/A di_node_name(node), di_instance(node));
2N/A
2N/A if ((bp->kstat_name = strdup(kstat_name)) == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A cache_free_bus(bp);
2N/A return (NULL);
2N/A }
2N/A
2N/A /* if parent node is a bus, get its name */
2N/A if ((pnode = get_parent_bus(node, args)) != NULL) {
2N/A devpath = di_devfs_path(pnode);
2N/A bp->pname = strdup(devpath);
2N/A di_devfs_path_free((void *) devpath);
2N/A if (bp->pname == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A cache_free_bus(bp);
2N/A return (NULL);
2N/A }
2N/A
2N/A } else {
2N/A bp->pname = NULL;
2N/A }
2N/A
2N/A bp->freq = get_prom_int("clock-frequency", node, args->ph);
2N/A
2N/A bp->controllers = (controller_t **)calloc(1, sizeof (controller_t *));
2N/A if (bp->controllers == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A cache_free_bus(bp);
2N/A return (NULL);
2N/A }
2N/A bp->controllers[0] = NULL;
2N/A
2N/A if (cp != NULL) {
2N/A if (add_ptr2array(cp, (void ***)&bp->controllers) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A bp->next = args->bus_listp;
2N/A args->bus_listp = bp;
2N/A
2N/A return (bp);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_cluster_devs(di_node_t node, di_minor_t minor, void *arg)
2N/A{
2N/A struct search_args *args;
2N/A char *devpath;
2N/A char slice_path[MAXPATHLEN];
2N/A int result = DI_WALK_CONTINUE;
2N/A
2N/A if (!is_cluster_disk(node, minor)) {
2N/A return (DI_WALK_CONTINUE);
2N/A }
2N/A
2N/A args = (struct search_args *)arg;
2N/A
2N/A if (dm_debug > 1) {
2N/A /* This is all just debugging code */
2N/A char *devpath;
2N/A char dev_name[MAXPATHLEN];
2N/A
2N/A devpath = di_devfs_path(node);
2N/A (void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
2N/A di_minor_name(minor));
2N/A di_devfs_path_free((void *) devpath);
2N/A
2N/A (void) fprintf(stderr, "INFO: cluster dev: %s\n", dev_name);
2N/A }
2N/A
2N/A args->node = node;
2N/A args->minor = minor;
2N/A args->dev_walk_status = 0;
2N/A
2N/A /*
2N/A * Fix the devpaths for the cluster drive.
2N/A *
2N/A * We will come through here once for each raw slice device name.
2N/A */
2N/A devpath = di_devfs_path(node);
2N/A (void) snprintf(slice_path, sizeof (slice_path), "%s:%s", devpath,
2N/A di_minor_name(minor));
2N/A di_devfs_path_free((void *) devpath);
2N/A
2N/A /* Walk the /dev tree to get the cluster devlinks. */
2N/A (void) di_devlink_walk(args->handle, DEVLINK_DID_REGEX, slice_path,
2N/A DI_PRIMARY_LINK, arg, fix_cluster_devpath);
2N/A
2N/A if (args->dev_walk_status != 0) {
2N/A result = DI_WALK_TERMINATE;
2N/A }
2N/A
2N/A return (result);
2N/A}
2N/A
2N/Astatic controller_t *
2N/Aadd_controller(struct search_args *args, di_node_t node, di_minor_t minor)
2N/A{
2N/A char *devpath;
2N/A controller_t *cp;
2N/A char kstat_name[MAXPATHLEN];
2N/A char *c_type = DM_CTYPE_UNKNOWN;
2N/A
2N/A devpath = di_devfs_path(node);
2N/A
2N/A if ((cp = find_controller(args, devpath)) != NULL) {
2N/A di_devfs_path_free((void *) devpath);
2N/A return (cp);
2N/A }
2N/A
2N/A /* Special handling for fp attachment node. */
2N/A if (strcmp(di_node_name(node), "fp") == 0) {
2N/A di_node_t pnode;
2N/A
2N/A pnode = di_parent_node(node);
2N/A if (pnode != DI_NODE_NIL) {
2N/A di_devfs_path_free((void *) devpath);
2N/A devpath = di_devfs_path(pnode);
2N/A
2N/A if ((cp = find_controller(args, devpath)) != NULL) {
2N/A di_devfs_path_free((void *) devpath);
2N/A return (cp);
2N/A }
2N/A
2N/A /* not in the list, create it */
2N/A node = pnode;
2N/A c_type = DM_CTYPE_FIBRE;
2N/A }
2N/A }
2N/A
2N/A if (dm_debug) {
2N/A (void) fprintf(stderr, "INFO: add_controller %s\n", devpath);
2N/A }
2N/A
2N/A cp = (controller_t *)calloc(1, sizeof (controller_t));
2N/A if (cp == NULL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A cp->name = strdup(devpath);
2N/A di_devfs_path_free((void *) devpath);
2N/A if (cp->name == NULL) {
2N/A cache_free_controller(cp);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (strcmp(c_type, DM_CTYPE_UNKNOWN) == 0) {
2N/A c_type = ctype(node, minor);
2N/A }
2N/A cp->ctype = c_type;
2N/A
2N/A (void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",
2N/A di_node_name(node), di_instance(node));
2N/A
2N/A if ((cp->kstat_name = strdup(kstat_name)) == NULL) {
2N/A cache_free_controller(cp);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(cp->ctype, "scsi")) {
2N/A cp->scsi_options = get_prop(SCSI_OPTIONS_PROP, node);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(di_node_name(node), "scsi_vhci")) {
2N/A cp->multiplex = 1;
2N/A } else {
2N/A cp->multiplex = 0;
2N/A }
2N/A
2N/A cp->freq = get_prom_int("clock-frequency", node, args->ph);
2N/A
2N/A cp->disks = (disk_t **)calloc(1, sizeof (disk_t *));
2N/A if (cp->disks == NULL) {
2N/A cache_free_controller(cp);
2N/A return (NULL);
2N/A }
2N/A cp->disks[0] = NULL;
2N/A
2N/A cp->next = args->controller_listp;
2N/A args->controller_listp = cp;
2N/A
2N/A cp->bus = add_bus(args, di_parent_node(node),
2N/A di_minor_next(di_parent_node(node), NULL), cp);
2N/A
2N/A return (cp);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_devpath(di_devlink_t devlink, void *arg)
2N/A{
2N/A struct search_args *args;
2N/A char *devidstr;
2N/A disk_t *diskp;
2N/A char kernel_name[MAXPATHLEN];
2N/A
2N/A args = (struct search_args *)arg;
2N/A
2N/A /*
2N/A * Get the diskp value from calling have_disk. Can either be found
2N/A * by kernel name or devid.
2N/A */
2N/A
2N/A diskp = NULL;
2N/A devidstr = get_str_prop(DEVICE_ID_PROP, args->node);
2N/A (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
2N/A di_node_name(args->node), di_instance(args->node));
2N/A
2N/A (void) have_disk(args, devidstr, kernel_name, &diskp);
2N/A
2N/A /*
2N/A * The devlink_path is usually of the form /dev/rdsk/c0t0d0s0.
2N/A * For diskettes it is /dev/rdiskette*.
2N/A * On Intel we would also get each fdisk partition as well
2N/A * (e.g. /dev/rdsk/c0t0d0p0).
2N/A */
2N/A if (diskp != NULL) {
2N/A alias_t *ap;
2N/A char *devlink_path;
2N/A
2N/A if (diskp->drv_type != DM_DT_FLOPPY) {
2N/A /*
2N/A * Add other controllers for multipath disks.
2N/A * This will have no effect if the controller
2N/A * relationship is already set up.
2N/A */
2N/A if (add_disk2controller(diskp, args) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A }
2N/A
2N/A (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
2N/A di_node_name(args->node), di_instance(args->node));
2N/A devlink_path = (char *)di_devlink_path(devlink);
2N/A
2N/A if (dm_debug > 1) {
2N/A (void) fprintf(stderr,
2N/A "INFO: devpath %s\n", devlink_path);
2N/A }
2N/A
2N/A if ((ap = find_alias(diskp, kernel_name)) == NULL) {
2N/A if (new_alias(diskp, kernel_name, devlink_path,
2N/A args) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A } else {
2N/A /*
2N/A * It is possible that we have already added this
2N/A * devpath. Do not add it again. new_devpath will
2N/A * return a 0 if found, and not add the path.
2N/A */
2N/A if (new_devpath(ap, devlink_path) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A }
2N/A }
2N/A
2N/A return (DI_WALK_CONTINUE);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_devs(di_node_t node, di_minor_t minor, void *arg)
2N/A{
2N/A struct search_args *args;
2N/A int result = DI_WALK_CONTINUE;
2N/A
2N/A args = (struct search_args *)arg;
2N/A
2N/A if (dm_debug > 1) {
2N/A /* This is all just debugging code */
2N/A char *devpath;
2N/A char dev_name[MAXPATHLEN];
2N/A
2N/A devpath = di_devfs_path(node);
2N/A (void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
2N/A di_minor_name(minor));
2N/A di_devfs_path_free((void *) devpath);
2N/A
2N/A (void) fprintf(stderr,
2N/A "INFO: dev: %s, node: %s%d, minor: 0x%x, type: %s\n",
2N/A dev_name, di_node_name(node), di_instance(node),
2N/A di_minor_spectype(minor),
2N/A (di_minor_nodetype(minor) != NULL ?
2N/A di_minor_nodetype(minor) : "NULL"));
2N/A }
2N/A
2N/A if (bus_type(node, minor, args->ph) != NULL) {
2N/A if (add_bus(args, node, minor, NULL) == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A result = DI_WALK_TERMINATE;
2N/A }
2N/A
2N/A } else if (is_HBA(node, minor)) {
2N/A if (add_controller(args, node, minor) == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A result = DI_WALK_TERMINATE;
2N/A }
2N/A
2N/A } else if (di_minor_spectype(minor) == S_IFCHR &&
2N/A (is_drive(minor) || is_zvol(node, minor))) {
2N/A char *devidstr;
2N/A char kernel_name[MAXPATHLEN];
2N/A disk_t *diskp;
2N/A
2N/A (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
2N/A di_node_name(node), di_instance(node));
2N/A devidstr = get_str_prop(DEVICE_ID_PROP, node);
2N/A
2N/A args->node = node;
2N/A args->minor = minor;
2N/A /*
2N/A * Check if we already got this disk and
2N/A * this is another slice.
2N/A */
2N/A if (!have_disk(args, devidstr, kernel_name, &diskp)) {
2N/A args->dev_walk_status = 0;
2N/A /*
2N/A * This is a newly found disk, create the
2N/A * disk structure.
2N/A */
2N/A diskp = create_disk(devidstr, kernel_name, args);
2N/A if (diskp == NULL) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A
2N/A if (diskp->drv_type != DM_DT_FLOPPY) {
2N/A /* add the controller relationship */
2N/A if (args->dev_walk_status == 0) {
2N/A if (add_disk2controller(diskp,
2N/A args) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A }
2N/A }
2N/A }
2N/A if (is_zvol(node, minor)) {
2N/A char zvdsk[MAXNAMELEN];
2N/A char *str;
2N/A alias_t *ap;
2N/A
2N/A if (di_prop_lookup_strings(di_minor_devt(minor),
2N/A node, "name", &str) == -1)
2N/A return (DI_WALK_CONTINUE);
2N/A (void) snprintf(zvdsk, MAXNAMELEN, "/dev/zvol/rdsk/%s",
2N/A str);
2N/A if ((ap = find_alias(diskp, kernel_name)) == NULL) {
2N/A if (new_alias(diskp, kernel_name,
2N/A zvdsk, args) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A } else {
2N/A /*
2N/A * It is possible that we have already added
2N/A * this devpath.
2N/A * Do not add it again. new_devpath will
2N/A * return a 0 if found, and not add the path.
2N/A */
2N/A if (new_devpath(ap, zvdsk) != 0) {
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A }
2N/A }
2N/A
2N/A /* Add the devpaths for the drive. */
2N/A if (args->dev_walk_status == 0) {
2N/A char *devpath;
2N/A char slice_path[MAXPATHLEN];
2N/A char *pattern;
2N/A
2N/A /*
2N/A * We will come through here once for each of
2N/A * the raw slice device names.
2N/A */
2N/A devpath = di_devfs_path(node);
2N/A (void) snprintf(slice_path,
2N/A sizeof (slice_path), "%s:%s",
2N/A devpath, di_minor_name(minor));
2N/A di_devfs_path_free((void *) devpath);
2N/A
2N/A if (libdiskmgt_str_eq(di_minor_nodetype(minor),
2N/A DDI_NT_FD)) {
2N/A pattern = DEVLINK_FLOPPY_REGEX;
2N/A } else {
2N/A pattern = DEVLINK_REGEX;
2N/A }
2N/A
2N/A /* Walk the /dev tree to get the devlinks. */
2N/A (void) di_devlink_walk(args->handle, pattern,
2N/A slice_path, DI_PRIMARY_LINK, arg, add_devpath);
2N/A }
2N/A
2N/A if (args->dev_walk_status != 0) {
2N/A result = DI_WALK_TERMINATE;
2N/A }
2N/A }
2N/A
2N/A return (result);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_disk2controller(disk_t *diskp, struct search_args *args)
2N/A{
2N/A di_node_t pnode;
2N/A controller_t *cp;
2N/A di_minor_t minor;
2N/A di_node_t node;
2N/A int i;
2N/A
2N/A node = args->node;
2N/A
2N/A pnode = di_parent_node(node);
2N/A if (pnode == DI_NODE_NIL) {
2N/A return (0);
2N/A }
2N/A
2N/A minor = di_minor_next(pnode, NULL);
2N/A if (minor == NULL) {
2N/A return (0);
2N/A }
2N/A
2N/A if ((cp = add_controller(args, pnode, minor)) == NULL) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A /* check if the disk <-> ctrl assoc is already there */
2N/A for (i = 0; diskp->controllers[i]; i++) {
2N/A if (cp == diskp->controllers[i]) {
2N/A return (0);
2N/A }
2N/A }
2N/A
2N/A /* this is a new controller for this disk */
2N/A
2N/A /* add the disk to the controlller */
2N/A if (add_ptr2array(diskp, (void ***)&cp->disks) != 0) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A /* add the controlller to the disk */
2N/A if (add_ptr2array(cp, (void ***)&diskp->controllers) != 0) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A /*
2N/A * Set up paths for mpxio controlled drives.
2N/A */
2N/A if (libdiskmgt_str_eq(di_node_name(pnode), "scsi_vhci")) {
2N/A /* note: mpxio di_path stuff is all consolidation private */
2N/A di_path_t pi = DI_PATH_NIL;
2N/A
2N/A while (
2N/A (pi = di_path_client_next_path(node, pi)) != DI_PATH_NIL) {
2N/A int cnt;
2N/A uchar_t *bytes;
2N/A char str[MAXPATHLEN];
2N/A char *wwn;
2N/A
2N/A di_node_t phci_node = di_path_phci_node(pi);
2N/A
2N/A /* get the node wwn */
2N/A cnt = di_path_prop_lookup_bytes(pi, WWN_PROP, &bytes);
2N/A wwn = NULL;
2N/A if (cnt > 0) {
2N/A int i;
2N/A str[0] = 0;
2N/A
2N/A for (i = 0; i < cnt; i++) {
2N/A /*
2N/A * A byte is only 2 hex chars + null.
2N/A */
2N/A char bstr[8];
2N/A
2N/A (void) snprintf(bstr,
2N/A sizeof (bstr), "%.2x", bytes[i]);
2N/A (void) strlcat(str, bstr, sizeof (str));
2N/A }
2N/A wwn = str;
2N/A }
2N/A
2N/A if (new_path(cp, diskp, phci_node,
2N/A di_path_state(pi), wwn) == NULL) {
2N/A return (ENOMEM);
2N/A }
2N/A }
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_disk2path(disk_t *dp, path_t *pp, di_path_state_t st, char *wwn)
2N/A{
2N/A /* add the disk to the path */
2N/A if (add_ptr2array(dp, (void ***)&pp->disks) != 0) {
2N/A cache_free_path(pp);
2N/A return (0);
2N/A }
2N/A
2N/A /* add the path to the disk */
2N/A if (add_ptr2array(pp, (void ***)&dp->paths) != 0) {
2N/A cache_free_path(pp);
2N/A return (0);
2N/A }
2N/A
2N/A /* add the path state for this disk */
2N/A if (add_int2array(st, &pp->states) != 0) {
2N/A cache_free_path(pp);
2N/A return (0);
2N/A }
2N/A
2N/A /* add the path state for this disk */
2N/A if (wwn != NULL) {
2N/A char *wp;
2N/A
2N/A if ((wp = strdup(wwn)) != NULL) {
2N/A if (add_ptr2array(wp, (void ***)(&pp->wwns)) != 0) {
2N/A cache_free_path(pp);
2N/A return (0);
2N/A }
2N/A }
2N/A }
2N/A
2N/A return (1);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_int2array(int p, int **parray)
2N/A{
2N/A int i;
2N/A int cnt;
2N/A int *pa;
2N/A int *new_array;
2N/A
2N/A pa = *parray;
2N/A
2N/A cnt = 0;
2N/A if (pa != NULL) {
2N/A for (; pa[cnt] != -1; cnt++)
2N/A ;
2N/A }
2N/A
2N/A new_array = (int *)calloc(cnt + 2, sizeof (int *));
2N/A if (new_array == NULL) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A /* copy the existing array */
2N/A for (i = 0; i < cnt; i++) {
2N/A new_array[i] = pa[i];
2N/A }
2N/A
2N/A new_array[i] = p;
2N/A new_array[i + 1] = -1;
2N/A
2N/A free(pa);
2N/A *parray = new_array;
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Astatic int
2N/Aadd_ptr2array(void *p, void ***parray)
2N/A{
2N/A int i;
2N/A int cnt;
2N/A void **pa;
2N/A void **new_array;
2N/A
2N/A pa = *parray;
2N/A
2N/A cnt = 0;
2N/A if (pa != NULL) {
2N/A for (; pa[cnt]; cnt++)
2N/A ;
2N/A }
2N/A
2N/A new_array = (void **)calloc(cnt + 2, sizeof (void *));
2N/A if (new_array == NULL) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A /* copy the existing array */
2N/A for (i = 0; i < cnt; i++) {
2N/A new_array[i] = pa[i];
2N/A }
2N/A
2N/A new_array[i] = p;
2N/A new_array[i + 1] = NULL;
2N/A
2N/A free(pa);
2N/A *parray = new_array;
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * If we have a controller in the list that is really a path then we need to
2N/A * take that controller out of the list since nodes that are paths are not
2N/A * considered to be controllers.
2N/A */
2N/Astatic void
2N/Aclean_paths(struct search_args *args)
2N/A{
2N/A controller_t *cp;
2N/A
2N/A for (cp = args->controller_listp; cp != NULL; cp = cp->next) {
2N/A path_t **pp;
2N/A
2N/A for (pp = cp->paths; pp && *pp; pp++)
2N/A remove_invalid_controller((*pp)->name, cp, args);
2N/A }
2N/A}
2N/A
2N/Astatic disk_t *
2N/Acreate_disk(char *deviceid, char *kernel_name, struct search_args *args)
2N/A{
2N/A disk_t *diskp;
2N/A char *type;
2N/A char *prod_id;
2N/A char *vendor_id;
2N/A
2N/A if (dm_debug) {
2N/A (void) fprintf(stderr, "INFO: create_disk %s\n", kernel_name);
2N/A }
2N/A
2N/A diskp = calloc(1, sizeof (disk_t));
2N/A if (diskp == NULL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A diskp->controllers = (controller_t **)
2N/A calloc(1, sizeof (controller_t *));
2N/A if (diskp->controllers == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A diskp->controllers[0] = NULL;
2N/A
2N/A diskp->devid = NULL;
2N/A if (deviceid != NULL) {
2N/A if ((diskp->device_id = strdup(deviceid)) == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A (void) devid_str_decode(deviceid, &(diskp->devid), NULL);
2N/A }
2N/A
2N/A if (kernel_name != NULL) {
2N/A diskp->kernel_name = strdup(kernel_name);
2N/A if (diskp->kernel_name == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A diskp->paths = NULL;
2N/A diskp->aliases = NULL;
2N/A
2N/A diskp->cd_rom = 0;
2N/A diskp->rpm = 0;
2N/A type = di_minor_nodetype(args->minor);
2N/A
2N/A prod_id = get_str_prop(PROD_ID_PROP, args->node);
2N/A if (prod_id != NULL) {
2N/A if ((diskp->product_id = strdup(prod_id)) == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A } else {
2N/A prod_id = get_str_prop(PROD_ID_USB_PROP, args->node);
2N/A if (prod_id != NULL) {
2N/A if ((diskp->product_id = strdup(prod_id)) == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A }
2N/A }
2N/A
2N/A vendor_id = get_str_prop(VENDOR_ID_PROP, args->node);
2N/A if (vendor_id != NULL) {
2N/A if ((diskp->vendor_id = strdup(vendor_id)) == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A } else {
2N/A vendor_id = get_str_prop(VENDOR_ID_PROP, args->node);
2N/A if (vendor_id != NULL) {
2N/A if ((diskp->vendor_id = strdup(vendor_id)) == NULL) {
2N/A cache_free_disk(diskp);
2N/A return (NULL);
2N/A }
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * DVD, CD-ROM, CD-RW, MO, etc. are all reported as CD-ROMS.
2N/A * We try to use uscsi later to determine the real type.
2N/A * The cd_rom flag tells us that the kernel categorized the drive
2N/A * as a CD-ROM. We leave the drv_type as UKNOWN for now.
2N/A * The combination of the cd_rom flag being set with the drv_type of
2N/A * unknown is what triggers the uscsi probe in drive.c.
2N/A */
2N/A if (disk_is_cdrom(type)) {
2N/A diskp->drv_type = DM_DT_UNKNOWN;
2N/A diskp->cd_rom = 1;
2N/A diskp->removable = 1;
2N/A } else if (libdiskmgt_str_eq(type, DDI_NT_FD)) {
2N/A diskp->drv_type = DM_DT_FLOPPY;
2N/A diskp->removable = 1;
2N/A } else {
2N/A /* not a "CD-ROM" or Floppy */
2N/A diskp->removable = get_prop(REMOVABLE_PROP, args->node);
2N/A
2N/A if (diskp->removable == -1) {
2N/A diskp->removable = 0;
2N/A#if defined(i386) || defined(__amd64)
2N/A /*
2N/A * x86 does not have removable property.
2N/A * Check for common removable drives, zip & jaz,
2N/A * and mark those correctly.
2N/A */
2N/A if (vendor_id != NULL && prod_id != NULL) {
2N/A if (str_case_index(vendor_id,
2N/A "iomega") != NULL) {
2N/A if (str_case_index(prod_id,
2N/A "jaz") != NULL) {
2N/A diskp->removable = 1;
2N/A } else if (str_case_index(prod_id,
2N/A "zip") != NULL) {
2N/A diskp->removable = 1;
2N/A }
2N/A }
2N/A }
2N/A#endif
2N/A }
2N/A
2N/A if (diskp->removable) {
2N/A /*
2N/A * For removable jaz or zip drives there is no way
2N/A * to get the drive type unless media is inserted,so
2N/A * we look at the product-id for a hint.
2N/A */
2N/A diskp->drv_type = DM_DT_UNKNOWN;
2N/A
2N/A if (prod_id != NULL) {
2N/A if (str_case_index(prod_id, "jaz") != NULL) {
2N/A diskp->drv_type = DM_DT_JAZ;
2N/A } else if (str_case_index(prod_id,
2N/A "zip") != NULL) {
2N/A diskp->drv_type = DM_DT_ZIP;
2N/A }
2N/A }
2N/A } else {
2N/A diskp->drv_type = DM_DT_FIXED;
2N/A }
2N/A }
2N/A
2N/A diskp->next = args->disk_listp;
2N/A args->disk_listp = diskp;
2N/A
2N/A return (diskp);
2N/A}
2N/A
2N/Astatic char *
2N/Actype(di_node_t node, di_minor_t minor)
2N/A{
2N/A char *type;
2N/A char *name;
2N/A
2N/A type = di_minor_nodetype(minor);
2N/A name = di_node_name(node);
2N/A
2N/A /* IDE disks use SCSI nexus as the type, so handle this special case */
2N/A if (libdiskmgt_str_eq(name, "ide")) {
2N/A return (DM_CTYPE_ATA);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(di_minor_name(minor), "scsa2usb")) {
2N/A return (DM_CTYPE_USB);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(type, DDI_NT_SCSI_NEXUS) ||
2N/A libdiskmgt_str_eq(type, DDI_NT_SCSI_ATTACHMENT_POINT)) {
2N/A return (DM_CTYPE_SCSI);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(type, DDI_NT_FC_ATTACHMENT_POINT)) {
2N/A return (DM_CTYPE_FIBRE);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(type, DDI_NT_NEXUS) &&
2N/A libdiskmgt_str_eq(name, "fp")) {
2N/A return (DM_CTYPE_FIBRE);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(type, DDI_PSEUDO) &&
2N/A libdiskmgt_str_eq(name, "ide")) {
2N/A return (DM_CTYPE_ATA);
2N/A }
2N/A
2N/A if (libdiskmgt_str_eq(type, DDI_NT_SATA_NEXUS)) {
2N/A return (DM_CTYPE_SATA);
2N/A }
2N/A
2N/A return (DM_CTYPE_UNKNOWN);
2N/A}
2N/A
2N/Astatic boolean_t
2N/Adisk_is_cdrom(const char *type)
2N/A{
2N/A return (strncmp(type, DDI_NT_CD, strlen(DDI_NT_CD)) == 0);
2N/A}
2N/A
2N/Astatic alias_t *
2N/Afind_alias(disk_t *diskp, char *kernel_name)
2N/A{
2N/A alias_t *ap;
2N/A
2N/A ap = diskp->aliases;
2N/A while (ap != NULL) {
2N/A if (libdiskmgt_str_eq(ap->kstat_name, kernel_name)) {
2N/A return (ap);
2N/A }
2N/A ap = ap->next;
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic bus_t *
2N/Afind_bus(struct search_args *args, char *name)
2N/A{
2N/A bus_t *listp;
2N/A
2N/A listp = args->bus_listp;
2N/A while (listp != NULL) {
2N/A if (libdiskmgt_str_eq(listp->name, name)) {
2N/A return (listp);
2N/A }
2N/A listp = listp->next;
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic controller_t *
2N/Afind_controller(struct search_args *args, char *name)
2N/A{
2N/A controller_t *listp;
2N/A
2N/A listp = args->controller_listp;
2N/A while (listp != NULL) {
2N/A if (libdiskmgt_str_eq(listp->name, name)) {
2N/A return (listp);
2N/A }
2N/A listp = listp->next;
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic int
2N/Afix_cluster_devpath(di_devlink_t devlink, void *arg)
2N/A{
2N/A int fd;
2N/A struct search_args *args;
2N/A char *devlink_path;
2N/A disk_t *diskp = NULL;
2N/A alias_t *ap = NULL;
2N/A
2N/A /*
2N/A * The devlink_path is of the form /dev/did/rdsk/d1s0.
2N/A */
2N/A
2N/A args = (struct search_args *)arg;
2N/A
2N/A /* Find the disk by the deviceid we read from the cluster disk. */
2N/A devlink_path = (char *)di_devlink_path(devlink);
2N/A if (devlink_path == NULL)
2N/A return (DI_WALK_CONTINUE);
2N/A
2N/A if ((fd = open(devlink_path, O_RDONLY|O_NDELAY)) >= 0) {
2N/A ddi_devid_t devid;
2N/A
2N/A if (dm_debug > 1)
2N/A (void) fprintf(stderr, "INFO: cluster devpath %s\n",
2N/A devlink_path);
2N/A
2N/A if (devid_get(fd, &devid) == 0) {
2N/A char *minor;
2N/A char *devidstr;
2N/A
2N/A minor = di_minor_name(args->minor);
2N/A
2N/A if ((devidstr =
2N/A devid_str_encode(devid, minor)) != NULL) {
2N/A diskp = get_disk_by_deviceid(args->disk_listp,
2N/A devidstr);
2N/A /*
2N/A * This really shouldn't happen, since
2N/A * we should have found all of the disks
2N/A * during our first pass through
2N/A * the dev tree, but just in case...
2N/A */
2N/A if (diskp == NULL) {
2N/A if (dm_debug > 1)
2N/A (void) fprintf(stderr,
2N/A "INFO: cluster create"
2N/A " disk\n");
2N/A
2N/A diskp = create_disk(devidstr,
2N/A NULL, args);
2N/A if (diskp == NULL)
2N/A args->dev_walk_status = ENOMEM;
2N/A
2N/A /* add the controller relationship */
2N/A if ((args->dev_walk_status == 0) &&
2N/A (add_disk2controller(diskp,
2N/A args) != 0))
2N/A args->dev_walk_status = ENOMEM;
2N/A
2N/A if (new_alias(diskp, NULL,
2N/A devlink_path, args) != 0)
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A devid_str_free(devidstr);
2N/A }
2N/A devid_free(devid);
2N/A }
2N/A (void) close(fd);
2N/A }
2N/A
2N/A if (diskp != NULL) {
2N/A if (dm_debug > 1)
2N/A (void) fprintf(stderr, "INFO: cluster found"
2N/A " disk\n");
2N/A ap = diskp->aliases;
2N/A }
2N/A
2N/A if (ap != NULL) {
2N/A /*
2N/A * NOTE: if ap->next != NULL have cluster
2N/A * disks w/ multiple paths.
2N/A */
2N/A
2N/A if (!ap->cluster) {
2N/A char *basep;
2N/A char *namep;
2N/A int cnt = 0;
2N/A int len, size;
2N/A char alias[MAXPATHLEN];
2N/A char cldevpath[MAXPATHLEN];
2N/A
2N/A /*
2N/A * First time; save the /dev/rdsk devpaths and
2N/A * update the alias_did info with the new alias name.
2N/A */
2N/A ap->orig_paths = ap->devpaths;
2N/A ap->devpaths = NULL;
2N/A
2N/A /* get the new cluster alias name */
2N/A basep = strrchr(devlink_path, '/');
2N/A if (basep == NULL)
2N/A basep = devlink_path;
2N/A else
2N/A basep++;
2N/A size = sizeof (alias) - 1;
2N/A namep = alias;
2N/A
2N/A while (*basep != 0 && *basep != 's' && cnt < size) {
2N/A *namep++ = *basep++;
2N/A cnt++;
2N/A }
2N/A *namep = 0;
2N/A
2N/A free(ap->alias_did);
2N/A ap->alias_did = NULL;
2N/A
2N/A if ((ap->alias_did = strdup(alias)) == NULL)
2N/A args->dev_walk_status = ENOMEM;
2N/A
2N/A ap->cluster = 1;
2N/A
2N/A size = sizeof (cldevpath) - 1;
2N/A len = basep - devlink_path;
2N/A for (cnt = 0; (cnt < len) && (cnt < size); cnt ++)
2N/A cldevpath[cnt] = devlink_path[cnt];
2N/A cldevpath[cnt] = '\0';
2N/A
2N/A if (new_devpath(ap, cldevpath) != 0)
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A
2N/A if (new_devpath(ap, devlink_path) != 0)
2N/A args->dev_walk_status = ENOMEM;
2N/A }
2N/A
2N/A return (DI_WALK_CONTINUE);
2N/A}
2N/A
2N/A/*
2N/A * Check if we have the drive in our list, based upon the device id.
2N/A * We got the device id from the dev tree walk. This is encoded
2N/A * using devid_str_encode(3DEVID). In order to check the device ids we need
2N/A * to use the devid_compare(3DEVID) function, so we need to decode the
2N/A * string representation of the device id.
2N/A */
2N/Astatic disk_t *
2N/Aget_disk_by_deviceid(disk_t *listp, char *devidstr)
2N/A{
2N/A ddi_devid_t devid;
2N/A
2N/A if (devidstr == NULL || devid_str_decode(devidstr, &devid, NULL) != 0) {
2N/A return (NULL);
2N/A }
2N/A
2N/A while (listp != NULL) {
2N/A if (listp->devid != NULL &&
2N/A devid_compare(listp->devid, devid) == 0) {
2N/A break;
2N/A }
2N/A listp = listp->next;
2N/A }
2N/A
2N/A devid_free(devid);
2N/A return (listp);
2N/A}
2N/A
2N/A/*
2N/A * Get the base disk name with no path prefix and no slice (if there is one).
2N/A * The name parameter should be big enough to hold the name.
2N/A * This handles diskette names ok (/dev/rdiskette0) since there is no slice,
2N/A * and converts the raw diskette name.
2N/A * But, we don't know how to strip off the slice from third party drive
2N/A * names. That just means that their drive name will include a slice on
2N/A * it.
2N/A */
2N/Astatic void
2N/Aget_disk_name_from_path(char *path, char *name, int size)
2N/A{
2N/A char *basep;
2N/A int cnt = 0;
2N/A
2N/A basep = strrchr(path, '/');
2N/A if (basep == NULL) {
2N/A basep = path;
2N/A } else {
2N/A basep++;
2N/A }
2N/A
2N/A size = size - 1; /* leave room for terminating 0 */
2N/A
2N/A if (is_ctds(basep)) {
2N/A while (*basep != 0 && *basep != 's' && cnt < size) {
2N/A *name++ = *basep++;
2N/A cnt++;
2N/A }
2N/A *name = 0;
2N/A } else {
2N/A if (strncmp(basep, FLOPPY_NAME,
2N/A sizeof (FLOPPY_NAME) - 1) == 0) {
2N/A /*
2N/A * a floppy, convert rdiskette name to diskette name,
2N/A * by skipping over the 'r' for raw diskette
2N/A */
2N/A basep++;
2N/A }
2N/A
2N/A /* not a ctds name, just copy it */
2N/A (void) strlcpy(name, basep, size);
2N/A }
2N/A}
2N/A
2N/Astatic char *
2N/Aget_byte_prop(char *prop_name, di_node_t node)
2N/A{
2N/A int cnt;
2N/A uchar_t *bytes;
2N/A int i;
2N/A char str[MAXPATHLEN];
2N/A
2N/A cnt = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, prop_name, &bytes);
2N/A if (cnt < 1) {
2N/A return (NULL);
2N/A }
2N/A
2N/A str[0] = 0;
2N/A for (i = 0; i < cnt; i++) {
2N/A char bstr[8]; /* a byte is only 2 hex chars + null */
2N/A
2N/A (void) snprintf(bstr, sizeof (bstr), "%.2x", bytes[i]);
2N/A (void) strlcat(str, bstr, sizeof (str));
2N/A }
2N/A return (strdup(str));
2N/A}
2N/A
2N/Astatic di_node_t
2N/Aget_parent_bus(di_node_t node, struct search_args *args)
2N/A{
2N/A di_node_t pnode;
2N/A
2N/A pnode = di_parent_node(node);
2N/A if (pnode == DI_NODE_NIL) {
2N/A return (NULL);
2N/A }
2N/A
2N/A if (bus_type(pnode, di_minor_next(pnode, NULL), args->ph) != NULL) {
2N/A return (pnode);
2N/A }
2N/A
2N/A return (get_parent_bus(pnode, args));
2N/A}
2N/A
2N/Astatic int
2N/Aget_prom_int(char *prop_name, di_node_t node, di_prom_handle_t ph)
2N/A{
2N/A int *n;
2N/A
2N/A if (di_prom_prop_lookup_ints(ph, node, prop_name, &n) == 1) {
2N/A return (*n);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Astatic char *
2N/Aget_prom_str(char *prop_name, di_node_t node, di_prom_handle_t ph)
2N/A{
2N/A char *str;
2N/A
2N/A if (di_prom_prop_lookup_strings(ph, node, prop_name, &str) == 1) {
2N/A return (str);
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/A/*
2N/A * Get one of the positive int or boolean properties.
2N/A */
2N/Astatic int
2N/Aget_prop(char *prop_name, di_node_t node)
2N/A{
2N/A int num;
2N/A int *ip;
2N/A
2N/A if ((num = di_prop_lookup_ints(DDI_DEV_T_ANY, node, prop_name, &ip))
2N/A >= 0) {
2N/A if (num == 0) {
2N/A /* boolean */
2N/A return (1);
2N/A } else if (num == 1) {
2N/A /* single int */
2N/A return (*ip);
2N/A }
2N/A }
2N/A return (-1);
2N/A}
2N/A
2N/Astatic char *
2N/Aget_str_prop(char *prop_name, di_node_t node)
2N/A{
2N/A char *str;
2N/A
2N/A /*
2N/A * If we find a string, we return it here. If we get more than one
2N/A * string, then we're returning a pointer to the whole buffer, even
2N/A * though the caller will only 'see' the first string. This is OK
2N/A * though, because we only care about the first one.
2N/A */
2N/A if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, prop_name, &str) > 0) {
2N/A return (str);
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/A/*
2N/A * Check if we have the drive in our list, based upon the device id, if the
2N/A * drive has a device id, or the kernel name, if it doesn't have a device id.
2N/A */
2N/Astatic int
2N/Ahave_disk(struct search_args *args, char *devidstr, char *kernel_name,
2N/A disk_t **diskp)
2N/A{
2N/A disk_t *listp;
2N/A
2N/A *diskp = NULL;
2N/A listp = args->disk_listp;
2N/A if (devidstr != NULL) {
2N/A if ((*diskp = get_disk_by_deviceid(listp, devidstr)) != NULL) {
2N/A return (1);
2N/A }
2N/A
2N/A } else {
2N/A /* no devid, try matching the kernel names on the drives */
2N/A while (listp != NULL) {
2N/A if (libdiskmgt_str_eq(kernel_name,
2N/A listp->kernel_name)) {
2N/A *diskp = listp;
2N/A return (1);
2N/A }
2N/A listp = listp->next;
2N/A }
2N/A }
2N/A return (0);
2N/A}
2N/A
2N/Astatic char *
2N/Abus_type(di_node_t node, di_minor_t minor, di_prom_handle_t ph)
2N/A{
2N/A char *type;
2N/A int i;
2N/A
2N/A type = get_prom_str("device_type", node, ph);
2N/A if (type == NULL) {
2N/A type = di_node_name(node);
2N/A }
2N/A
2N/A for (i = 0; bustypes[i]; i++) {
2N/A if (libdiskmgt_str_eq(type, bustypes[i])) {
2N/A return (type);
2N/A }
2N/A }
2N/A
2N/A if (minor != NULL && strcmp(di_minor_nodetype(minor),
2N/A DDI_NT_USB_ATTACHMENT_POINT) == 0) {
2N/A return ("usb");
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic int
2N/Ais_cluster_disk(di_node_t node, di_minor_t minor)
2N/A{
2N/A if (di_minor_spectype(minor) == S_IFCHR &&
2N/A libdiskmgt_str_eq(di_minor_nodetype(minor), DDI_PSEUDO) &&
2N/A libdiskmgt_str_eq(di_node_name(node), CLUSTER_DEV)) {
2N/A return (1);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * If the input name is in c[t]ds format then return 1, otherwise return 0.
2N/A */
2N/Astatic int
2N/Ais_ctds(char *name)
2N/A{
2N/A char *p;
2N/A
2N/A p = name;
2N/A
2N/A if (*p++ != 'c') {
2N/A return (0);
2N/A }
2N/A /* skip controller digits */
2N/A while (isdigit(*p)) {
2N/A p++;
2N/A }
2N/A
2N/A /* handle optional target */
2N/A if (*p == 't') {
2N/A p++;
2N/A /* skip over target */
2N/A while (isdigit(*p) || isupper(*p)) {
2N/A p++;
2N/A }
2N/A }
2N/A
2N/A if (*p++ != 'd') {
2N/A return (0);
2N/A }
2N/A while (isdigit(*p)) {
2N/A p++;
2N/A }
2N/A
2N/A if (*p++ != 's') {
2N/A return (0);
2N/A }
2N/A
2N/A /* check the slice number */
2N/A while (isdigit(*p)) {
2N/A p++;
2N/A }
2N/A
2N/A if (*p != 0) {
2N/A return (0);
2N/A }
2N/A
2N/A return (1);
2N/A}
2N/A
2N/Astatic int
2N/Ais_drive(di_minor_t minor)
2N/A{
2N/A return (strncmp(di_minor_nodetype(minor), DDI_NT_BLOCK,
2N/A strlen(DDI_NT_BLOCK)) == 0);
2N/A}
2N/A
2N/Astatic int
2N/Ais_zvol(di_node_t node, di_minor_t minor)
2N/A{
2N/A if ((strncmp(di_node_name(node), ZFS_DRIVER, 3) == 0) &&
2N/A minor(di_minor_devt(minor)))
2N/A return (1);
2N/A return (0);
2N/A}
2N/A
2N/Astatic int
2N/Ais_HBA(di_node_t node, di_minor_t minor)
2N/A{
2N/A char *type;
2N/A char *name;
2N/A int type_index;
2N/A
2N/A type = di_minor_nodetype(minor);
2N/A type_index = 0;
2N/A
2N/A while (ctrltypes[type_index] != NULL) {
2N/A if (libdiskmgt_str_eq(type, ctrltypes[type_index])) {
2N/A return (1);
2N/A }
2N/A type_index++;
2N/A }
2N/A
2N/A name = di_node_name(node);
2N/A if (libdiskmgt_str_eq(type, DDI_PSEUDO) &&
2N/A libdiskmgt_str_eq(name, "ide")) {
2N/A return (1);
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Astatic int
2N/Anew_alias(disk_t *diskp, char *kernel_name, char *devlink_path,
2N/A struct search_args *args)
2N/A{
2N/A alias_t *aliasp;
2N/A char alias[MAXPATHLEN];
2N/A di_node_t pnode;
2N/A
2N/A aliasp = malloc(sizeof (alias_t));
2N/A if (aliasp == NULL)
2N/A return (ENOMEM);
2N/A
2N/A bzero(aliasp, sizeof (alias_t));
2N/A
2N/A get_disk_name_from_path(devlink_path, alias, sizeof (alias));
2N/A
2N/A aliasp->alias_cxtydz = strdup(alias);
2N/A if (aliasp->alias_cxtydz == NULL) {
2N/A cache_free_alias(aliasp);
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A aliasp->alias_did = strdup(alias);
2N/A if (aliasp->alias_did == NULL) {
2N/A cache_free_alias(aliasp);
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A if (kernel_name != NULL) {
2N/A aliasp->kstat_name = strdup(kernel_name);
2N/A if (aliasp->kstat_name == NULL) {
2N/A cache_free_alias(aliasp);
2N/A return (ENOMEM);
2N/A }
2N/A } else {
2N/A aliasp->kstat_name = NULL;
2N/A }
2N/A
2N/A aliasp->cluster = 0;
2N/A aliasp->lun = get_prop(DM_LUN, args->node);
2N/A aliasp->target = get_prop(DM_TARGET, args->node);
2N/A aliasp->wwn = get_byte_prop(WWN_PROP, args->node);
2N/A
2N/A pnode = di_parent_node(args->node);
2N/A if (pnode != DI_NODE_NIL) {
2N/A char prop_name[MAXPROPLEN];
2N/A
2N/A (void) snprintf(prop_name, sizeof (prop_name),
2N/A "target%d-sync-speed", aliasp->target);
2N/A diskp->sync_speed = get_prop(prop_name, pnode);
2N/A (void) snprintf(prop_name, sizeof (prop_name), "target%d-wide",
2N/A aliasp->target);
2N/A diskp->wide = get_prop(prop_name, pnode);
2N/A }
2N/A
2N/A if (new_devpath(aliasp, devlink_path) != 0) {
2N/A cache_free_alias(aliasp);
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A aliasp->next = diskp->aliases;
2N/A diskp->aliases = aliasp;
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Append the new devpath to the end of the devpath list. This is important
2N/A * since we may want to use the order of the devpaths to match up the vtoc
2N/A * entries.
2N/A */
2N/Astatic int
2N/Anew_devpath(alias_t *ap, char *devpath)
2N/A{
2N/A slice_t *newdp;
2N/A slice_t *alistp;
2N/A
2N/A /*
2N/A * First, search the alias list to be sure that this devpath is
2N/A * not already there.
2N/A */
2N/A
2N/A for (alistp = ap->devpaths; alistp != NULL; alistp = alistp->next) {
2N/A if (libdiskmgt_str_eq(alistp->devpath, devpath)) {
2N/A return (0);
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * Otherwise, not found so add this new devpath to the list.
2N/A */
2N/A
2N/A newdp = malloc(sizeof (slice_t));
2N/A if (newdp == NULL) {
2N/A return (ENOMEM);
2N/A }
2N/A
2N/A newdp->devpath = strdup(devpath);
2N/A if (newdp->devpath == NULL) {
2N/A free(newdp);
2N/A return (ENOMEM);
2N/A }
2N/A newdp->slice_num = -1;
2N/A newdp->next = NULL;
2N/A
2N/A if (ap->devpaths == NULL) {
2N/A ap->devpaths = newdp;
2N/A } else {
2N/A /* append the devpath to the end of the list */
2N/A slice_t *dp;
2N/A
2N/A dp = ap->devpaths;
2N/A while (dp->next != NULL) {
2N/A dp = dp->next;
2N/A }
2N/A
2N/A dp->next = newdp;
2N/A }
2N/A
2N/A return (0);
2N/A}
2N/A
2N/Astatic path_t *
2N/Anew_path(controller_t *cp, disk_t *dp, di_node_t node, di_path_state_t st,
2N/A char *wwn)
2N/A{
2N/A char *devpath;
2N/A path_t *pp;
2N/A di_minor_t minor;
2N/A
2N/A /* Special handling for fp attachment node. */
2N/A if (strcmp(di_node_name(node), "fp") == 0) {
2N/A di_node_t pnode;
2N/A
2N/A pnode = di_parent_node(node);
2N/A if (pnode != DI_NODE_NIL) {
2N/A node = pnode;
2N/A }
2N/A }
2N/A
2N/A devpath = di_devfs_path(node);
2N/A
2N/A /* check if the path is already there */
2N/A pp = NULL;
2N/A if (cp->paths != NULL) {
2N/A int i;
2N/A
2N/A for (i = 0; cp->paths[i]; i++) {
2N/A if (libdiskmgt_str_eq(devpath, cp->paths[i]->name)) {
2N/A pp = cp->paths[i];
2N/A break;
2N/A }
2N/A }
2N/A }
2N/A
2N/A if (pp != NULL) {
2N/A /* the path exists, add this disk to it */
2N/A
2N/A di_devfs_path_free((void *) devpath);
2N/A if (!add_disk2path(dp, pp, st, wwn)) {
2N/A return (NULL);
2N/A }
2N/A return (pp);
2N/A }
2N/A
2N/A /* create a new path */
2N/A
2N/A pp = calloc(1, sizeof (path_t));
2N/A if (pp == NULL) {
2N/A di_devfs_path_free((void *) devpath);
2N/A return (NULL);
2N/A }
2N/A
2N/A pp->name = strdup(devpath);
2N/A di_devfs_path_free((void *) devpath);
2N/A if (pp->name == NULL) {
2N/A cache_free_path(pp);
2N/A return (NULL);
2N/A }
2N/A
2N/A /* add the disk to the path */
2N/A if (!add_disk2path(dp, pp, st, wwn)) {
2N/A return (NULL);
2N/A }
2N/A
2N/A /* add the path to the controller */
2N/A if (add_ptr2array(pp, (void ***)&cp->paths) != 0) {
2N/A cache_free_path(pp);
2N/A return (NULL);
2N/A }
2N/A
2N/A /* add the controller to the path */
2N/A pp->controller = cp;
2N/A
2N/A minor = di_minor_next(node, NULL);
2N/A if (minor != NULL) {
2N/A pp->ctype = ctype(node, minor);
2N/A } else {
2N/A pp->ctype = DM_CTYPE_UNKNOWN;
2N/A }
2N/A
2N/A return (pp);
2N/A}
2N/A
2N/Astatic void
2N/Aremove_controller_reference(char *name, controller_t **ctra)
2N/A{
2N/A int cnt;
2N/A
2N/A if ((name == NULL) || (ctra == NULL))
2N/A return;
2N/A
2N/A for (cnt = 0; ctra[cnt] != NULL; cnt++) {
2N/A if (libdiskmgt_str_eq(ctra[cnt]->name, name)) {
2N/A int tcnt;
2N/A
2N/A /*
2N/A * remove pointer to invalid controller.
2N/A * (it is a path)
2N/A */
2N/A for (tcnt = cnt; ctra[tcnt] != NULL; tcnt++)
2N/A ctra[tcnt] = ctra[tcnt + 1];
2N/A }
2N/A }
2N/A}
2N/A
2N/A/*
2N/A * We pass in the current controller pointer (currp) so we can double check
2N/A * that we aren't corrupting the list by removing the element we are on. This
2N/A * should never happen, but it doesn't hurt to double check.
2N/A */
2N/Astatic void
2N/Aremove_invalid_controller(char *name, controller_t *currp,
2N/A struct search_args *args)
2N/A{
2N/A controller_t *tcp, *pcp, *cp;
2N/A disk_t *dp;
2N/A bus_t *bp;
2N/A
2N/A /*
2N/A * loop through the disks and remove the reference to the
2N/A * controller for this disk structure. The disk itself
2N/A * is still a valid device, the controller being removed
2N/A * is a 'path' so any disk that has a reference to it
2N/A * as a controller needs to have this reference removed.
2N/A */
2N/A for (dp = args->disk_listp; dp != NULL; dp = dp->next)
2N/A remove_controller_reference(name, dp->controllers);
2N/A
2N/A for (bp = args->bus_listp; bp != NULL; bp = bp->next)
2N/A remove_controller_reference(name, bp->controllers);
2N/A
2N/A /*
2N/A * loop through the controllers and remove the controller itself.
2N/A * The controller being removed is a 'path'.
2N/A */
2N/A for (pcp = NULL, cp = args->controller_listp; cp != NULL;
2N/A /* CSTYLED */) {
2N/A if (libdiskmgt_str_eq(cp->name, name)) {
2N/A if (cp == currp) {
2N/A if (dm_debug)
2N/A (void) fprintf(stderr,
2N/A "ERROR: Removing current "
2N/A "controller %s from list\n",
2N/A cp->name);
2N/A
2N/A pcp = cp;
2N/A cp = cp->next;
2N/A continue;
2N/A }
2N/A
2N/A tcp = cp;
2N/A cp = cp->next;
2N/A
2N/A if (pcp == NULL)
2N/A args->controller_listp = cp;
2N/A else
2N/A pcp->next = cp;
2N/A
2N/A if (dm_debug)
2N/A (void) fprintf(stderr,
2N/A "INFO: Removed controller %s from list\n",
2N/A tcp->name);
2N/A
2N/A cache_free_controller(tcp);
2N/A continue;
2N/A }
2N/A
2N/A pcp = cp;
2N/A cp = cp->next;
2N/A }
2N/A}
2N/A
2N/A/*
2N/A * This is the standard strstr code modified for case independence.
2N/A */
2N/Astatic char *
2N/Astr_case_index(register char *s1, register char *s2)
2N/A{
2N/A uint_t s2len = strlen(s2); /* length of the second string */
2N/A
2N/A /* If the length of the second string is 0, return the first arg. */
2N/A if (s2len == 0) {
2N/A return (s1);
2N/A }
2N/A
2N/A while (strlen(s1) >= s2len) {
2N/A if (strncasecmp(s1, s2, s2len) == 0) {
2N/A return (s1);
2N/A }
2N/A s1++;
2N/A }
2N/A return (NULL);
2N/A}