xref: /illumos-gate/usr/src/lib/storage/liba5k/common/diag.c (revision fcf3ce44)

/*
 * 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
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*LINTLIBRARY*/


/*
 *	This module is part of the photon library
 */

/*
 * I18N message number ranges
 *  This file: 8000 - 8499
 *  Shared common messages: 1 - 1999
 */

/*	Includes	*/
#include	<stdlib.h>
#include	<stdio.h>
#include	<sys/file.h>
#include	<sys/types.h>
#include	<sys/param.h>
#include	<fcntl.h>
#include	<unistd.h>
#include	<errno.h>
#include	<string.h>
#include	<sys/scsi/scsi.h>
#include	<nl_types.h>
#include	<strings.h>
#include	<sys/ddi.h>	/* for max */
#include	<l_common.h>
#include	<stgcom.h>
#include	<l_error.h>
#include	<a_state.h>
#include	<a5k.h>



/*	Defines		*/
#define	VERBPRINT	if (verbose) (void) printf


/*
 * take all paths supplied by dl offline.
 *
 * RETURNS:
 *	0 = No error.
 *	*bsy_res_flag_p: 1 = The device is "busy".
 *
 * In pre-2.6 we just return success
 */
static int
d_offline_drive(struct dlist *dl, int *bsy_res_flag_p, int verbose)
{
char			dev_path1[MAXPATHLEN];
devctl_hdl_t		devhdl;


	/* for each path attempt to take it offline */
	for (; dl != NULL; dl = dl->next) {

		/* save a copy of the pathname */
		(void) strcpy(dev_path1, dl->dev_path);

		/* attempt to acquire the device */
		if ((devhdl = devctl_device_acquire(dev_path1,
			DC_EXCL)) == NULL) {
			if (errno != EBUSY) {
				return (L_ACQUIRE_FAIL);
			}
		}

		/* attempt to offline the drive */
		if (devctl_device_offline(devhdl) != 0) {
			*bsy_res_flag_p = 1;
			(void) devctl_release(devhdl);
			return (0);
		}

		E_DPRINTF("  d_offline_drive: Offline succeeded:/n    "
			"%s\n", dev_path1);
		/* offline succeeded -- release handle acquired above */
		(void) devctl_release(devhdl);
	}
	return (0);
}




/*
 * Check to see if any of the disks that are attached
 * to the selected port on this backplane are reserved or busy.
 *
 * INPUTS:
 * RETURNS:
 *	0 = No error.
 *	*bsy_res_flag_p: 1 = The device is "busy".
 */

int
l_check_busy_reserv_bp(char *ses_path, int front_flag,
	int port_a_flag, int *bsy_res_flag_p, int verbose)
{
int	err, i;
L_state		*l_state = NULL;
struct dlist	*p_list;

	if ((l_state = (L_state *)calloc(1, sizeof (L_state))) == NULL) {
		return (L_MALLOC_FAILED);
	}

	if (err = l_get_status(ses_path, l_state, verbose)) {
		(void) l_free_lstate(&l_state);
		return (err);
	}
	for (i = 0; i < (int)l_state->total_num_drv/2; i++) {
		if ((front_flag &&
	(l_state->drv_front[i].g_disk_state.d_state_flags[port_a_flag] &
			L_RESERVED)) || (!front_flag &&
	(l_state->drv_rear[i].g_disk_state.d_state_flags[port_a_flag] &
			L_RESERVED))) {
			*bsy_res_flag_p = 1;
			(void) l_free_lstate(&l_state);
			return (0);
		}
	}

	for (i = 0; i < (int)l_state->total_num_drv/2; i++) {
		/* Get list of all paths to the requested port. */
		if (front_flag) {
			if (port_a_flag) {
				if ((err = g_get_port_multipath(
				l_state->drv_front[i].g_disk_state.port_a_wwn_s,
					&p_list, verbose)) != 0) {
					(void) l_free_lstate(&l_state);
					return (err);
				}
			} else {
				if ((err = g_get_port_multipath(
				l_state->drv_front[i].g_disk_state.port_b_wwn_s,
					&p_list, verbose)) != 0) {
					(void) l_free_lstate(&l_state);
					return (err);
				}
			}
		} else {
			if (port_a_flag) {
				if ((err = g_get_port_multipath(
				l_state->drv_rear[i].g_disk_state.port_a_wwn_s,
					&p_list, verbose)) != 0) {
					(void) l_free_lstate(&l_state);
					return (err);
				}
			} else {
				if ((err = g_get_port_multipath(
				l_state->drv_rear[i].g_disk_state.port_b_wwn_s,
					&p_list, verbose)) != 0) {
					(void) l_free_lstate(&l_state);
					return (err);
				}
			}
		}
		if (err = d_offline_drive(p_list,
			bsy_res_flag_p, verbose)) {
			(void) g_free_multipath(p_list);
			(void) l_free_lstate(&l_state);
			return (err);
		}
		(void) g_free_multipath(p_list);
	}
	(void) l_free_lstate(&l_state);
	return (0);
}



/*
 * Request the enclosure services controller (IB)
 * to set the LRC (Loop Redundancy Circuit) to the
 * bypassed/enabled state for the backplane specified by
 * the a and f flag and the enclosure or pathname.
 */
int
l_bp_bypass_enable(char *ses_path, int bypass_flag, int port_a_flag,
	int front_flag, int force_flag, int verbose)
{

int		fd, i;
int		nobj = 0;
ses_objarg	obj;
ses_object	*all_objp = NULL, *all_objp_save = NULL;
int		found = 0;
Bp_elem_st	*bp;
char		msg[MAXPATHLEN];
int		bsy_res_flag = 0;
int		err;

	if (ses_path == NULL) {
		return (L_NO_SES_PATH);
	}

	/*
	 * Check for reservation and busy for all disks on this
	 * backplane.
	 */

	if (!force_flag && bypass_flag) {
		if (err = l_check_busy_reserv_bp(ses_path,
			front_flag, port_a_flag, &bsy_res_flag, verbose)) {
			return (err);
		}
		if (bsy_res_flag) {
				return (L_BP_BUSY_RESERVED);
		}
	}


	if ((fd = g_object_open(ses_path, O_NDELAY | O_RDWR)) == -1) {
		return (errno);
	}

	if (ioctl(fd, SESIOC_GETNOBJ, (caddr_t)&nobj) < 0) {
		(void) close(fd);
		return (errno);
	}
	if (nobj == 0) {
		(void) close(fd);
		return (L_IB_NO_ELEM_FOUND);
	}

	E_DPRINTF("  l_ib_bypass_bp: Number of SES objects: 0x%x\n",
		nobj);

	/* alloc some memory for the objmap */
	if ((all_objp = g_zalloc((nobj + 1) * sizeof (ses_object))) == NULL) {
		(void) close(fd);
		return (errno);
	}

	all_objp_save = all_objp;

	if (ioctl(fd, SESIOC_GETOBJMAP, (caddr_t)all_objp) < 0) {
		(void) close(fd);
		(void) g_destroy_data(all_objp_save);
		return (errno);
	}

	for (i = 0; i < nobj; i++, all_objp++) {
			E_DPRINTF("  ID 0x%x\t Element type 0x%x\n",
			all_objp->obj_id, all_objp->elem_type);
		if (all_objp->elem_type == ELM_TYP_BP) {
			found++;
			break;
		}
	}

	if (found == 0) {
		(void) close(fd);
		(void) g_destroy_data(all_objp_save);
		return (L_NO_BP_ELEM_FOUND);
	}

	/*
	 * We found the backplane element.
	 */


	if (verbose) {
		/* Get the status for backplane #0 */
		obj.obj_id = all_objp->obj_id;
		if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
			(void) close(fd);
			(void) g_destroy_data(all_objp_save);
			return (errno);
		}
		(void) fprintf(stdout, MSGSTR(8000,
			"  Front backplane status: "));
		bp = (struct  bp_element_status *)&obj.cstat[0];
		l_element_msg_string(bp->code, msg);
		(void) fprintf(stdout, "%s\n", msg);
		if (bp->byp_a_enabled || bp->en_bypass_a) {
			(void) fprintf(stdout, "    ");
			(void) fprintf(stdout,
			MSGSTR(130, "Bypass A enabled"));
			(void) fprintf(stdout, ".\n");
		}
		if (bp->byp_b_enabled || bp->en_bypass_b) {
			(void) fprintf(stdout, "    ");
			(void) fprintf(stdout,
			MSGSTR(129, "Bypass B enabled"));
			(void) fprintf(stdout, ".\n");
		}

		all_objp++;
		obj.obj_id = all_objp->obj_id;
		all_objp--;
		if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
			(void) close(fd);
			(void) g_destroy_data(all_objp_save);
			return (errno);
		}
		(void) fprintf(stdout, MSGSTR(8001,
			"  Rear backplane status: "));
		bp = (struct  bp_element_status *)&obj.cstat[0];
		l_element_msg_string(bp->code, msg);
		(void) fprintf(stdout, "%s\n", msg);
		if (bp->byp_a_enabled || bp->en_bypass_a) {
			(void) fprintf(stdout, "    ");
			(void) fprintf(stdout,
			MSGSTR(130, "Bypass A enabled"));
			(void) fprintf(stdout, ".\n");
		}
		if (bp->byp_b_enabled || bp->en_bypass_b) {
			(void) fprintf(stdout, "    ");
			(void) fprintf(stdout,
			MSGSTR(129, "Bypass B enabled"));
			(void) fprintf(stdout, ".\n");
		}
	}

	/* Get the current status */
	if (!front_flag) {
		all_objp++;
	}
	obj.obj_id = all_objp->obj_id;
	if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
		(void) close(fd);
		(void) g_destroy_data(all_objp_save);
		return (errno);
	}
	/* Do the requested action. */
	bp = (struct  bp_element_status *)&obj.cstat[0];
	bp->select = 1;
	bp->code = 0;
	if (port_a_flag) {
		bp->en_bypass_a = bypass_flag;
	} else {
		bp->en_bypass_b = bypass_flag;
	}
	if (getenv("_LUX_E_DEBUG") != NULL) {
		(void) printf("  Sending this structure to ID 0x%x"
			" of type 0x%x\n",
			obj.obj_id, all_objp->elem_type);
		for (i = 0; i < 4; i++) {
			(void) printf("    Byte %d  0x%x\n", i,
			obj.cstat[i]);
		}
	}

	if (ioctl(fd, SESIOC_SETOBJSTAT, (caddr_t)&obj) < 0) {
		(void) close(fd);
		(void) g_destroy_data(all_objp_save);
		return (errno);
	}

	(void) g_destroy_data(all_objp_save);
	(void) close(fd);

	return (0);
}




/*
 * This function will request the enclosure services
 * controller (IB) to set the LRC (Loop Redundancy Circuit) to the
 * bypassed/enabled state for the device specified by the
 * enclosure,dev or pathname and the port specified by the a
 * flag.
 */

int
l_dev_bypass_enable(struct path_struct *path_struct, int bypass_flag,
	int force_flag, int port_a_flag, int verbose)
{
gfc_map_t		map;
char			ses_path[MAXPATHLEN];
uchar_t			*page_buf;
int 			err, fd, front_index, rear_index, offset;
int			pathcnt = 1;
unsigned short		page_len;
struct	device_element 	*elem;
L_state			*l_state = NULL;
struct device_element 	status;
int			bsy_flag = 0, i, f_flag;
struct dlist		*p_list;
char			temppath[MAXPATHLEN];
mp_pathlist_t		pathlist;
int			p_pw = 0, p_on = 0, p_st = 0;
L_inquiry		inq;

	if (path_struct == NULL) {
		return (L_INVALID_PATH_FORMAT);
	}

	if ((l_state = (L_state *)calloc(1, sizeof (L_state))) == NULL) {
		return (L_MALLOC_FAILED);
	}
	map.dev_addr = (gfc_port_dev_info_t *)NULL;
	(void) strcpy(temppath, path_struct->p_physical_path);
	if ((strstr(path_struct->p_physical_path, SCSI_VHCI) != NULL) &&
		(!g_get_pathlist(temppath, &pathlist))) {
			pathcnt = pathlist.path_count;
			p_pw = p_on = p_st = 0;
			for (i = 0; i < pathcnt; i++) {
				if (pathlist.path_info[i].path_state <
					MAXPATHSTATE) {
					if (strstr(pathlist.path_info[i].
						path_addr,
						path_struct->argv) != NULL) {
						p_pw = i;
						break;
					}
					if (pathlist.path_info[i].path_state ==
						MDI_PATHINFO_STATE_ONLINE) {
						p_on = i;
					}
					if (pathlist.path_info[i].path_state ==
						MDI_PATHINFO_STATE_STANDBY) {
						p_st = i;
					}
				}
			}
			if (strstr(pathlist.path_info[p_pw].path_addr,
				path_struct->argv) != NULL) {
				/* matching input pwwn */
				(void) strcpy(temppath,
					pathlist.path_info[p_pw].path_hba);
			} else if (pathlist.path_info[p_on].path_state ==
				MDI_PATHINFO_STATE_ONLINE) {
				/* on_line path */
				(void) strcpy(temppath,
					pathlist.path_info[p_on].path_hba);
			} else {
				/* standby or path0 */
				(void) strcpy(temppath,
					pathlist.path_info[p_st].path_hba);
			}
			free(pathlist.path_info);
			(void) strcat(temppath, FC_CTLR);
	}

	/*
	 * Need to get a valid location, front/rear & slot.
	 *
	 * The path_struct will return a valid slot
	 * and the IB path or a disk path.
	 */

	if (!path_struct->ib_path_flag) {
		if (err = g_get_dev_map(temppath, &map, verbose)) {
			(void) l_free_lstate(&l_state);
			return (err);
		}
		if (err = l_get_ses_path(path_struct->p_physical_path,
			ses_path, &map, verbose)) {
			(void) l_free_lstate(&l_state);
			free((void *)map.dev_addr);
			return (err);
		}
	} else {
		(void) strcpy(ses_path, path_struct->p_physical_path);
	}
	if (!path_struct->slot_valid) {
		if ((map.dev_addr == (gfc_port_dev_info_t *)NULL) &&
			((err = g_get_dev_map(temppath,
						&map, verbose)) != 0)) {
			(void) l_free_lstate(&l_state);
			return (err);
		}
		if ((err = l_get_ses_path(path_struct->p_physical_path,
			ses_path, &map, verbose)) != 0) {
			(void) l_free_lstate(&l_state);
			free((void *)map.dev_addr);
			return (err);
		}
		if ((err = l_get_status(ses_path, l_state, verbose)) != 0) {
			(void) l_free_lstate(&l_state);
			free((void *)map.dev_addr);
			return (err);
		}

		/* We are passing the disks path */
		if ((err = l_get_slot(path_struct, l_state, verbose)) != 0) {
			(void) l_free_lstate(&l_state);
			free((void *)map.dev_addr);
			return (err);
		}
	}

	if (map.dev_addr != (gfc_port_dev_info_t *)NULL) {
		free((void *)map.dev_addr);
	}

	if ((page_buf = (uchar_t *)malloc(MAX_REC_DIAG_LENGTH)) == NULL) {
		(void) l_free_lstate(&l_state);
		return (errno);
	}

	if ((fd = g_object_open(ses_path, O_NDELAY | O_RDWR)) == -1) {
		(void) g_destroy_data(page_buf);
		(void) l_free_lstate(&l_state);
		return (errno);
	}

	if (err = l_get_envsen_page(fd, page_buf, MAX_REC_DIAG_LENGTH,
				L_PAGE_2, verbose)) {
		(void) close(fd);
		(void) g_destroy_data(page_buf);
		(void) l_free_lstate(&l_state);
		return (err);
	}

	page_len = (page_buf[2] << 8 | page_buf[3]) + HEADER_LEN;

	/* Get index to the disk we are interested in */
	if (err = l_get_status(ses_path, l_state, verbose)) {
		(void) close(fd);
		(void) g_destroy_data(page_buf);
		(void) l_free_lstate(&l_state);
		return (err);
	}
	/*
	 * Now that we have the status check to see if
	 * busy or reserved, if bypassing.
	 */
	if ((!(force_flag | path_struct->ib_path_flag)) &&
						bypass_flag) {
		i = path_struct->slot;
		f_flag = path_struct->f_flag;

		/*
		 * Check for reservation and busy
		 */
		if ((f_flag &&
		(l_state->drv_front[i].g_disk_state.d_state_flags[port_a_flag] &
			L_RESERVED)) || (!f_flag &&
		(l_state->drv_rear[i].g_disk_state.d_state_flags[port_a_flag] &
			L_RESERVED))) {
			(void) close(fd);
			(void) g_destroy_data(page_buf);
			(void) l_free_lstate(&l_state);
			return (L_BP_RESERVED);
		}
		if (f_flag) {
			if (port_a_flag) {
				if ((err = g_get_port_multipath(
				l_state->drv_front[i].g_disk_state.port_a_wwn_s,
					&p_list, verbose)) != 0) {
					(void) close(fd);
					(void) g_destroy_data(page_buf);
					(void) l_free_lstate(&l_state);
					return (err);
				}
			} else {
				if ((err = g_get_port_multipath(
				l_state->drv_front[i].g_disk_state.port_b_wwn_s,
					&p_list, verbose)) != 0) {
					(void) close(fd);
					(void) g_destroy_data(page_buf);
					(void) l_free_lstate(&l_state);
					return (err);
				}
			}
		} else {
			if (port_a_flag) {
				if ((err = g_get_port_multipath(
				l_state->drv_rear[i].g_disk_state.port_a_wwn_s,
					&p_list, verbose)) != 0) {
					(void) close(fd);
					(void) g_destroy_data(page_buf);
					(void) l_free_lstate(&l_state);
					return (err);
				}
			} else {
				if ((err = g_get_port_multipath(
				l_state->drv_rear[i].g_disk_state.port_b_wwn_s,
					&p_list, verbose)) != 0) {
					(void) close(fd);
					(void) g_destroy_data(page_buf);
					(void) l_free_lstate(&l_state);
					return (err);
				}
			}
		}
		if (err = d_offline_drive(p_list,
			&bsy_flag, verbose)) {
			(void) g_free_multipath(p_list);
			(void) close(fd);
			(void) g_destroy_data(page_buf);
			(void) l_free_lstate(&l_state);
			return (err);
		}
		(void) g_free_multipath(p_list);
		if (bsy_flag) {
			(void) close(fd);
			(void) g_destroy_data(page_buf);
			(void) l_free_lstate(&l_state);
			return (L_BP_BUSY);
		}
	}

	if (err = l_get_disk_element_index(l_state, &front_index,
		&rear_index)) {
		(void) close(fd);
		(void) g_destroy_data(page_buf);
		(void) l_free_lstate(&l_state);
		return (err);
	}

	if (g_get_inquiry(ses_path, &inq)) {
		return (L_SCSI_ERROR);
	}

	/* Skip global element */
	front_index++;
	if ((strncmp((char *)&inq.inq_pid[0], DAK_OFF_NAME,
						strlen(DAK_OFF_NAME)) == 0) ||
			(strncmp((char *)&inq.inq_pid[0], DAK_PROD_STR,
						strlen(DAK_PROD_STR)) == 0)) {
		rear_index += (MAX_DRIVES_DAK/2) + 1;
	} else {
		rear_index++;
	}

	if (path_struct->f_flag) {
		offset = (8 + (front_index + path_struct->slot)*4);
	} else {
		offset = (8 + (rear_index + path_struct->slot)*4);
	}

	elem = (struct device_element *)(page_buf + offset);
	/*
	 * now do requested action.
	 */
	bcopy((const void *)elem, (void *)&status,
		sizeof (struct device_element));	/* save status */
	bzero(elem, sizeof (struct device_element));
	elem->select = 1;
	elem->dev_off = status.dev_off;
	elem->en_bypass_a = status.en_bypass_a;
	elem->en_bypass_b = status.en_bypass_b;

	/* Do requested action */
	if (port_a_flag) {
		elem->en_bypass_a = bypass_flag;
	} else {
		elem->en_bypass_b = bypass_flag;
	}

	if (getenv("_LUX_E_DEBUG") != NULL) {
		g_dump("  l_dev_bypass_enable: Updating LRC circuit state:\n"
		"    Device Status Element ",
		(uchar_t *)elem, sizeof (struct device_element),
		HEX_ONLY);
		(void) fprintf(stdout, "    for device at location:"
			" enclosure:%s slot:%d %s\n",
			l_state->ib_tbl.enclosure_name,
			path_struct->slot,
			path_struct->f_flag ? "front" : "rear");
	}
	if (err = g_scsi_send_diag_cmd(fd,
		(uchar_t *)page_buf, page_len)) {
		(void) close(fd);
		(void) g_destroy_data(page_buf);
		(void) l_free_lstate(&l_state);
		return (err);
	}

	(void) close(fd);
	(void) g_destroy_data(page_buf);
	(void) l_free_lstate(&l_state);
	return (0);
}



/*
 * Issue a Loop Port enable Primitive sequence
 * to the device specified by the pathname.
 */
int
d_p_enable(char *path, int verbose)
/*ARGSUSED*/
{

	return (0);
}

/*
 * Issue a Loop Port Bypass Primitive sequence
 * to the device specified by the pathname. This requests the
 * device to set its L_Port into the bypass mode.
 */
int
d_p_bypass(char *path, int verbose)
/*ARGSUSED*/
{

	return (0);
}