/*
 * 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: 3500 - 3999
 *  Shared common messages: 1 - 1999
 */

/*	Includes	*/
#include	<stdlib.h>
#include	<stdio.h>
#include	<sys/file.h>
#include	<sys/errno.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	<libdevice.h>
#include	<sys/fibre-channel/fcio.h>
#define	_SYS_FC4_FCAL_LINKAPP_H
#include	<sys/fc4/fcio.h>
#include	<sys/devctl.h>
#include	<sys/scsi/targets/sesio.h>
#include	<l_common.h>
#include	<l_error.h>
#include	<a_state.h>
#include	<a5k.h>
#include	<stgcom.h>
#include	"luxadm.h"


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



static int
print_ssd_in_box(char *ses_path, uchar_t *box_name, int verbose)
{
L_state		l_state;
int		err, i;
struct	dlist	*ml;
WWN_list	*wwn_list, *wwn_list_ptr;
char		*s;
L_inquiry	inq;
int		enc_type = 0;

	wwn_list = wwn_list_ptr = NULL;
	if (err = l_get_status(ses_path, &l_state, verbose)) {
		return (err);
	}

	if (err = g_get_wwn_list(&wwn_list, verbose)) {
		return (err);

	}

	/* Need to find out whether this device is a daktari */
	if (g_get_inquiry(ses_path, &inq)) {
		return (L_SCSI_ERROR);
	}
	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)) {
		enc_type = DAK_ENC_TYPE;
	}
	for (i = 0; i < (int)l_state.total_num_drv/2; i++) {
		if (l_state.drv_front[i].ib_status.code != S_NOT_INSTALLED) {

		ml = l_state.drv_front[i].g_disk_state.multipath_list;
		while (ml) {
			for (wwn_list_ptr = wwn_list; wwn_list_ptr != NULL;
					wwn_list_ptr = wwn_list_ptr->wwn_next) {
				s = wwn_list_ptr->physical_path;
				if (strcmp((char *)s,
					ml->dev_path) == 0) {
				(void) fprintf(stdout, MSGSTR(3500,
					"%-80.80s %-17.17s %-17.17s %-22.22s "),
					wwn_list_ptr->physical_path,
					wwn_list_ptr->node_wwn_s,
					wwn_list_ptr->port_wwn_s,
					wwn_list_ptr->logical_path);
					if (enc_type == DAK_ENC_TYPE) {
						(void) fprintf(stdout,
						MSGSTR(3513, "%s,s%d\n"),
						box_name, i);
					} else {
						(void) fprintf(stdout,
						MSGSTR(3501, "%s,f%d\n"),
						box_name, i);
					}
				}
			}
			ml = ml->next;
		}

		}
	}
	for (i = 0; i < (int)l_state.total_num_drv/2; i++) {
		if (l_state.drv_rear[i].ib_status.code != S_NOT_INSTALLED) {

		ml = l_state.drv_rear[i].g_disk_state.multipath_list;
		while (ml) {
			wwn_list_ptr = wwn_list;
			for (wwn_list_ptr = wwn_list; wwn_list_ptr != NULL;
					wwn_list_ptr = wwn_list_ptr->wwn_next) {
				s = wwn_list_ptr->physical_path;
				if (strcmp((char *)s,
					ml->dev_path) == 0) {
				(void) fprintf(stdout, MSGSTR(3502,
					"%-80.80s %-17.17s %-17.17s %-22.22s "),
					wwn_list_ptr->physical_path,
					wwn_list_ptr->node_wwn_s,
					wwn_list_ptr->port_wwn_s,
					wwn_list_ptr->logical_path);
					if (enc_type == DAK_ENC_TYPE) {
						(void) fprintf(stdout,
						MSGSTR(3513, "%s,s%d\n"),
							box_name,
						(int)l_state.total_num_drv/2+i);
					} else {
						(void) fprintf(stdout,
						MSGSTR(3503, "%s,r%d\n"),
								box_name, i);
					}
				}
			}
			ml = ml->next;
		}

		}
	}
	g_free_wwn_list(&wwn_list);
	return (0);
}



int
sysdump(int verbose)
{
int		err;

Box_list	*b_list = NULL;
Box_list	*o_list = NULL;
Box_list	*c_list = NULL;
int		multi_print_flag;

	if (err = l_get_box_list(&b_list, verbose)) {
		return (err);
	}
	if (b_list == NULL) {
		(void) fprintf(stdout,
			MSGSTR(93, "No %s enclosures found "
			"in /dev/es\n"), ENCLOSURE_PROD_NAME);
	} else {
		o_list = b_list;
		while (b_list != NULL) {
			/* Don't re-print multiple paths */
			c_list = o_list;
			multi_print_flag = 0;
			while (c_list != b_list) {
				if (strcmp(c_list->b_node_wwn_s,
					b_list->b_node_wwn_s) == 0) {
					multi_print_flag = 1;
					break;
				}
				c_list = c_list->box_next;
			}
			if (multi_print_flag) {
				b_list = b_list->box_next;
				continue;
			}
			/* Found enclosure */

			(void) fprintf(stdout,
			MSGSTR(3504, "Enclosure name:%s   Node WWN:%s\n"),
			b_list->b_name, b_list->b_node_wwn_s);

			(void) fprintf(stdout, MSGSTR(3505,
			"%-80.80s %-17.17s %-17.17s %-22.22s %-20.20s \n"),
			MSGSTR(3506, "Physical"),
			MSGSTR(3507, "Node_WWN"),
			MSGSTR(3508, "Port_WWN"),
			MSGSTR(3509, "Logical"),
			MSGSTR(3510, "Name"));

			(void) fprintf(stdout, MSGSTR(3511,
			"%-80.80s %-17.17s %-17.17s %-22.22s %-20.20s\n"),
			b_list->b_physical_path,
			b_list->b_node_wwn_s,
			b_list->b_port_wwn_s,
			b_list->logical_path,
			b_list->b_name);

			c_list = o_list;
			while (c_list != NULL) {
				if ((c_list != b_list) &&
				(strcmp(c_list->b_node_wwn_s,
					b_list->b_node_wwn_s) == 0)) {
					(void) fprintf(stdout, MSGSTR(3512,
			"%-80.80s %-17.17s %-17.17s %-22.22s %-20.20s\n"),
					c_list->b_physical_path,
					c_list->b_node_wwn_s,
					c_list->b_port_wwn_s,
					c_list->logical_path,
					c_list->b_name);
				}
				c_list = c_list->box_next;
			}
			/*
			 * Print the individual disk information for each box.
			 */
			if (err = print_ssd_in_box(b_list->b_physical_path,
				b_list->b_name, verbose)) {
				return (err);
			}
			b_list = b_list->box_next;
		}
	}
	(void) l_free_box_list(&b_list);
	return (0);
}