#define LUX_SF_INST_SHIFT4MINOR 6
#define LUX_SF_MINOR2INST(x) (x >> LUX_SF_INST_SHIFT4MINOR)
#include <stdlib.h>
#include <stdio.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <kstat.h>
#include <sys/mkdev.h>
#include <locale.h>
#include <nl_types.h>
#include <fcntl.h>
#include <unistd.h>
#include <strings.h>
#include <ctype.h>
#include <dirent.h>
#include <limits.h>
#include <stdarg.h>
#include <termio.h>
#include <signal.h>
#include <sys/scsi/scsi.h>
#include <sys/scsi/generic/commands.h>
#include <l_common.h>
#include <l_error.h>
#include <stgcom.h>
#include <a_state.h>
#include <devid.h>
#include <g_state.h>
#include "common.h"
extern char *dtype[];
extern char *whoami;
extern int Options;
extern const int OPTION_A;
extern const int OPTION_B;
extern const int OPTION_C;
extern const int OPTION_D;
extern const int OPTION_E;
extern const int OPTION_F;
extern const int OPTION_L;
extern const int OPTION_P;
extern const int OPTION_R;
extern const int OPTION_T;
extern const int OPTION_V;
extern const int OPTION_Z;
extern const int OPTION_Y;
extern const int OPTION_CAPF;
extern const int PVERBOSE;
extern const int SAVE;
extern const int EXPERT;
static struct termios termios;
static int termio_fd;
static void pho_display_config(char *);
static void dpm_display_config(char *);
static void n_rem_list_entry(uchar_t, struct gfc_map *,
WWN_list **);
static void n_rem_list_entry_fabric(int, struct gfc_map *,
WWN_list **);
static void n_rem_wwn_entry(uchar_t *, WWN_list **);
static void display_disk_info(L_inquiry, L_disk_state,
Path_struct *, struct mode_page *, int, char *, int);
static void display_lun_info(L_disk_state, Path_struct *,
struct mode_page *, int, WWN_list *, char *);
static void display_fc_disk(struct path_struct *, char *, gfc_map_t *,
L_inquiry, int);
static void adm_display_err(char *, int);
static void temperature_messages(struct l_state_struct *, int);
static void ctlr_messages(struct l_state_struct *, int, int);
static void fan_messages(struct l_state_struct *, int, int);
static void ps_messages(struct l_state_struct *, int, int);
static void abnormal_condition_display(struct l_state_struct *);
static void loop_messages(struct l_state_struct *, int, int);
static void revision_msg(struct l_state_struct *, int);
static void mb_messages(struct l_state_struct *, int, int);
static void back_plane_messages(struct l_state_struct *, int, int);
static void dpm_SSC100_messages(struct l_state_struct *, int, int);
static void mb_messages(struct l_state_struct *, int, int);
static void back_plane_messages(struct l_state_struct *, int, int);
static void dpm_SSC100_messages(struct l_state_struct *, int, int);
static void trans_decode(Trans_elem_st *trans);
static void trans_messages(struct l_state_struct *, int);
static void adm_print_pathlist(char *);
static void display_path_info(char *, char *, WWN_list *);
static void copy_wwn_data_to_str(char *, const uchar_t *);
static void adm_mplist_free(struct mplist_struct *);
static int lun_display(Path_struct *path_struct, L_inquiry inq_struct,
int verbose);
static int non_encl_fc_disk_display(Path_struct *path_struct,
L_inquiry inq_struct, int verbose);
static int get_enclStatus(char *phys_path, char *encl_name, int off_flag);
static int get_host_controller_pwwn(char *hba_path, uchar_t *pwwn);
static int get_lun_capacity(char *devpath,
struct scsi_capacity_16 *cap_data);
static int get_path_status(char *devpath, int *status);
static int get_FC4_host_controller_pwwn(char *hba_path, uchar_t *pwwn);
int
print_devState(char *devname, char *ppath, int fr_flag, int slot,
int verbose_flag)
{
L_state l_state;
int err;
int i, elem_index = 0;
uchar_t device_off, ib_status_code, bypass_a_en, bypass_b_en;
Bp_elem_st bpf, bpr;
if ((err = l_get_status(ppath, &l_state, verbose_flag)) != 0) {
(void) print_errString(err, ppath);
return (err);
}
for (i = 0; i < (int)l_state.ib_tbl.config.enc_num_elem; i++) {
elem_index++;
if (l_state.ib_tbl.config.type_hdr[i].type == ELM_TYP_BP) {
break;
}
elem_index += l_state.ib_tbl.config.type_hdr[i].num;
}
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index]),
(void *)&bpf, sizeof (bpf));
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index + 1]),
(void *)&bpr, sizeof (bpr));
if (fr_flag) {
device_off = l_state.drv_front[slot].ib_status.dev_off;
bypass_a_en = l_state.drv_front[slot].ib_status.bypass_a_en;
bypass_b_en = l_state.drv_front[slot].ib_status.bypass_b_en;
ib_status_code = l_state.drv_front[slot].ib_status.code;
} else {
device_off = l_state.drv_rear[slot].ib_status.dev_off;
bypass_a_en = l_state.drv_rear[slot].ib_status.bypass_a_en;
bypass_b_en = l_state.drv_rear[slot].ib_status.bypass_b_en;
ib_status_code = l_state.drv_rear[slot].ib_status.code;
}
if (device_off) {
(void) fprintf(stdout,
MSGSTR(2000,
"%s is offlined and bypassed.\n"
" Could not get device specific"
" information.\n\n"),
devname);
} else if (bypass_a_en && bypass_b_en) {
(void) fprintf(stdout,
MSGSTR(2001,
"%s is bypassed (Port:AB).\n"
" Could not get device specific"
" information.\n\n"),
devname);
} else if (ib_status_code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(2002,
"Slot %s is empty.\n\n"),
devname);
} else if (((bpf.code != S_NOT_INSTALLED) &&
((bpf.byp_a_enabled || bpf.en_bypass_a) &&
(bpf.byp_b_enabled || bpf.en_bypass_b))) ||
((bpr.code != S_NOT_INSTALLED) &&
((bpr.byp_a_enabled || bpr.en_bypass_a) &&
(bpr.byp_b_enabled || bpr.en_bypass_b)))) {
(void) fprintf(stdout,
MSGSTR(2003,
"Backplane(Port:AB) is bypassed.\n"
" Could not get device specific"
" information for"
" %s.\n\n"), devname);
} else {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
devname);
}
return (-1);
}
void
print_errString(int errnum, char *devpath)
{
char *errStr;
errStr = g_get_errString(errnum);
if (devpath == NULL) {
(void) fprintf(stderr,
"%s \n\n", errStr);
} else {
(void) fprintf(stderr,
"%s - %s.\n\n", errStr, devpath);
}
if (errStr != NULL)
(void) free(errStr);
}
int
adm_inquiry(char **argv)
{
L_inquiry inq;
L_inquiry80 inq80;
size_t serial_len;
int path_index = 0, retval = 0;
int slot, f_r, err = 0, argpwwn, argnwwn;
char inq_path[MAXNAMELEN];
char *path_phys = NULL, *ptr;
Path_struct *path_struct;
WWN_list *wwn_list, *wwn_list_ptr, *list_start;
char last_logical_path[MAXPATHLEN];
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) strcpy(inq_path, argv[path_index]);
if (((ptr = strstr(inq_path, ",")) != NULL) &&
((*(ptr + 1) == 'f') || (*(ptr + 1) == 'r') ||
(*(ptr +1) == 's'))) {
if (err != -1) {
(void) print_errString(err, argv[path_index]);
path_index++;
retval++;
continue;
}
*ptr = '\0';
slot = path_struct->slot;
f_r = path_struct->f_flag;
path_phys = NULL;
if ((err = l_convert_name(inq_path, &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
}
path_index++;
retval++;
continue;
}
if ((err = print_devState(argv[path_index],
path_struct->p_physical_path,
f_r, slot, Options & PVERBOSE)) != 0) {
path_index++;
retval++;
continue;
}
} else {
if (err != -1) {
(void) print_errString(err, argv[path_index]);
} else {
(void) fprintf(stderr, "\n ");
(void) fprintf(stderr,
MSGSTR(112, "Error: Invalid pathname (%s)"),
argv[path_index]);
(void) fprintf(stderr, "\n");
}
}
path_index++;
retval++;
continue;
}
if (strstr(argv[path_index], "/") != NULL) {
if (err = g_get_inquiry(path_phys, &inq)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
path_index++;
retval++;
continue;
}
serial_len = sizeof (inq80.inq_serial);
if (err = g_get_serial_number(path_phys, inq80.inq_serial,
&serial_len)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
path_index++;
retval++;
continue;
}
print_inq_data(argv[path_index], path_phys, inq,
inq80.inq_serial, serial_len);
path_index++;
continue;
}
if ((err = g_get_wwn_list(&wwn_list, 0)) != 0) {
return (err);
}
g_sort_wwn_list(&wwn_list);
list_start = wwn_list;
argpwwn = argnwwn = 0;
(void) strcpy(last_logical_path, path_phys);
for (wwn_list_ptr = wwn_list; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (strcasecmp(wwn_list_ptr->port_wwn_s, path_struct->argv) ==
0) {
list_start = wwn_list_ptr;
argpwwn = 1;
break;
} else if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) == 0) {
list_start = wwn_list_ptr;
argnwwn = 1;
break;
}
}
if (!(argpwwn || argnwwn)) {
if (err = g_get_inquiry(path_phys, &inq)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
path_index++;
retval++;
continue;
}
serial_len = sizeof (inq80.inq_serial);
if (err = g_get_serial_number(path_phys, inq80.inq_serial,
&serial_len)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
path_index++;
retval++;
continue;
}
print_inq_data(argv[path_index], path_phys, inq,
inq80.inq_serial, serial_len);
(void) g_free_wwn_list(&wwn_list);
path_index++;
continue;
}
for (wwn_list_ptr = list_start; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (argpwwn) {
if (strcasecmp(wwn_list_ptr->port_wwn_s,
path_struct->argv) != 0) {
continue;
}
(void) strcpy(path_phys,
wwn_list_ptr->physical_path);
} else if (argnwwn) {
if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) != 0) {
continue;
}
if (strstr(wwn_list_ptr->logical_path,
last_logical_path) != NULL) {
continue;
}
(void) strcpy(path_phys,
wwn_list_ptr->physical_path);
(void) strcpy(last_logical_path,
wwn_list_ptr->logical_path);
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
retval++;
break;
}
serial_len = sizeof (inq80.inq_serial);
if (err = g_get_serial_number(path_phys, inq80.inq_serial,
&serial_len)) {
(void) fprintf(stderr, "\n");
(void) print_errString(err, argv[path_index]);
(void) fprintf(stderr, "\n");
retval++;
break;
}
print_inq_data(argv[path_index], path_phys, inq,
inq80.inq_serial, serial_len);
}
(void) g_free_wwn_list(&wwn_list);
path_index++;
}
return (retval);
}
int
adm_forcelip(char **argv)
{
int slot, f_r, path_index = 0, err = 0, retval = 0;
Path_struct *path_struct = NULL;
char *path_phys = NULL, *ptr;
char err_path[MAXNAMELEN];
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) strcpy(err_path, argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
path_index++;
retval++;
continue;
}
if (((ptr = strstr(err_path, ", ")) != NULL) &&
((*(ptr + 1) == 'f') || (*(ptr + 1) == 'r') ||
(*(ptr +1) == 's'))) {
*ptr = '\0';
slot = path_struct->slot;
f_r = path_struct->f_flag;
path_phys = NULL;
if ((err = l_convert_name(err_path,
&path_phys, &path_struct,
Options & PVERBOSE)) != 0) {
(void) fprintf(stderr, MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
}
path_index++;
retval++;
continue;
}
if ((err = print_devState(argv[path_index],
path_struct->p_physical_path,
f_r, slot, Options & PVERBOSE)) != 0) {
path_index++;
retval++;
continue;
}
} else {
(void) fprintf(stderr, "\n ");
(void) fprintf(stderr, MSGSTR(112,
"Error: Invalid pathname (%s)"),
argv[path_index]);
(void) fprintf(stderr, "\n");
}
path_index++;
retval++;
continue;
}
if (err = g_force_lip(path_phys, Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
path_index++;
retval++;
continue;
}
path_index++;
if (path_struct != NULL) {
(void) free(path_struct);
}
}
return (retval);
}
int
adm_display_config(char **argv)
{
L_inquiry inq, ses_inq;
int i, slot, f_r, path_index = 0, err = 0, opnerr = 0;
int retval = 0;
gfc_map_t map;
Path_struct *path_struct;
char *path_phys = NULL, *ptr;
char ses_path[MAXPATHLEN], inq_path[MAXNAMELEN];
while (argv[path_index] != NULL) {
VERBPRINT(MSGSTR(2108, " Displaying information for: %s\n"),
argv[path_index]);
map.dev_addr = (gfc_port_dev_info_t *)NULL;
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
if (strstr(argv[path_index], SCSI_VHCI) == NULL) {
(void) strcpy(inq_path, argv[path_index]);
if (((ptr = strstr(inq_path, ",")) != NULL) &&
((*(ptr + 1) == 'f') || (*(ptr + 1) == 'r') ||
(*(ptr +1) == 's'))) {
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
path_index++;
retval++;
continue;
}
*ptr = '\0';
slot = path_struct->slot;
f_r = path_struct->f_flag;
if ((err = l_convert_name(inq_path, &path_phys,
&path_struct, Options & PVERBOSE))
!= 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
}
path_index++;
retval++;
continue;
}
if ((err = print_devState(argv[path_index],
path_struct->p_physical_path,
f_r, slot, Options & PVERBOSE)) != 0) {
path_index++;
retval++;
continue;
}
} else {
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
} else {
(void) fprintf(stderr, "\n ");
(void) fprintf(stderr,
MSGSTR(112,
"Error: Invalid pathname (%s)"),
argv[path_index]);
(void) fprintf(stderr, "\n");
}
}
} else {
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
} else {
(void) fprintf(stderr, "\n ");
(void) fprintf(stderr,
MSGSTR(112,
"Error: Invalid pathname (%s)"),
argv[path_index]);
(void) fprintf(stderr, "\n");
}
}
path_index++;
retval++;
continue;
}
if ((opnerr = g_get_inquiry(path_phys, &inq)) != 0) {
if (opnerr == L_OPEN_PATH_FAIL) {
(void) print_errString(errno, argv[path_index]);
path_index++;
retval++;
continue;
}
} else if (!g_enclDiskChk((char *)inq.inq_vid,
(char *)inq.inq_pid)) {
if ((err = lun_display(path_struct,
inq, Options & PVERBOSE)) != 0) {
(void) print_errString(err, path_phys);
exit(1);
}
} else if (strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) != NULL) {
(void) fprintf(stdout, "\n\t\t\t\t ");
print_chars(inq.inq_pid, sizeof (inq.inq_pid), 0);
(void) fprintf(stdout, "\n");
if (Options & OPTION_R) {
adm_display_err(path_phys,
(inq.inq_dtype & DTYPE_MASK));
} else {
pho_display_config(path_phys);
}
} else if ((((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI)) &&
(l_get_enc_type(inq) == DAK_ENC_TYPE)) {
(void) fprintf(stdout, "\n\t\t");
for (i = 0; i < sizeof (inq.inq_pid); i++) {
(void) fprintf(stdout, "%c", inq.inq_pid[i]);
}
(void) fprintf(stdout, "\n");
if (Options & OPTION_R) {
adm_display_err(path_phys,
(inq.inq_dtype & DTYPE_MASK));
} else {
dpm_display_config(path_phys);
}
} else if (((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) &&
((path_struct->slot_valid == 1) ||
((g_get_dev_map(path_phys, &map,
(Options & PVERBOSE)) == 0) &&
(l_get_ses_path(path_phys, ses_path,
&map, Options & PVERBOSE) == 0) &&
(g_get_inquiry(ses_path, &ses_inq) == 0) &&
((strstr((char *)ses_inq.inq_pid, ENCLOSURE_PROD_ID)
!= NULL))))) {
if (Options & OPTION_R) {
adm_display_err(path_phys,
(inq.inq_dtype & DTYPE_MASK));
} else {
display_fc_disk(path_struct, ses_path, &map, inq,
Options & PVERBOSE);
}
} else if (strstr((char *)inq.inq_pid, "SUN_SEN") != 0) {
if (strcmp(argv[path_index], path_phys) != 0) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(5, "Physical Path:"));
(void) fprintf(stdout, "\n %s\n", path_phys);
}
(void) fprintf(stdout, MSGSTR(2109, "DEVICE is a "));
print_chars(inq.inq_vid, sizeof (inq.inq_vid), 1);
(void) fprintf(stdout, " ");
print_chars(inq.inq_pid, sizeof (inq.inq_pid), 1);
(void) fprintf(stdout, MSGSTR(2110, " card."));
if (inq.inq_len > 31) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(26, "Revision:"));
(void) fprintf(stdout, " ");
print_chars(inq.inq_revision,
sizeof (inq.inq_revision), 0);
}
(void) fprintf(stdout, "\n");
} else if ((inq.inq_dtype & DTYPE_MASK) < 0x10) {
switch ((inq.inq_dtype & DTYPE_MASK)) {
case DTYPE_DIRECT:
case DTYPE_SEQUENTIAL:
if (Options & OPTION_R) {
adm_display_err(path_phys,
(inq.inq_dtype & DTYPE_MASK));
} else if (non_encl_fc_disk_display(path_struct,
inq, Options & PVERBOSE) != 0) {
(void) fprintf(stderr,
MSGSTR(2111,
"Error: getting the device"
" information.\n"));
retval++;
}
break;
default:
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(35,
"Device Type:"));
(void) fprintf(stdout, "%s\n",
dtype[inq.inq_dtype & DTYPE_MASK]);
break;
}
} else if ((inq.inq_dtype & DTYPE_MASK) < 0x1f) {
(void) fprintf(stdout,
MSGSTR(2112, " Device type: Reserved"));
(void) fprintf(stdout, "\n");
} else {
(void) fprintf(stdout,
MSGSTR(2113, " Device type: Unknown device"));
(void) fprintf(stdout, "\n");
}
path_index++;
if (map.dev_addr != NULL) {
free((void *)map.dev_addr);
}
(void) free(path_struct);
}
return (retval);
}
int
adm_power_off(char **argv, int off_flag)
{
int path_index = 0, err = 0, retval = 0;
L_inquiry inq;
char *path_phys = NULL;
Path_struct *path_struct;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
if (path_struct->ib_path_flag) {
path_phys = path_struct->p_physical_path;
} else {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
}
path_index++;
retval++;
continue;
}
}
if (path_struct->ib_path_flag) {
if (err = l_dev_pwr_up_down(path_phys,
path_struct, off_flag, Options & PVERBOSE,
Options & OPTION_CAPF)) {
print_devState(argv[path_index],
path_struct->p_physical_path,
path_struct->f_flag, path_struct->slot,
Options & PVERBOSE);
retval++;
}
path_index++;
continue;
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
path_index++;
retval++;
continue;
}
if ((strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) != 0) ||
(strncmp((char *)inq.inq_vid, "SUN ",
sizeof (inq.inq_vid)) &&
((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI))) {
if (get_enclStatus(path_phys, argv[path_index],
off_flag) != 0) {
path_index++;
retval++;
continue;
}
if (err = l_pho_pwr_up_down(argv[path_index], path_phys,
off_flag, Options & PVERBOSE,
Options & OPTION_CAPF)) {
(void) print_errString(err, argv[path_index]);
retval++;
}
} else if ((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) {
if (err = l_dev_pwr_up_down(path_phys,
path_struct, off_flag, Options & PVERBOSE,
Options & OPTION_CAPF)) {
(void) print_errString(err, argv[path_index]);
retval++;
}
} else {
(void) print_errString(L_INVALID_PATH,
argv[path_index]);
}
path_index++;
}
return (retval);
}
void
adm_bypass_enable(char **argv, int bypass_flag)
{
int path_index = 0, err = 0;
L_inquiry inq;
char *path_phys = NULL;
Path_struct *path_struct;
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
if (path_struct->ib_path_flag) {
path_phys = path_struct->p_physical_path;
} else {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
}
if (path_struct->ib_path_flag) {
if (Options & OPTION_F) {
E_USEAGE();
exit(-1);
}
if (err = l_dev_bypass_enable(path_struct,
bypass_flag, OPTION_CAPF,
Options & OPTION_A,
Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
return;
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) != 0) ||
(strncmp((char *)inq.inq_vid, "SUN ",
sizeof (inq.inq_vid)) &&
((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI))) {
if ((!((Options & OPTION_F) ||
(Options & OPTION_R))) ||
((Options & OPTION_R) &&
(Options & OPTION_F))) {
E_USEAGE();
exit(-1);
}
if (err = l_bp_bypass_enable(path_phys, bypass_flag,
Options & OPTION_A,
Options & OPTION_F,
Options & OPTION_CAPF,
Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
} else if ((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) {
if (Options & OPTION_F) {
E_USEAGE();
exit(-1);
}
if (err = l_dev_bypass_enable(path_struct,
bypass_flag, Options & OPTION_CAPF,
Options & OPTION_A,
Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
}
}
void
adm_download(char **argv, char *file_name)
{
int path_index = 0, err = 0;
char *path_phys = NULL;
L_inquiry inq;
Path_struct *path_struct;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) != 0) ||
(strncmp((char *)inq.inq_vid, "SUN ",
sizeof (inq.inq_vid)) &&
((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI))) {
if (err = l_download(path_phys,
file_name, (Options & SAVE),
(Options & PVERBOSE))) {
(void) print_errString(err,
(err == L_OPEN_PATH_FAIL) ?
argv[path_index]: file_name);
exit(-1);
}
} else {
(void) fprintf(stderr,
MSGSTR(112, "Error: Invalid pathname (%s)"),
argv[path_index]);
}
path_index++;
}
}
void
display_link_status(char **argv)
{
AL_rls *rls = NULL, *n;
int path_index = 0, err = 0;
char *path_phys = NULL;
Path_struct *path_struct;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (err = g_rdls(path_phys, &rls, Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
n = rls;
if (n != NULL) {
(void) fprintf(stdout,
MSGSTR(2007, "\nLink Error Status "
"information for loop:%s\n"),
n->driver_path);
(void) fprintf(stdout, MSGSTR(2008, "al_pa lnk fail "
" sync loss signal loss sequence err"
" invalid word CRC\n"));
}
while (n) {
if ((n->payload.rls_linkfail == 0xffffffff) &&
(n->payload.rls_syncfail == 0xffffffff) &&
(n->payload.rls_sigfail == 0xffffffff) &&
(n->payload.rls_primitiverr == 0xffffffff) &&
(n->payload.rls_invalidword == 0xffffffff) &&
(n->payload.rls_invalidcrc == 0xffffffff)) {
(void) fprintf(stdout,
"%x\t%-12d%-12d%-14d%-15d%-15d%-12d\n",
n->al_ha,
n->payload.rls_linkfail,
n->payload.rls_syncfail,
n->payload.rls_sigfail,
n->payload.rls_primitiverr,
n->payload.rls_invalidword,
n->payload.rls_invalidcrc);
} else {
(void) fprintf(stdout,
"%x\t%-12u%-12u%-14u%-15u%-15u%-12u\n",
n->al_ha,
n->payload.rls_linkfail,
n->payload.rls_syncfail,
n->payload.rls_sigfail,
n->payload.rls_primitiverr,
n->payload.rls_invalidword,
n->payload.rls_invalidcrc);
}
n = n->next;
}
path_index++;
}
(void) fprintf(stdout,
MSGSTR(2009, "NOTE: These LESB counts are not"
" cleared by a reset, only power cycles.\n"
"These counts must be compared"
" to previously read counts.\n"));
}
int
ib_present_chk(struct l_state_struct *l_state, int which_one)
{
Ctlr_elem_st ctlr;
int i;
int elem_index = 0;
int result = 1;
for (i = 0; i < (int)l_state->ib_tbl.config.enc_num_elem; i++) {
elem_index++;
if (l_state->ib_tbl.config.type_hdr[i].type == ELM_TYP_IB) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + which_one],
(void *)&ctlr, sizeof (ctlr));
if (ctlr.code == S_NOT_INSTALLED) {
result = 0;
}
break;
}
elem_index += l_state->ib_tbl.config.type_hdr[i].num;
}
return (result);
}
void
print_individual_state(int status, int port)
{
if (status & L_OPEN_FAIL) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(28, "Open Failed"));
(void) fprintf(stdout, ") ");
} else if (status & L_NOT_READY) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(20, "Not Ready"));
(void) fprintf(stdout, ") ");
} else if (status & L_NOT_READABLE) {
(void) fprintf(stdout, "(");
(void) fprintf(stdout,
MSGSTR(88, "Not Readable"));
(void) fprintf(stdout, ") ");
} else if (status & L_SPUN_DWN_D) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(68, "Spun Down"));
(void) fprintf(stdout, ") ");
} else if (status & L_SCSI_ERR) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(70, "SCSI Error"));
(void) fprintf(stdout, ") ");
} else if (status & L_RESERVED) {
if (port == PORT_A) {
(void) fprintf(stdout,
MSGSTR(2010,
" (Rsrv cnflt:A) "));
} else if (port == PORT_B) {
(void) fprintf(stdout,
MSGSTR(2011,
" (Rsrv cnflt:B) "));
} else {
(void) fprintf(stdout,
MSGSTR(2012,
" (Reserve cnflt)"));
}
} else if (status & L_NO_LABEL) {
(void) fprintf(stdout, "(");
(void) fprintf(stdout,
MSGSTR(92, "No UNIX Label"));
(void) fprintf(stdout, ") ");
}
}
void
display_disk_msg(struct l_disk_state_struct *dsk_ptr,
struct l_state_struct *l_state, Bp_elem_st *bp, int front_flag)
{
int loop_flag = 0;
int a_and_b = 0;
int state_a = 0, state_b = 0;
if (dsk_ptr->ib_status.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
(void) fprintf(stdout, " ");
if (dsk_ptr->ib_status.fault ||
dsk_ptr->ib_status.fault_req) {
(void) fprintf(stdout, "(");
(void) fprintf(stdout,
MSGSTR(2013, "Faulted"));
(void) fprintf(stdout,
") ");
} else if (dsk_ptr->ib_status.ident ||
dsk_ptr->ib_status.rdy_to_ins ||
dsk_ptr->ib_status.rmv) {
(void) fprintf(stdout,
MSGSTR(2014,
"(LED Blinking) "));
} else {
(void) fprintf(stdout,
" ");
}
} else if (dsk_ptr->ib_status.dev_off) {
(void) fprintf(stdout, MSGSTR(2015, "Off"));
if (dsk_ptr->ib_status.fault || dsk_ptr->ib_status.fault_req) {
(void) fprintf(stdout, "(");
(void) fprintf(stdout,
MSGSTR(2016, "Faulted"));
(void) fprintf(stdout,
") ");
} else if (dsk_ptr->ib_status.bypass_a_en &&
dsk_ptr->ib_status.bypass_b_en) {
(void) fprintf(stdout,
MSGSTR(2017,
"(Bypassed:AB)"));
(void) fprintf(stdout,
" ");
} else if (dsk_ptr->ib_status.bypass_a_en) {
(void) fprintf(stdout,
MSGSTR(2018,
"(Bypassed: A)"));
(void) fprintf(stdout,
" ");
} else if (dsk_ptr->ib_status.bypass_b_en) {
(void) fprintf(stdout,
MSGSTR(2019,
"(Bypassed: B)"));
(void) fprintf(stdout,
" ");
} else {
(void) fprintf(stdout,
" ");
}
} else {
(void) fprintf(stdout, MSGSTR(2020, "On"));
if (dsk_ptr->ib_status.fault || dsk_ptr->ib_status.fault_req) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(2021, "Faulted"));
(void) fprintf(stdout, ") ");
} else if (dsk_ptr->ib_status.bypass_a_en &&
dsk_ptr->ib_status.bypass_b_en) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(2022, "(Bypassed:AB)"));
(void) fprintf(stdout, " ");
} else if (ib_present_chk(l_state, 0) &&
dsk_ptr->ib_status.bypass_a_en) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(2023, "(Bypassed: A)"));
(void) fprintf(stdout, " ");
} else if (ib_present_chk(l_state, 1) &&
dsk_ptr->ib_status.bypass_b_en) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(2024, "(Bypassed: B)"));
(void) fprintf(stdout, " ");
} else if ((bp->code != S_NOT_INSTALLED) &&
((bp->byp_a_enabled || bp->en_bypass_a) &&
!(bp->byp_b_enabled || bp->en_bypass_b))) {
(void) fprintf(stdout,
MSGSTR(2025,
" (Bypassed BP: A)"));
} else if ((bp->code != S_NOT_INSTALLED) &&
((bp->byp_b_enabled || bp->en_bypass_b) &&
!(bp->byp_a_enabled || bp->en_bypass_a))) {
(void) fprintf(stdout,
MSGSTR(2026,
"(Bypassed BP: B)"));
} else if ((bp->code != S_NOT_INSTALLED) &&
((bp->byp_a_enabled || bp->en_bypass_a) &&
(bp->byp_b_enabled || bp->en_bypass_b))) {
(void) fprintf(stdout,
MSGSTR(2027,
"(Bypassed BP:AB)"));
} else {
state_a = dsk_ptr->g_disk_state.d_state_flags[PORT_A];
state_b = dsk_ptr->g_disk_state.d_state_flags[PORT_B];
a_and_b = state_a & state_b;
if (dsk_ptr->l_state_flag & L_NO_LOOP) {
(void) fprintf(stdout,
MSGSTR(2028,
" (Loop not accessible)"));
loop_flag = 1;
} else if (dsk_ptr->l_state_flag & L_INVALID_WWN) {
(void) fprintf(stdout,
MSGSTR(2029,
" (Invalid WWN) "));
} else if (dsk_ptr->l_state_flag & L_INVALID_MAP) {
(void) fprintf(stdout,
MSGSTR(2030,
" (Login failed) "));
} else if (dsk_ptr->l_state_flag & L_NO_PATH_FOUND) {
(void) fprintf(stdout,
MSGSTR(2031,
" (No path found)"));
} else if (a_and_b) {
print_individual_state(a_and_b, PORT_A_B);
} else if (state_a && (!state_b)) {
print_individual_state(state_a, PORT_A);
} else if ((!state_a) && state_b) {
print_individual_state(state_b, PORT_B);
} else if (state_a || state_b) {
print_individual_state(state_a | state_b,
PORT_A_B);
} else {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(29, "O.K."));
(void) fprintf(stdout,
") ");
}
}
if (loop_flag) {
(void) fprintf(stdout, " ");
} else if (strlen(dsk_ptr->g_disk_state.node_wwn_s)) {
(void) fprintf(stdout, "%s",
dsk_ptr->g_disk_state.node_wwn_s);
} else {
(void) fprintf(stdout, " ");
}
}
if (front_flag) {
(void) fprintf(stdout, " ");
}
}
void
pho_display_config(char *path_phys)
{
L_state l_state;
Bp_elem_st bpf, bpr;
int i, j, elem_index = 0, err = 0;
if (err = l_get_status(path_phys, &l_state,
(Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (l_state.ib_tbl.p2_s.ui.ab_cond) {
abnormal_condition_display(&l_state);
}
(void) fprintf(stdout,
MSGSTR(2032, " DISK STATUS \n"
"SLOT FRONT DISKS (Node WWN) "
" REAR DISKS (Node WWN)\n"));
for (j = 0; j < (int)l_state.ib_tbl.config.enc_num_elem; j++) {
elem_index++;
if (l_state.ib_tbl.config.type_hdr[j].type == ELM_TYP_BP)
break;
elem_index += l_state.ib_tbl.config.type_hdr[j].num;
}
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index]),
(void *)&bpf, sizeof (bpf));
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index + 1]),
(void *)&bpr, sizeof (bpr));
for (i = 0; i < (int)l_state.total_num_drv/2; i++) {
(void) fprintf(stdout, "%-2d ", i);
display_disk_msg(&l_state.drv_front[i], &l_state, &bpf, 1);
display_disk_msg(&l_state.drv_rear[i], &l_state, &bpr, 0);
(void) fprintf(stdout, "\n");
}
(void) fprintf(stdout,
MSGSTR(2242,
" SUBSYSTEM STATUS\nFW Revision:"));
print_chars(l_state.ib_tbl.config.prod_revision,
sizeof (l_state.ib_tbl.config.prod_revision), 1);
(void) fprintf(stdout, MSGSTR(2034, " Box ID:%d"),
l_state.ib_tbl.box_id);
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(90, "Node WWN:"));
for (i = 0; i < 8; i++) {
(void) fprintf(stdout, "%1.2x",
l_state.ib_tbl.config.enc_node_wwn[i]);
}
if (strlen((const char *)l_state.ib_tbl.enclosure_name) <=
sizeof (l_state.ib_tbl.enclosure_name)) {
(void) fprintf(stdout, MSGSTR(2035, " Enclosure Name:%s\n"),
l_state.ib_tbl.enclosure_name);
}
elem_index = 0;
for (i = 0; i < (int)l_state.ib_tbl.config.enc_num_elem; i++) {
elem_index++;
switch (l_state.ib_tbl.config.type_hdr[i].type) {
case ELM_TYP_PS:
ps_messages(&l_state, i, elem_index);
break;
case ELM_TYP_FT:
fan_messages(&l_state, i, elem_index);
break;
case ELM_TYP_BP:
back_plane_messages(&l_state, i, elem_index);
break;
case ELM_TYP_IB:
ctlr_messages(&l_state, i, elem_index);
break;
case ELM_TYP_LN:
if (l_state.ib_tbl.config.type_hdr[i].text_len != 0) {
(void) fprintf(stdout, "%s\t",
l_state.ib_tbl.config.text[i]);
}
break;
case ELM_TYP_LO:
loop_messages(&l_state, i, elem_index);
break;
case ELM_TYP_MB:
mb_messages(&l_state, i, elem_index);
break;
}
elem_index += l_state.ib_tbl.config.type_hdr[i].num;
}
(void) fprintf(stdout, "\n");
}
void
dpm_display_config(char *path_phys)
{
L_state l_state;
Bp_elem_st bpf, bpr;
int i, j, elem_index = 0, err = 0, count;
if (err = l_get_status(path_phys, &l_state,
(Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (l_state.ib_tbl.p2_s.ui.ab_cond) {
abnormal_condition_display(&l_state);
}
(void) fprintf(stdout,
MSGSTR(2247, " DISK STATUS \n"
"SLOT DISKS (Node WWN) \n"));
for (j = 0; j < (int)l_state.ib_tbl.config.enc_num_elem; j++) {
elem_index++;
if (l_state.ib_tbl.config.type_hdr[j].type == ELM_TYP_BP)
break;
elem_index += l_state.ib_tbl.config.type_hdr[j].num;
}
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index]),
(void *)&bpf, sizeof (bpf));
(void) bcopy((const void *)
&(l_state.ib_tbl.p2_s.element[elem_index + 1]),
(void *)&bpr, sizeof (bpr));
for (i = 0, count = 0;
i < (int)l_state.total_num_drv/2;
i++, count++) {
(void) fprintf(stdout, "%-2d ", count);
display_disk_msg(&l_state.drv_front[i], &l_state, &bpf, 1);
(void) fprintf(stdout, "\n");
}
for (i = 0; i < (int)l_state.total_num_drv/2; i++, count++) {
(void) fprintf(stdout, "%-2d ", count);
display_disk_msg(&l_state.drv_rear[i], &l_state, &bpf, 1);
(void) fprintf(stdout, "\n");
}
(void) fprintf(stdout,
MSGSTR(2033,
"\t\tSUBSYSTEM STATUS\nFW Revision:"));
for (i = 0; i < sizeof (l_state.ib_tbl.config.prod_revision); i++) {
(void) fprintf(stdout, "%c",
l_state.ib_tbl.config.prod_revision[i]);
}
(void) fprintf(stdout, MSGSTR(2034, " Box ID:%d"),
l_state.ib_tbl.box_id);
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout, MSGSTR(90, "Node WWN:"));
for (i = 0; i < 8; i++) {
(void) fprintf(stdout, "%1.2x",
l_state.ib_tbl.config.enc_node_wwn[i]);
}
if (strlen((const char *)l_state.ib_tbl.enclosure_name) <=
sizeof (l_state.ib_tbl.enclosure_name)) {
(void) fprintf(stdout, MSGSTR(2035, " Enclosure Name:%s\n"),
l_state.ib_tbl.enclosure_name);
}
elem_index = 0;
for (i = 0; i < (int)l_state.ib_tbl.config.enc_num_elem; i++) {
elem_index++;
switch (l_state.ib_tbl.config.type_hdr[i].type) {
case ELM_TYP_PS:
ps_messages(&l_state, i, elem_index);
break;
case ELM_TYP_FT:
fan_messages(&l_state, i, elem_index);
break;
case ELM_TYP_BP:
dpm_SSC100_messages(&l_state, i, elem_index);
break;
case ELM_TYP_IB:
ctlr_messages(&l_state, i, elem_index);
break;
case ELM_TYP_LN:
if (l_state.ib_tbl.config.type_hdr[i].text_len != 0) {
(void) fprintf(stdout, "%s\t",
l_state.ib_tbl.config.text[i]);
}
break;
case ELM_TYP_LO:
loop_messages(&l_state, i, elem_index);
break;
case ELM_TYP_MB:
mb_messages(&l_state, i, elem_index);
break;
case ELM_TYP_FL:
trans_messages(&l_state, 1);
break;
}
elem_index += l_state.ib_tbl.config.type_hdr[i].num;
}
(void) fprintf(stdout, "\n");
}
void
intfix(void)
{
if (termio_fd) {
termios.c_lflag |= ECHO;
ioctl(termio_fd, TCSETS, &termios);
}
exit(SIGINT);
}
void
up_password(char **argv)
{
int path_index = 0, err = 0;
char password[1024];
char input[1024];
int i, j, matched, equal;
L_inquiry inq;
void (*sig)();
char *path_phys = NULL;
Path_struct *path_struct;
if ((termio_fd = open("/dev/tty", O_RDONLY)) == -1) {
(void) fprintf(stderr,
MSGSTR(2036, "Error: tty open failed.\n"));
exit(-1);
}
ioctl(termio_fd, TCGETS, &termios);
sig = sigset(SIGINT, (void (*)())intfix);
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) == 0) &&
(!(strncmp((char *)inq.inq_vid, "SUN ",
sizeof (inq.inq_vid)) &&
((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI)))) {
(void) fprintf(stderr,
MSGSTR(2037, "Error: Enclosure is not a %s\n"),
ENCLOSURE_PROD_ID);
exit(-1);
}
(void) fprintf(stdout,
MSGSTR(2038,
"Changing FPM password for subsystem %s\n"),
argv[path_index]);
equal = 0;
while (!equal) {
memset(input, 0, sizeof (input));
memset(password, 0, sizeof (password));
(void) fprintf(stdout,
MSGSTR(2039, "New password: "));
termios.c_lflag &= ~ECHO;
ioctl(termio_fd, TCSETS, &termios);
(void) gets(input);
(void) fprintf(stdout,
MSGSTR(2040, "\nRe-enter new password: "));
(void) gets(password);
termios.c_lflag |= ECHO;
ioctl(termio_fd, TCSETS, &termios);
for (i = 0; input[i]; i++) {
if (!isdigit(input[i])) {
(void) fprintf(stderr,
MSGSTR(2041, "\nError: Invalid password."
" The password"
" must be 4 decimal-digit characters.\n"));
exit(-1);
}
}
if (i && (i != 4)) {
(void) fprintf(stderr,
MSGSTR(2042, "\nError: Invalid password."
" The password"
" must be 4 decimal-digit characters.\n"));
exit(-1);
}
for (j = 0; password[j]; j++) {
if (!isdigit(password[j])) {
(void) fprintf(stderr,
MSGSTR(2043, "\nError: Invalid password."
" The password"
" must be 4 decimal-digit characters.\n"));
exit(-1);
}
}
if (i != j) {
matched = -1;
} else for (i = matched = 0; password[i]; i++) {
if (password[i] == input[i]) {
matched++;
}
}
if ((matched != -1) && (matched == i)) {
equal = 1;
} else {
(void) fprintf(stdout,
MSGSTR(2044, "\npassword: They don't match;"
" try again.\n"));
}
}
(void) fprintf(stdout, "\n");
sscanf(input, "%s", password);
(void) signal(SIGINT, sig);
if (l_new_password(path_phys, input)) {
(void) print_errString(err, path_phys);
exit(-1);
}
}
void
adm_failover(char **argv)
{
int path_index = 0, err = 0;
char pathclass[20];
char *path_phys = NULL;
(void) memset(pathclass, 0, sizeof (pathclass));
(void) strcpy(pathclass, argv[path_index++]);
if ((strcmp(pathclass, "primary") != 0) &&
(strcmp(pathclass, "secondary") != 0)) {
(void) fprintf(stderr,
MSGSTR(2300, "Incorrect pathclass\n"));
exit(-1);
}
while (argv[path_index] != NULL) {
path_phys = g_get_physical_name(argv[path_index++]);
if ((path_phys == NULL) ||
(strstr(path_phys, SCSI_VHCI) == NULL)) {
(void) fprintf(stderr,
MSGSTR(2301, "Incorrect pathname\n"));
exit(-1);
}
if (err = g_failover(path_phys, pathclass)) {
(void) print_errString(err, NULL);
exit(-1);
}
}
}
void
up_encl_name(char **argv, int argc)
{
int i, rval, al_pa, path_index = 0, err = 0;
L_inquiry inq;
Box_list *b_list = NULL;
uchar_t node_wwn[WWN_SIZE], port_wwn[WWN_SIZE];
char wwn1[(WWN_SIZE*2)+1], name[1024], *path_phys = NULL;
Path_struct *path_struct;
(void) memset(name, 0, sizeof (name));
(void) memset(&inq, 0, sizeof (inq));
(void) sscanf(argv[path_index++], "%s", name);
for (i = 0; name[i]; i++) {
if ((!isalnum(name[i]) &&
((name[i] != '#') &&
(name[i] != '-') &&
(name[i] != '_') &&
(name[i] != '.'))) || i >= 16) {
(void) fprintf(stderr,
MSGSTR(2045, "Error: Invalid enclosure name.\n"));
(void) fprintf(stderr, MSGSTR(2046,
"Usage: %s [-v] subcommand {a name consisting of"
" 1-16 alphanumeric characters}"
" {enclosure... | pathname...}\n"), whoami);
exit(-1);
}
}
if (((Options & PVERBOSE) && (argc != 5)) ||
(!(Options & PVERBOSE) && (argc != 4))) {
(void) fprintf(stderr,
MSGSTR(114, "Error: Incorrect number of arguments.\n"));
(void) fprintf(stderr, MSGSTR(2047,
"Usage: %s [-v] subcommand {a name consisting of"
" 1-16 alphanumeric characters}"
" {enclosure... | pathname...}\n"), whoami);
exit(-1);
}
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((strstr((char *)inq.inq_pid, ENCLOSURE_PROD_ID) == 0) &&
(!(strncmp((char *)inq.inq_vid, "SUN ",
sizeof (inq.inq_vid)) &&
((inq.inq_dtype & DTYPE_MASK) == DTYPE_ESI)))) {
(void) fprintf(stderr,
MSGSTR(2048, "Error: Pathname does not point to a %s"
" enclosure\n"), ENCLOSURE_PROD_NAME);
exit(-1);
}
if (err = g_get_wwn(path_phys, port_wwn, node_wwn, &al_pa,
Options & PVERBOSE)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
for (i = 0; i < WWN_SIZE; i++) {
(void) sprintf(&wwn1[i << 1], "%02x", node_wwn[i]);
}
if ((err = l_get_box_list(&b_list, Options & PVERBOSE)) != 0) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if (b_list == NULL) {
(void) fprintf(stdout,
MSGSTR(93, "No %s enclosures found "
"in /dev/es\n"), ENCLOSURE_PROD_NAME);
exit(-1);
} else if (l_duplicate_names(b_list, wwn1, name,
Options & PVERBOSE)) {
(void) fprintf(stderr,
MSGSTR(2049, "Warning: The name you selected, %s,"
" is already being used.\n"
"Please choose a unique name.\n"
"You can use the \"probe\" subcommand to"
" see all of the enclosure names.\n"),
name);
(void) l_free_box_list(&b_list);
exit(-1);
}
(void) l_free_box_list(&b_list);
if (rval = l_new_name(path_phys, name)) {
(void) print_errString(rval, path_phys);
exit(-1);
}
if (Options & PVERBOSE) {
(void) fprintf(stdout,
MSGSTR(2050, "The enclosure has been renamed to %s\n"),
name);
}
}
static int
get_enclStatus(char *phys_path, char *encl_name, int off_flag)
{
int found_pwrOnDrv = 0, slot;
int found_pwrOffDrv = 0, err = 0;
L_state l_state;
if ((err = l_get_status(phys_path,
&l_state, Options & PVERBOSE)) != 0) {
(void) print_errString(err, encl_name);
return (err);
}
if (off_flag) {
for (slot = 0; slot < l_state.total_num_drv/2;
slot++) {
if (((l_state.drv_front[slot].ib_status.code !=
S_NOT_INSTALLED) &&
(!l_state.drv_front[slot].ib_status.dev_off)) ||
((l_state.drv_rear[slot].ib_status.code !=
S_NOT_INSTALLED) &&
(!l_state.drv_rear[slot].ib_status.dev_off))) {
found_pwrOnDrv++;
break;
}
}
if (!found_pwrOnDrv) {
(void) fprintf(stdout,
MSGSTR(2051,
"Notice: Drives in enclosure"
" \"%s\" have already been"
" powered off.\n\n"),
encl_name);
return (-1);
}
} else {
for (slot = 0; slot < l_state.total_num_drv/2;
slot++) {
if (((l_state.drv_front[slot].ib_status.code !=
S_NOT_INSTALLED) &&
(l_state.drv_front[slot].ib_status.dev_off)) ||
((l_state.drv_rear[slot].ib_status.code !=
S_NOT_INSTALLED) &&
(l_state.drv_rear[slot].ib_status.dev_off))) {
found_pwrOffDrv++;
break;
}
}
if (!found_pwrOffDrv) {
(void) fprintf(stdout,
MSGSTR(2052,
"Notice: Drives in enclosure"
" \"%s\" have already been"
" powered on.\n\n"),
encl_name);
return (-1);
}
}
return (0);
}
void
adm_led(char **argv, int led_action)
{
int path_index = 0, err = 0;
gfc_map_t map;
L_inquiry inq;
Dev_elem_st status;
char *path_phys = NULL;
Path_struct *path_struct;
int enc_t = 0;
char ses_path[MAXPATHLEN];
L_inquiry ses_inq;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
if (path_struct->ib_path_flag) {
path_phys = path_struct->p_physical_path;
} else {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err,
argv[path_index]);
}
exit(-1);
}
}
if (!path_struct->ib_path_flag) {
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((inq.inq_dtype & DTYPE_MASK) != DTYPE_DIRECT) {
(void) fprintf(stderr,
MSGSTR(2053,
"Error: pathname must be to a disk device.\n"
" %s\n"), argv[path_index]);
exit(-1);
}
}
if (err = g_get_dev_map(path_phys, &map,
(Options & PVERBOSE))) {
(void) print_errString(err, argv[path_index]);
}
if (led_action == L_LED_ON) {
(void) fprintf(stderr, MSGSTR(2054,
"The led_on functionality is not applicable "
"to this subsystem.\n"));
exit(-1);
}
if (err = l_led(path_struct, led_action, &status,
(Options & PVERBOSE))) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if (l_get_ses_path(path_phys, ses_path, &map,
(Options & PVERBOSE)) == 0) {
if (g_get_inquiry(ses_path, &ses_inq) == 0) {
enc_t = l_get_enc_type(ses_inq);
}
}
switch (led_action) {
case L_LED_STATUS:
if (status.fault || status.fault_req) {
if (!path_struct->slot_valid) {
(void) fprintf(stdout,
MSGSTR(2055, "LED state is ON for "
"device:\n %s\n"), path_phys);
} else {
if (enc_t == DAK_ENC_TYPE) {
if (path_struct->f_flag) {
(void) fprintf(stdout,
MSGSTR(2236, "LED state is ON for "
"device in location: slot %d\n"),
path_struct->slot);
} else {
(void) fprintf(stdout,
MSGSTR(2236, "LED state is ON for "
"device in location: slot %d\n"),
path_struct->slot +
(MAX_DRIVES_DAK/2));
}
} else {
(void) fprintf(stdout,
(path_struct->f_flag) ?
MSGSTR(2056, "LED state is ON for "
"device in location: front,slot %d\n")
: MSGSTR(2057, "LED state is ON for "
"device in location: rear,slot %d\n"),
path_struct->slot);
}
}
} else if (status.ident || status.rdy_to_ins ||
status.rmv) {
if (!path_struct->slot_valid) {
(void) fprintf(stdout, MSGSTR(2058,
"LED state is BLINKING for "
"device:\n %s\n"), path_phys);
} else {
if (enc_t == DAK_ENC_TYPE) {
if (path_struct->f_flag) {
(void) fprintf(stdout, MSGSTR(2237,
"LED state is BLINKING for "
"device in location: slot %d\n"),
path_struct->slot);
} else {
(void) fprintf(stdout, MSGSTR(2237,
"LED state is BLINKING for "
"device in location: slot %d\n"),
path_struct->slot + (MAX_DRIVES_DAK/2));
}
} else {
(void) fprintf(stdout,
(path_struct->f_flag) ?
MSGSTR(2059, "LED state is BLINKING for "
"device in location: front,slot %d\n")
: MSGSTR(2060, "LED state is BLINKING for "
"device in location: rear,slot %d\n"),
path_struct->slot);
}
}
} else {
if (!path_struct->slot_valid) {
(void) fprintf(stdout,
MSGSTR(2061, "LED state is OFF for "
"device:\n %s\n"), path_phys);
} else {
if (enc_t == DAK_ENC_TYPE) {
if (path_struct->f_flag) {
(void) fprintf(stdout, MSGSTR(2238,
"LED state is OFF for "
"device in location: slot %d\n"),
path_struct->slot);
} else {
(void) fprintf(stdout, MSGSTR(2238,
"LED state is OFF for "
"device in location: slot %d\n"),
path_struct->slot + MAX_DRIVES_DAK/2);
}
} else {
(void) fprintf(stdout,
(path_struct->f_flag) ?
MSGSTR(2062, "LED state is OFF for "
"device in location: front,slot %d\n")
: MSGSTR(2063, "LED state is OFF for "
"device in location: rear,slot %d\n"),
path_struct->slot);
}
}
}
break;
}
free((void *)map.dev_addr);
path_index++;
}
}
void
dump(char **argv)
{
uchar_t *buf;
int path_index = 0, err = 0;
L_inquiry inq;
char hdr_buf[MAXNAMELEN];
Rec_diag_hdr *hdr, *hdr_ptr;
char *path_phys = NULL;
Path_struct *path_struct;
if ((hdr = (struct rec_diag_hdr *)calloc(1, MAX_REC_DIAG_LENGTH)) ==
NULL) {
(void) print_errString(L_MALLOC_FAILED, NULL);
exit(-1);
}
buf = (uchar_t *)hdr;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (err = g_get_inquiry(path_phys, &inq)) {
(void) print_errString(err, argv[path_index]);
} else {
(void) g_dump(MSGSTR(2065, "INQUIRY data: "),
(uchar_t *)&inq, 5 + inq.inq_len, HEX_ASCII);
}
(void) memset(buf, 0, MAX_REC_DIAG_LENGTH);
if (err = l_get_envsen(path_phys, buf, MAX_REC_DIAG_LENGTH,
(Options & PVERBOSE))) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
(void) fprintf(stdout,
MSGSTR(2066, "\t\tEnvironmental Sense Information\n"));
hdr_ptr = hdr;
while (hdr_ptr->page_len != 0) {
(void) sprintf(hdr_buf, MSGSTR(2067, "Page %d: "),
hdr_ptr->page_code);
(void) g_dump(hdr_buf, (uchar_t *)hdr_ptr,
HEADER_LEN + hdr_ptr->page_len, HEX_ASCII);
hdr_ptr += ((HEADER_LEN + hdr_ptr->page_len) /
sizeof (struct rec_diag_hdr));
}
path_index++;
}
(void) free(buf);
}
void
display_socal_stats(int port, char *socal_path, struct socal_stats *fc_stats)
{
int i;
int header_flag = 0;
char status_msg_buf[MAXNAMELEN];
int num_status_entries;
(void) fprintf(stdout, MSGSTR(2068,
"\tInformation for FC Loop on port %d of"
" FC100/S Host Adapter\n\tat path: %s\n"),
port, socal_path);
if (fc_stats->version > 1) {
(void) fprintf(stdout, "\t");
(void) fprintf(stdout, MSGSTR(32,
"Information from %s"), fc_stats->drvr_name);
(void) fprintf(stdout, "\n");
if ((*fc_stats->node_wwn != '\0') &&
(*fc_stats->port_wwn[port] != '\0')) {
(void) fprintf(stdout, MSGSTR(104,
" Host Adapter WWN's: Node:%s"
" Port:%s\n"),
fc_stats->node_wwn,
fc_stats->port_wwn[port]);
}
if (*fc_stats->fw_revision != '\0') {
(void) fprintf(stdout, MSGSTR(105,
" Host Adapter Firmware Revision: %s\n"),
fc_stats->fw_revision);
}
if (fc_stats->parity_chk_enabled != 0) {
(void) fprintf(stdout, MSGSTR(2069,
" This Host Adapter checks S-Bus parity.\n"));
}
}
(void) fprintf(stdout, MSGSTR(2070,
" Version Resets Req_Q_Intrpts Qfulls"
" Unsol_Resps Lips\n"));
(void) fprintf(stdout, " %4d%8d%11d%13d%10d%7d\n",
fc_stats->version,
fc_stats->resets,
fc_stats->reqq_intrs,
fc_stats->qfulls,
fc_stats->pstats[port].unsol_resps,
fc_stats->pstats[port].lips);
(void) fprintf(stdout, MSGSTR(2071,
" Els_rcvd Abts"
" Abts_ok Offlines Loop_onlines Onlines\n"));
(void) fprintf(stdout, " %4d%9d%10d%9d%13d%10d\n",
fc_stats->pstats[port].els_rcvd,
fc_stats->pstats[port].abts,
fc_stats->pstats[port].abts_ok,
fc_stats->pstats[port].offlines,
fc_stats->pstats[port].online_loops,
fc_stats->pstats[port].onlines);
if (fc_stats->version > 1) {
num_status_entries = FC_STATUS_ENTRIES;
} else {
num_status_entries = 64;
}
for (i = 0; i < num_status_entries; i++) {
if (fc_stats->pstats[port].resp_status[i] != 0) {
if (header_flag++ == 0) {
(void) fprintf(stdout, MSGSTR(2072,
" Fibre Channel Transport status:\n "
"Status Value"
" Count\n"));
}
(void) l_format_fc_status_msg(status_msg_buf,
fc_stats->pstats[port].resp_status[i], i);
(void) fprintf(stdout, " %s\n",
status_msg_buf);
}
}
}
void
display_sf_stats(char *path_phys, int dtype, struct sf_stats *sf_stats)
{
int i, al_pa, err = 0;
gfc_map_t map;
uchar_t node_wwn[WWN_SIZE];
uchar_t port_wwn[WWN_SIZE];
gfc_port_dev_info_t *dev_addr_list;
if (sf_stats->version > 1) {
(void) fprintf(stdout, "\n\t");
(void) fprintf(stdout, MSGSTR(32,
"Information from %s"),
sf_stats->drvr_name);
(void) fprintf(stdout, "\n");
} else {
(void) fprintf(stdout,
MSGSTR(2073, "\n\t\tInformation from sf driver:\n"));
}
(void) fprintf(stdout, MSGSTR(2074,
" Version Lip_count Lip_fail"
" Alloc_fail #_cmds "
"Throttle_limit Pool_size\n"));
(void) fprintf(stdout, " %4d%9d%12d%11d%10d%11d%12d\n",
sf_stats->version,
sf_stats->lip_count,
sf_stats->lip_failures,
sf_stats->cralloc_failures,
sf_stats->ncmds,
sf_stats->throttle_limit,
sf_stats->cr_pool_size);
(void) fprintf(stdout, MSGSTR(2075,
"\n\t\tTARGET ERROR INFORMATION:\n"));
(void) fprintf(stdout, MSGSTR(2076,
"AL_PA Els_fail Timouts Abts_fail"
" Tsk_m_fail "
" Data_ro_mis Dl_len_mis Logouts\n"));
if (err = g_get_dev_map(path_phys, &map, (Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (dtype == DTYPE_DIRECT) {
if (err = g_get_wwn(path_phys, port_wwn, node_wwn, &al_pa,
Options & PVERBOSE)) {
(void) print_errString(err, path_phys);
exit(-1);
}
for (i = 0, dev_addr_list = map.dev_addr; i < map.count;
i++, dev_addr_list++) {
if (dev_addr_list->gfc_port_dev.priv_port.sf_al_pa
== al_pa) {
(void) fprintf(stdout,
"%3x%10d%8d%10d%11d%13d%11d%9d\n",
al_pa,
sf_stats->tstats[i].els_failures,
sf_stats->tstats[i].timeouts,
sf_stats->tstats[i].abts_failures,
sf_stats->tstats[i].task_mgmt_failures,
sf_stats->tstats[i].data_ro_mismatches,
sf_stats->tstats[i].dl_len_mismatches,
sf_stats->tstats[i].logouts_recvd);
break;
}
}
if (i >= map.count) {
(void) print_errString(L_INVALID_LOOP_MAP, path_phys);
exit(-1);
}
} else {
for (i = 0, dev_addr_list = map.dev_addr; i < map.count;
i++, dev_addr_list++) {
(void) fprintf(stdout,
"%3x%10d%8d%10d%11d%13d%11d%9d\n",
dev_addr_list->gfc_port_dev.priv_port.sf_al_pa,
sf_stats->tstats[i].els_failures,
sf_stats->tstats[i].timeouts,
sf_stats->tstats[i].abts_failures,
sf_stats->tstats[i].task_mgmt_failures,
sf_stats->tstats[i].data_ro_mismatches,
sf_stats->tstats[i].dl_len_mismatches,
sf_stats->tstats[i].logouts_recvd);
}
}
free((void *)map.dev_addr);
}
static void
adm_display_err(char *path_phys, int dtype)
{
int i, drvr_inst, sf_inst, socal_inst, port, al_pa, err = 0;
char *char_ptr, socal_path[MAXPATHLEN], drvr_path[MAXPATHLEN];
struct stat sbuf;
kstat_ctl_t *kc;
kstat_t *ifp_ks, *sf_ks, *fc_ks;
sf_stats_t sf_stats;
socal_stats_t fc_stats;
ifp_stats_t ifp_stats;
int header_flag = 0, pathcnt = 1;
char status_msg_buf[MAXNAMELEN];
gfc_map_t map;
uchar_t node_wwn[WWN_SIZE], port_wwn[WWN_SIZE];
uint_t path_type;
gfc_port_dev_info_t *dev_addr_list;
mp_pathlist_t pathlist;
int p_on = 0, p_st = 0;
if ((kc = kstat_open()) == (kstat_ctl_t *)NULL) {
(void) fprintf(stderr,
MSGSTR(2077, " Error: can't open kstat\n"));
exit(-1);
}
if (strstr(path_phys, SCSI_VHCI)) {
(void) strcpy(drvr_path, path_phys);
if (err = g_get_pathlist(drvr_path, &pathlist)) {
(void) print_errString(err, NULL);
exit(-1);
}
pathcnt = pathlist.path_count;
p_on = p_st = 0;
for (i = 0; i < pathcnt; i++) {
if (pathlist.path_info[i].path_state < MAXPATHSTATE) {
if (pathlist.path_info[i].path_state ==
MDI_PATHINFO_STATE_ONLINE) {
p_on = i;
break;
} else if (pathlist.path_info[i].path_state ==
MDI_PATHINFO_STATE_STANDBY) {
p_st = i;
}
}
}
if (pathlist.path_info[p_on].path_state ==
MDI_PATHINFO_STATE_ONLINE) {
(void) strcpy(drvr_path,
pathlist.path_info[p_on].path_hba);
} else {
(void) strcpy(drvr_path,
pathlist.path_info[p_st].path_hba);
}
free(pathlist.path_info);
} else {
(void) strcpy(drvr_path, path_phys);
if ((char_ptr = strrchr(drvr_path, '/')) == NULL) {
(void) print_errString(L_INVLD_PATH_NO_SLASH_FND,
path_phys);
exit(-1);
}
*char_ptr = '\0';
}
path_type = g_get_path_type(drvr_path);
if (path_type) {
if ((err = g_get_nexus_path(drvr_path, &char_ptr)) != 0) {
(void) print_errString(err, path_phys);
exit(-1);
}
(void) strcpy(socal_path, char_ptr);
}
(void) strcat(drvr_path, FC_CTLR);
if (stat(drvr_path, &sbuf) < 0) {
(void) print_errString(L_LSTAT_ERROR, path_phys);
exit(-1);
}
drvr_inst = minor(sbuf.st_rdev);
if (path_type & FC4_PCI_FCA) {
if ((ifp_ks = kstat_lookup(kc, "ifp",
drvr_inst, "statistics")) != NULL) {
if (kstat_read(kc, ifp_ks, &ifp_stats) < 0) {
(void) fprintf(stderr,
MSGSTR(2082,
"Error: could not read ifp%d\n"), drvr_inst);
exit(-1);
}
(void) fprintf(stdout, MSGSTR(2083,
"\tInformation for FC Loop of"
" FC100/P Host Adapter\n\tat path: %s\n"),
drvr_path);
if (ifp_stats.version > 1) {
(void) fprintf(stdout, "\t");
(void) fprintf(stdout, MSGSTR(32,
"Information from %s"),
ifp_stats.drvr_name);
(void) fprintf(stdout, "\n");
if ((*ifp_stats.node_wwn != '\0') &&
(*ifp_stats.port_wwn != '\0')) {
(void) fprintf(stdout, MSGSTR(104,
" Host Adapter WWN's: Node:%s"
" Port:%s\n"),
ifp_stats.node_wwn,
ifp_stats.port_wwn);
}
if (*ifp_stats.fw_revision != 0) {
(void) fprintf(stdout, MSGSTR(105,
" Host Adapter Firmware Revision: %s\n"),
ifp_stats.fw_revision);
}
if (ifp_stats.parity_chk_enabled != 0) {
(void) fprintf(stdout, MSGSTR(2084,
" This Host Adapter checks "
"PCI-Bus parity.\n"));
}
}
(void) fprintf(stdout, MSGSTR(2085,
" Version Lips\n"));
(void) fprintf(stdout, " %10d%7d\n",
ifp_stats.version,
ifp_stats.lip_count);
for (i = 0; i < FC_STATUS_ENTRIES; i++) {
if (ifp_stats.resp_status[i] != 0) {
if (header_flag++ == 0) {
(void) fprintf(stdout, MSGSTR(2086,
" Fibre Channel Transport "
"status:\n "
"Status "
" Value"
" Count\n"));
}
(void) l_format_ifp_status_msg(
status_msg_buf,
ifp_stats.resp_status[i], i);
(void) fprintf(stdout, " %s\n",
status_msg_buf);
}
}
(void) fprintf(stdout, MSGSTR(2087,
"\n\t\tTARGET ERROR INFORMATION:\n"));
(void) fprintf(stdout, MSGSTR(2088,
"AL_PA logouts_recvd task_mgmt_failures"
" data_ro_mismatches data_len_mismatch\n"));
if (err = g_get_dev_map(path_phys, &map,
(Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (dtype == DTYPE_DIRECT) {
if (err = g_get_wwn(path_phys, port_wwn,
node_wwn, &al_pa,
Options & PVERBOSE)) {
(void) print_errString(err,
path_phys);
exit(-1);
}
for (i = 0, dev_addr_list = map.dev_addr;
i < map.count; i++,
dev_addr_list++) {
if (dev_addr_list->gfc_port_dev.
priv_port.sf_al_pa
== al_pa) {
(void) fprintf
(stdout,
"%3x%14d%18d%20d%20d\n",
al_pa,
ifp_stats.tstats[i].
logouts_recvd,
ifp_stats.tstats[i].
task_mgmt_failures,
ifp_stats.tstats[i].
data_ro_mismatches,
ifp_stats.tstats[i].
dl_len_mismatches);
break;
}
}
if (i >= map.count) {
(void) print_errString(
L_INVALID_LOOP_MAP, path_phys);
exit(-1);
}
} else {
for (i = 0, dev_addr_list = map.dev_addr;
i < map.count; i++,
dev_addr_list++) {
(void) fprintf(stdout,
"%3x%14d%18d%20d%20d\n",
dev_addr_list->gfc_port_dev.
priv_port.sf_al_pa,
ifp_stats.tstats[i].logouts_recvd,
ifp_stats.tstats[i].task_mgmt_failures,
ifp_stats.tstats[i].data_ro_mismatches,
ifp_stats.tstats[i].dl_len_mismatches);
}
}
free((void *)map.dev_addr);
}
} else if (path_type & FC4_SF_XPORT) {
if (stat(socal_path, &sbuf) < 0) {
(void) print_errString(L_LSTAT_ERROR, path_phys);
exit(-1);
}
socal_inst = minor(sbuf.st_rdev)/2;
port = socal_inst%2;
sf_inst = LUX_SF_MINOR2INST(minor(sbuf.st_rdev));
if (!(sf_ks = kstat_lookup(kc, "sf", sf_inst,
"statistics"))) {
(void) fprintf(stderr,
MSGSTR(2078,
" Error: could not lookup driver stats for sf%d\n"),
sf_inst);
exit(-1);
}
if (!(fc_ks = kstat_lookup(kc, "socal", socal_inst,
"statistics"))) {
(void) fprintf(stderr,
MSGSTR(2079,
" Error: could not lookup driver stats for socal%d\n"),
socal_inst);
exit(-1);
}
if (kstat_read(kc, sf_ks, &sf_stats) < 0) {
(void) fprintf(stderr,
MSGSTR(2080,
" Error: could not read driver stats for sf%d\n"),
sf_inst);
exit(-1);
}
if (kstat_read(kc, fc_ks, &fc_stats) < 0) {
(void) fprintf(stderr,
MSGSTR(2081,
" Error: could not read driver stats for socal%d\n"),
socal_inst);
exit(-1);
}
(void) display_socal_stats(port, socal_path, &fc_stats);
(void) display_sf_stats(path_phys, dtype, &sf_stats);
} else if ((path_type & FC_FCA_MASK) == FC_PCI_FCA) {
fprintf(stderr, MSGSTR(2252,
"\n WARNING!! display -r on qlc is"
" currently not supported.\n"));
} else {
fprintf(stderr, MSGSTR(2253,
"\n WARNING!! display -r is not supported on path\n"
" %s\n"), drvr_path);
}
(void) kstat_close(kc);
}
void
adm_display_verbose_disk(char *path, int verbose)
{
uchar_t *pg_buf;
Mode_header_10 *mode_header_ptr;
Mp_01 *pg1_buf;
Mp_04 *pg4_buf;
struct mode_page *pg_hdr;
int offset, hdr_printed = 0, err = 0;
if ((err = l_get_mode_pg(path, &pg_buf, verbose)) == 0) {
mode_header_ptr = (struct mode_header_10_struct *)(int)pg_buf;
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)sizeof (struct mode_header_10_struct) +
(uchar_t *)(uintptr_t)(mode_header_ptr->bdesc_length)));
offset = sizeof (struct mode_header_10_struct) +
mode_header_ptr->bdesc_length;
while (offset < (mode_header_ptr->length +
sizeof (mode_header_ptr->length))) {
switch (pg_hdr->code) {
case 0x01:
pg1_buf = (struct mode_page_01_struct *)
(int)pg_hdr;
P_DPRINTF(" adm_display_verbose_disk:"
"Mode Sense page 1 found.\n");
if (hdr_printed++ == 0) {
(void) fprintf(stdout,
MSGSTR(2089,
" Mode Sense data:\n"));
}
(void) fprintf(stdout,
MSGSTR(2090,
" AWRE:\t\t\t%d\n"
" ARRE:\t\t\t%d\n"
" Read Retry Count:\t\t"
"%d\n"
" Write Retry Count:\t\t"
"%d\n"),
pg1_buf->awre,
pg1_buf->arre,
pg1_buf->read_retry_count,
pg1_buf->write_retry_count);
break;
case MODEPAGE_GEOMETRY:
pg4_buf = (struct mode_page_04_struct *)
(int)pg_hdr;
P_DPRINTF(" adm_display_verbose_disk:"
"Mode Sense page 4 found.\n");
if (hdr_printed++ == 0) {
(void) fprintf(stdout,
MSGSTR(2091,
" Mode Sense data:\n"));
}
if (pg4_buf->rpm) {
(void) fprintf(stdout,
MSGSTR(2092,
" Medium rotation rate:\t"
"%d RPM\n"), pg4_buf->rpm);
}
break;
}
offset += pg_hdr->length + sizeof (struct mode_page);
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)offset));
}
} else if (getenv("_LUX_P_DEBUG") != NULL) {
(void) print_errString(err, path);
}
}
void
print_wwn(FILE *fd, uchar_t *pn_wwn)
{
(void) fprintf(fd,
" %1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
pn_wwn[0], pn_wwn[1], pn_wwn[2], pn_wwn[3],
pn_wwn[4], pn_wwn[5], pn_wwn[6], pn_wwn[7]);
}
void
print_fabric_prop(int pos, uchar_t *port_wwn, uchar_t *node_wwn, int port_addr,
int hard_addr)
{
(void) fprintf(stdout, "%-4d %-6x %-6x ",
pos, port_addr, hard_addr);
print_wwn(stdout, port_wwn);
print_wwn(stdout, node_wwn);
}
void
print_private_loop_prop(int pos, uchar_t *port_wwn, uchar_t *node_wwn,
int port_addr, int hard_addr)
{
(void) fprintf(stdout, "%-3d %-2x %-2x %-2x ",
pos, port_addr, g_sf_alpa_to_switch[port_addr], hard_addr);
print_wwn(stdout, port_wwn);
print_wwn(stdout, node_wwn);
}
void
dump_map(char **argv)
{
int i = 0, path_index = 0, pathcnt = 1;
int limited_map_flag = 0, err = 0;
char *path_phys = NULL;
Path_struct *path_struct;
struct lilpmap limited_map;
uint_t dev_type;
char temp2path[MAXPATHLEN];
mp_pathlist_t pathlist;
int p_pw = 0, p_on = 0, p_st = 0;
gfc_dev_t map_root, map_dev;
int *port_addr, *hard_addr, pos = 0, count;
uchar_t *hba_port_wwn, *port_wwn, *node_wwn, *dtype_prop;
uint_t map_topo;
while (argv[path_index] != NULL) {
if ((err = l_convert_name(argv[path_index], &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
argv[path_index]);
if (err != -1) {
(void) print_errString(err, argv[path_index]);
}
exit(-1);
}
if (strstr(path_phys, SCSI_VHCI) != NULL) {
(void) strcpy(temp2path, path_phys);
if (err = g_get_pathlist(temp2path, &pathlist)) {
(void) print_errString(err, NULL);
exit(-1);
}
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) {
(void) strcpy(temp2path,
pathlist.path_info[p_pw].path_hba);
} else if (pathlist.path_info[p_on].path_state ==
MDI_PATHINFO_STATE_ONLINE) {
(void) strcpy(temp2path,
pathlist.path_info[p_on].path_hba);
} else {
(void) strcpy(temp2path,
pathlist.path_info[p_st].path_hba);
}
free(pathlist.path_info);
(void) strcat(temp2path, FC_CTLR);
} else {
(void) strcpy(temp2path, path_phys);
}
if ((dev_type = g_get_path_type(temp2path)) == 0) {
(void) print_errString(L_INVALID_PATH,
argv[path_index]);
exit(-1);
}
if ((map_root = g_dev_map_init(temp2path, &err,
MAP_FORMAT_LILP)) == NULL) {
if (dev_type & FC_FCA_MASK) {
(void) print_errString(err, argv[path_index]);
exit(-1);
} else {
if (err = g_get_limited_map(path_phys,
&limited_map, (Options & PVERBOSE))) {
(void) print_errString(err,
argv[path_index]);
exit(-1);
}
limited_map_flag++;
}
}
if (limited_map_flag) {
(void) fprintf(stdout,
MSGSTR(2093,
"Host Adapter AL_PA: %x\n"),
limited_map.lilp_myalpa);
(void) fprintf(stdout,
MSGSTR(2094,
"Pos AL_PA\n"));
for (i = 0; i < (uint_t)limited_map.lilp_length; i++) {
(void) fprintf(stdout, "%-3d %-2x\n",
i, limited_map.lilp_list[i]);
}
} else {
if ((err = g_dev_prop_lookup_bytes(map_root,
PORT_WWN_PROP, &count, &hba_port_wwn)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_get_map_topology(
map_root, &map_topo)) != 0) {
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((map_dev = g_get_first_dev(map_root, &err)) == NULL) {
if (err == L_NO_SUCH_DEV_FOUND) {
g_dev_map_fini(map_root);
(void) fprintf(stderr,
MSGSTR(2308, " No devices are found on %s.\n"),
argv[path_index]);
exit(-1);
} else {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
}
switch (map_topo) {
case FC_TOP_FABRIC:
case FC_TOP_PUBLIC_LOOP:
case FC_TOP_PT_PT:
(void) fprintf(stdout,
MSGSTR(2095, "Pos Port_ID Hard_Addr Port WWN"
" Node WWN Type\n"));
while (map_dev) {
if ((err = g_dev_prop_lookup_ints(
map_dev, PORT_ADDR_PROP, &port_addr)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_bytes(map_dev,
PORT_WWN_PROP, &count, &port_wwn)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_bytes(map_dev,
NODE_WWN_PROP, &count, &node_wwn)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_ints(
map_dev, HARD_ADDR_PROP, &hard_addr)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
print_fabric_prop(pos++, port_wwn,
node_wwn, *port_addr, *hard_addr);
if ((err = g_dev_prop_lookup_bytes(map_dev,
INQ_DTYPE_PROP, &count, &dtype_prop)) != 0) {
(void) fprintf(stdout,
MSGSTR(2307, " Failed to get the type.\n"));
} else {
print_fabric_dtype_prop(hba_port_wwn, port_wwn,
*dtype_prop);
}
if (((map_dev = g_get_next_dev(
map_dev, &err)) == NULL) &&
(err != L_NO_SUCH_DEV_FOUND)) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
}
break;
case FC_TOP_PRIVATE_LOOP:
(void) fprintf(stdout,
MSGSTR(2295,
"Pos AL_PA ID Hard_Addr "
"Port WWN Node WWN Type\n"));
while (map_dev) {
if ((err = g_dev_prop_lookup_ints(
map_dev, PORT_ADDR_PROP, &port_addr)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_bytes(map_dev,
PORT_WWN_PROP, &count, &port_wwn)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_bytes(map_dev,
NODE_WWN_PROP, &count, &node_wwn)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
if ((err = g_dev_prop_lookup_ints(
map_dev, HARD_ADDR_PROP, &hard_addr)) != 0) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
print_private_loop_prop(pos++, port_wwn,
node_wwn, *port_addr, *hard_addr);
if ((err = g_dev_prop_lookup_bytes(map_dev,
INQ_DTYPE_PROP, &count, &dtype_prop)) != 0) {
(void) fprintf(stdout,
MSGSTR(2307, " Failed to get the type.\n"));
} else {
print_private_loop_dtype_prop(hba_port_wwn,
port_wwn, *dtype_prop);
}
if (((map_dev = g_get_next_dev(
map_dev, &err)) == NULL) &&
(err != L_NO_SUCH_DEV_FOUND)) {
g_dev_map_fini(map_root);
(void) print_errString(err, argv[path_index]);
exit(-1);
}
}
break;
default:
(void) print_errString(L_UNEXPECTED_FC_TOPOLOGY,
argv[path_index]);
exit(-1);
}
g_dev_map_fini(map_root);
}
limited_map_flag = 0;
path_index++;
}
}
int
n_get_non_encl_list(WWN_list **wwn_list_ptr, int verbose)
{
int i, j, k, err, found_ib = 0, pathcnt = 1;
WWN_list *wwn_list;
Box_list *b_list = NULL;
gfc_map_t map;
uchar_t box_id;
gfc_port_dev_info_t *dev_addr_list;
char phci_path[MAXPATHLEN], oldphci_path[MAXPATHLEN];
mp_pathlist_t pathlist;
if ((err = l_get_box_list(&b_list, verbose)) != 0) {
return (err);
}
if (err = g_get_wwn_list(&wwn_list, verbose)) {
(void) l_free_box_list(&b_list);
return (err);
}
while (b_list != NULL) {
pathcnt = 1;
if (strstr(b_list->b_physical_path, SCSI_VHCI) != NULL) {
(void) strcpy(phci_path, b_list->b_physical_path);
if (err = g_get_pathlist(phci_path, &pathlist)) {
(void) print_errString(err, NULL);
exit(-1);
}
pathcnt = pathlist.path_count;
}
for (k = 0; k < pathcnt; k++) {
if ((k > 0) && (strstr(oldphci_path,
pathlist.path_info[k].path_hba))) {
continue;
}
if (strstr(b_list->b_physical_path, SCSI_VHCI) == NULL) {
if ((err = g_get_dev_map(b_list->b_physical_path,
&map, verbose)) != 0) {
(void) g_free_wwn_list(&wwn_list);
(void) l_free_box_list(&b_list);
return (err);
}
} else {
(void) strcpy(phci_path,
pathlist.path_info[k].path_hba);
(void) strcpy(oldphci_path, phci_path);
(void) strcat(phci_path, FC_CTLR);
if (g_get_dev_map(phci_path, &map, verbose)) {
continue;
}
if (pathcnt == 1) {
free(pathlist.path_info);
}
}
switch (map.hba_addr.port_topology) {
case FC_TOP_FABRIC:
case FC_TOP_PUBLIC_LOOP:
for (i = 0, dev_addr_list = map.dev_addr;
i < map.count; i++, dev_addr_list++) {
for (found_ib = 1, j = 0; j < WWN_SIZE;
j++) {
if (b_list->b_node_wwn[j] !=
dev_addr_list->gfc_port_dev.
pub_port.dev_nwwn.raw_wwn[j]) {
found_ib = 0;
}
}
if (found_ib) {
(void) n_rem_list_entry_fabric(
dev_addr_list->gfc_port_dev.
pub_port.dev_did.port_id, &map,
&wwn_list);
}
}
break;
case FC_TOP_PRIVATE_LOOP:
for (i = 0, dev_addr_list = map.dev_addr;
i < map.count; i++, dev_addr_list++) {
for (found_ib = 1, j = 0; j < WWN_SIZE;
j++) {
if (b_list->b_node_wwn[j] !=
dev_addr_list->gfc_port_dev.
priv_port.sf_node_wwn[j]) {
found_ib = 0;
}
}
if (found_ib) {
box_id = g_sf_alpa_to_switch
[dev_addr_list->gfc_port_dev.
priv_port.sf_al_pa] &
BOX_ID_MASK;
(void) n_rem_list_entry(box_id, &map,
&wwn_list);
if (wwn_list == NULL) {
*wwn_list_ptr = NULL;
break;
}
}
}
break;
case FC_TOP_PT_PT:
(void) free((void *)map.dev_addr);
return (L_PT_PT_FC_TOP_NOT_SUPPORTED);
default:
(void) free((void *)map.dev_addr);
return (L_UNEXPECTED_FC_TOPOLOGY);
}
free((void *)map.dev_addr);
}
if (pathcnt > 1) {
free(pathlist.path_info);
}
b_list = b_list->box_next;
}
*wwn_list_ptr = wwn_list;
(void) l_free_box_list(&b_list);
return (0);
}
void
n_rem_list_entry(uchar_t box_id, struct gfc_map *map,
struct wwn_list_struct **wwn_list)
{
int k;
gfc_port_dev_info_t *dev_addr_list;
N_DPRINTF(" n_rem_list_entry: Removing devices"
" with box_id=0x%x from device list.\n", box_id);
for (k = 0, dev_addr_list = map->dev_addr; k < map->count;
k++, dev_addr_list++) {
if ((g_sf_alpa_to_switch[dev_addr_list->gfc_port_dev.
priv_port.sf_hard_address] & BOX_ID_MASK)
== box_id) {
n_rem_wwn_entry(dev_addr_list->gfc_port_dev.
priv_port.sf_node_wwn, wwn_list);
}
}
}
void
n_rem_list_entry_fabric(int pa, struct gfc_map *map,
struct wwn_list_struct **wwn_list)
{
int k;
gfc_port_dev_info_t *dev_addr_ptr;
N_DPRINTF(" n_rem_list_entry: Removing devices"
" with the same domain and area ID as"
" 0x%x PA from device list.\n", pa);
for (k = 0, dev_addr_ptr = map->dev_addr; k < map->count;
k++, dev_addr_ptr++) {
if ((dev_addr_ptr->gfc_port_dev.pub_port.dev_did.port_id |
0xff) == (pa | 0xff)) {
n_rem_wwn_entry(dev_addr_ptr->
gfc_port_dev.pub_port.dev_nwwn.raw_wwn,
wwn_list);
}
}
}
void
n_rem_wwn_entry(uchar_t node_wwn[], struct wwn_list_struct **wwn_list)
{
int l, found_dev;
WWN_list *inner, *l1;
inner = *wwn_list;
while (inner != NULL) {
for (found_dev = 1, l = 0; l < WWN_SIZE; l++) {
if (inner->w_node_wwn[l] != node_wwn[l]) {
found_dev = 0;
}
}
if (found_dev) {
if (inner->wwn_prev != NULL) {
inner->wwn_prev->wwn_next =
inner->wwn_next;
} else {
*wwn_list = inner->wwn_next;
}
if (inner->wwn_next != NULL) {
inner->wwn_next->wwn_prev =
inner->wwn_prev;
}
l1 = inner;
N_DPRINTF(" n_rem_wwn_entry: "
"Removing Logical=%s "
"Current=0x%x, "
"Prev=0x%x, Next=0x%x\n",
l1->logical_path,
l1,
l1->wwn_prev,
l1->wwn_next);
inner = inner->wwn_next;
if ((l1->wwn_prev == NULL) &&
(l1->wwn_next) == NULL) {
(void) free(l1->physical_path);
(void) free(l1->logical_path);
(void) free(l1);
*wwn_list = NULL;
N_DPRINTF(" n_rem_list_entry: "
"No non-Photon "
"devices left"
" in the list.\n");
return;
}
(void) free(l1->physical_path);
(void) free(l1->logical_path);
(void) free(l1);
} else {
inner = inner->wwn_next;
}
}
}
void
non_encl_probe()
{
WWN_list *wwn_list, *wwn_listh, *inner, *l1;
int err = 0;
char lun_a[MAXPATHLEN], lun_b[MAXPATHLEN], temppath[MAXPATHLEN];
char *tempptra = NULL, *tempptrb, *tempptr;
mp_pathlist_t pathlist;
int compare_result, retr_outer = 0;
ddi_devid_t devid1 = NULL, devid2 = NULL;
di_node_t root = DI_NODE_NIL;
if (err = n_get_non_encl_list(&wwn_list, (Options & PVERBOSE))) {
(void) print_errString(err, NULL);
exit(-1);
}
g_sort_wwn_list(&wwn_list);
wwn_listh = wwn_list;
if (wwn_list != NULL) {
if (wwn_list->wwn_next != NULL) {
(void) fprintf(stdout,
MSGSTR(2098, "\nFound Fibre Channel device(s):\n"));
} else {
(void) fprintf(stdout,
MSGSTR(2099, "\nFound Fibre Channel device:\n"));
}
} else {
return;
}
while (wwn_list != NULL) {
if (strstr(wwn_list->physical_path, SCSI_VHCI) != NULL) {
(void) strcpy(temppath, wwn_list->physical_path);
if ((!g_get_pathlist(temppath,
&pathlist)) &&
((tempptra = strchr(pathlist.path_info[0].
path_addr, ','))) != NULL) {
tempptra++;
(void) strcpy(lun_a, tempptra);
free(pathlist.path_info);
}
} else {
if ((((tempptr = strstr(wwn_list->physical_path,
SLSH_DRV_NAME_ST)) != NULL) ||
((tempptr = strstr(wwn_list->physical_path,
SLSH_DRV_NAME_SSD)) != NULL)) &&
((tempptra = strchr(tempptr, ',')) != NULL)) {
tempptra++;
(void) strcpy(lun_a, tempptra);
}
}
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(90, "Node WWN:"));
(void) fprintf(stdout, "%s ", wwn_list->node_wwn_s);
if (wwn_list->device_type < 0x10) {
(void) fprintf(stdout, MSGSTR(35, "Device Type:"));
(void) fprintf(stdout, "%s",
dtype[wwn_list->device_type]);
} else if (wwn_list->device_type < 0x1f) {
(void) fprintf(stdout, MSGSTR(2100,
"Type:Reserved"));
} else {
(void) fprintf(stdout, MSGSTR(2101,
"Type:Unknown"));
}
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout, MSGSTR(31, "Logical Path:%s"),
wwn_list->logical_path);
(void) fprintf(stdout, "\n");
if (Options & OPTION_P) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(5, "Physical Path:"));
(void) fprintf(stdout, "\n %s\n", wwn_list->physical_path);
}
inner = wwn_list->wwn_next;
while (inner != NULL) {
if (strcmp(inner->node_wwn_s, wwn_list->node_wwn_s) == 0) {
if (tempptra != NULL) {
if (strstr(inner->physical_path,
SCSI_VHCI) != NULL) {
(void) strcpy(temppath,
inner->physical_path);
if ((!g_get_pathlist(temppath, &pathlist)) &&
((tempptrb = strchr(
pathlist.path_info[0].path_addr, ','))) !=
NULL) {
tempptrb++;
(void) strcpy(lun_b, tempptrb);
free(pathlist.path_info);
}
} else {
if ((((tempptr = strstr(inner->physical_path,
SLSH_DRV_NAME_ST)) != NULL) ||
((tempptr = strstr(inner->physical_path,
SLSH_DRV_NAME_SSD)) != NULL)) &&
((tempptrb = strchr(tempptr, ',')) != NULL)) {
tempptrb++;
(void) strcpy(lun_b, tempptrb);
}
}
}
if (((tempptra == NULL) || (strcmp(lun_a, lun_b)) == 0)) {
if (root == DI_NODE_NIL) {
if ((root = di_init("/", DINFOCPYALL)) ==
DI_NODE_NIL) {
(void) fprintf(stdout,
MSGSTR(2319,
"\nFailed to get device tree snapshot:\n"));
exit(1);
}
}
if (!retr_outer && strstr(wwn_list->physical_path,
SLSH_DRV_NAME_SSD) != NULL) {
if ((err = g_devid_get(wwn_list->physical_path,
&devid1, root, SSD_DRVR_NAME)) != 0) {
(void) print_errString(err,
wwn_list->physical_path);
}
retr_outer = 1;
}
if ((strstr(inner->physical_path,
SLSH_DRV_NAME_SSD) != NULL) &&
devid1 != NULL) {
if ((err = g_devid_get(inner->physical_path,
&devid2, root, SSD_DRVR_NAME)) != 0) {
(void) print_errString(err,
inner->physical_path);
compare_result = 0;
} else {
compare_result = devid_compare(devid1, devid2);
}
} else {
compare_result = 0;
}
if (compare_result == 0) {
if (strcmp(wwn_list->logical_path,
inner->logical_path)) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout,
MSGSTR(31, "Logical Path:%s"),
inner->logical_path);
(void) fprintf(stdout, "\n");
if (Options & OPTION_P) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(5,
"Physical Path:"));
(void) fprintf(stdout, "\n %s\n",
inner->physical_path);
}
}
if (inner->wwn_prev != NULL) {
inner->wwn_prev->wwn_next =
inner->wwn_next;
}
if (inner->wwn_next != NULL) {
inner->wwn_next->wwn_prev =
inner->wwn_prev;
}
free(inner->physical_path);
free(inner->logical_path);
l1 = inner;
inner = inner->wwn_next;
(void) free(l1);
} else {
inner = inner->wwn_next;
}
} else {
inner = inner->wwn_next;
}
} else {
inner = inner->wwn_next;
}
devid2 = NULL;
}
wwn_list = wwn_list->wwn_next;
retr_outer = 0;
devid1 = NULL;
}
(void) g_free_wwn_list(&wwn_listh);
(void) di_fini(root);
}
void
pho_probe()
{
Box_list *b_list, *o_list, *c_list;
int multi_path_flag, multi_print_flag;
int duplicate_names_found = 0, err = 0;
b_list = o_list = c_list = NULL;
if ((err = l_get_box_list(&b_list, Options & PVERBOSE)) != 0) {
(void) print_errString(err, NULL);
exit(-1);
}
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;
if (b_list->box_next != NULL) {
(void) fprintf(stdout, MSGSTR(2102,
"Found Enclosure(s)"));
} else {
(void) fprintf(stdout, MSGSTR(2103, "Found Enclosure"));
}
(void) fprintf(stdout, ":\n");
while (b_list != NULL) {
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;
}
(void) fprintf(stdout,
MSGSTR(2104, "%s Name:%s Node WWN:%s "),
b_list->prod_id_s, b_list->b_name,
b_list->b_node_wwn_s);
multi_path_flag = 0;
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)) {
multi_path_flag = 1;
}
c_list = c_list->box_next;
}
if (multi_path_flag) {
(void) fprintf(stdout, "\n ");
}
(void) fprintf(stdout,
MSGSTR(31, "Logical Path:%s"),
b_list->logical_path);
if (Options & OPTION_P) {
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout,
MSGSTR(5, "Physical Path:"));
(void) fprintf(stdout, "%s",
b_list->b_physical_path);
}
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, "\n ");
(void) fprintf(stdout,
MSGSTR(31, "Logical Path:%s"),
c_list->logical_path);
if (Options & OPTION_P) {
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout,
MSGSTR(5, "Physical Path:"));
(void) fprintf(stdout, "%s",
c_list->b_physical_path);
}
}
c_list = c_list->box_next;
}
(void) fprintf(stdout, "\n");
if (l_duplicate_names(o_list, b_list->b_node_wwn_s,
(char *)b_list->b_name,
Options & PVERBOSE)) {
duplicate_names_found++;
}
b_list = b_list->box_next;
}
}
if (duplicate_names_found) {
(void) fprintf(stdout,
MSGSTR(2105, "\nWARNING: There are enclosures with "
"the same names.\n"
"You can not use the \"enclosure\""
" name to specify these subsystems.\n"
"Please use the \"enclosure_name\""
" subcommand to select unique names.\n\n"));
}
(void) l_free_box_list(&b_list);
}
void
display_port_status(int d_state_flag)
{
if (d_state_flag & L_OPEN_FAIL) {
(void) fprintf(stdout, MSGSTR(28, "Open Failed"));
} else if (d_state_flag & L_NOT_READY) {
(void) fprintf(stdout, MSGSTR(20, "Not Ready"));
} else if (d_state_flag & L_NOT_READABLE) {
(void) fprintf(stdout, MSGSTR(88, "Not Readable"));
} else if (d_state_flag & L_SPUN_DWN_D) {
(void) fprintf(stdout, MSGSTR(68, "Spun Down"));
} else if (d_state_flag & L_SCSI_ERR) {
(void) fprintf(stdout, MSGSTR(70, "SCSI Error"));
} else if (d_state_flag & L_RESERVED) {
(void) fprintf(stdout, MSGSTR(73, "Reservation conflict"));
} else if (d_state_flag & L_NO_LABEL) {
(void) fprintf(stdout, MSGSTR(92, "No UNIX Label"));
} else {
(void) fprintf(stdout, MSGSTR(29, "O.K."));
}
(void) fprintf(stdout, "\n");
}
void
display_fc_disk(struct path_struct *path_struct, char *ses_path,
gfc_map_t *map, L_inquiry inq, int verbose)
{
static WWN_list *wwn_list = NULL;
static char path_phys[MAXPATHLEN];
static L_disk_state l_disk_state;
static L_inquiry local_inq;
static uchar_t node_wwn[WWN_SIZE];
char same_path_phys = B_FALSE;
uchar_t port_wwn[WWN_SIZE], *pg_buf;
char logical_path[MAXPATHLEN];
int al_pa, port_a_flag = 0;
int offset, mode_data_avail = 0;
int no_path_flag = 0, err = 0;
L_state l_state;
Mode_header_10 *mode_header_ptr = NULL;
struct mode_page *pg_hdr = NULL;
if (strcmp(path_phys, path_struct->p_physical_path) == 0)
same_path_phys = B_TRUE;
(void) strcpy(path_phys, path_struct->p_physical_path);
(void) memset((char *)logical_path, 0, sizeof (logical_path));
if (path_struct->slot_valid == 1) {
if (err = g_get_dev_map(path_phys, map, (Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (err = l_get_ses_path(path_phys, ses_path, map,
(Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
}
if (same_path_phys == B_FALSE) {
if (err = g_get_wwn(path_phys, port_wwn, node_wwn,
&al_pa, (Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
if (err = g_get_inquiry(ses_path, &local_inq)) {
(void) print_errString(err, ses_path);
exit(-1);
}
}
if ((err = l_get_ib_status(ses_path, &l_state,
Options & PVERBOSE)) != 0) {
(void) print_errString(err, ses_path);
exit(-1);
}
if ((wwn_list == NULL) && (err = g_get_wwn_list(&wwn_list, verbose))) {
(void) print_errString(err, ses_path);
exit(-1);
}
if (same_path_phys == B_FALSE) {
(void) memset(&l_disk_state, 0,
sizeof (struct l_disk_state_struct));
if (err = l_get_disk_status(path_phys, &l_disk_state,
wwn_list, (Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
}
if (l_disk_state.l_state_flag & L_NO_PATH_FOUND) {
(void) fprintf(stderr, MSGSTR(2106,
"\nWARNING: No path found "
"in /dev/rdsk directory\n"
" Please check the logical links in /dev/rdsk\n"
" (It may be necessary to run the \"disks\" "
"program.)\n\n"));
if (err = l_get_port(ses_path, &port_a_flag, verbose)) {
(void) print_errString(err, ses_path);
exit(-1);
}
if (err = l_get_disk_port_status(path_phys,
&l_disk_state, port_a_flag,
(Options & PVERBOSE))) {
(void) print_errString(err, path_phys);
exit(-1);
}
no_path_flag++;
}
if (strlen(l_disk_state.g_disk_state.node_wwn_s) == 0) {
(void) sprintf(l_disk_state.g_disk_state.node_wwn_s,
"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
node_wwn[0], node_wwn[1], node_wwn[2], node_wwn[3],
node_wwn[4], node_wwn[5], node_wwn[6], node_wwn[7]);
}
if (l_get_mode_pg(path_phys, &pg_buf, Options & PVERBOSE) == 0) {
mode_header_ptr = (struct mode_header_10_struct *)(int)pg_buf;
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)sizeof (struct mode_header_10_struct) +
(uchar_t *)(uintptr_t)(mode_header_ptr->bdesc_length)));
offset = sizeof (struct mode_header_10_struct) +
mode_header_ptr->bdesc_length;
while (offset < (mode_header_ptr->length +
sizeof (mode_header_ptr->length)) &&
!mode_data_avail) {
if (pg_hdr->code == MODEPAGE_CACHING) {
mode_data_avail++;
break;
}
offset += pg_hdr->length + sizeof (struct mode_page);
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)offset));
}
}
switch ((inq.inq_dtype & DTYPE_MASK)) {
case DTYPE_DIRECT:
fprintf(stdout, MSGSTR(121, "DEVICE PROPERTIES for disk: %s\n"),
path_struct->argv);
break;
case DTYPE_SEQUENTIAL:
fprintf(stdout, MSGSTR(2249, "DEVICE PROPERTIES for tape: %s\n"),
path_struct->argv);
break;
default:
fprintf(stdout, MSGSTR(2250, "DEVICE PROPERTIES for: %s\n"),
path_struct->argv);
break;
}
if (l_disk_state.g_disk_state.port_a_valid) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(141, "Status(Port A):"));
(void) fprintf(stdout, "\t");
display_port_status(
l_disk_state.g_disk_state.d_state_flags[PORT_A]);
} else {
if (path_struct->f_flag) {
if ((ib_present_chk(&l_state, 0) == 1) &&
(l_state.drv_front[path_struct->slot].ib_status.bypass_a_en)) {
(void) fprintf(stdout,
MSGSTR(66,
" Status(Port A):\tBYPASSED\n"));
}
} else {
if ((ib_present_chk(&l_state, 0) == 1) &&
(l_state.drv_rear[path_struct->slot].ib_status.bypass_a_en)) {
(void) fprintf(stdout,
MSGSTR(66,
" Status(Port A):\tBYPASSED\n"));
}
}
}
if (l_disk_state.g_disk_state.port_b_valid) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(142, "Status(Port B):"));
(void) fprintf(stdout, "\t");
display_port_status(l_disk_state.g_disk_state.d_state_flags[PORT_B]);
} else {
if (path_struct->f_flag) {
if ((ib_present_chk(&l_state, 1) == 1) &&
(l_state.drv_front[path_struct->slot].ib_status.bypass_b_en)) {
(void) fprintf(stdout,
MSGSTR(65,
" Status(Port B):\tBYPASSED\n"));
}
} else {
if ((ib_present_chk(&l_state, 1) == 1) &&
(l_state.drv_rear[path_struct->slot].ib_status.bypass_b_en)) {
(void) fprintf(stdout,
MSGSTR(65,
" Status(Port B):\tBYPASSED\n"));
}
}
}
if (no_path_flag) {
(void) fprintf(stdout, " ");
if (port_a_flag != 0) {
(void) fprintf(stdout, MSGSTR(142, "Status(Port B):"));
} else {
(void) fprintf(stdout, MSGSTR(141, "Status(Port A):"));
}
(void) fprintf(stdout, "\t");
display_port_status(
l_disk_state.g_disk_state.d_state_flags[port_a_flag]);
} else if ((!l_disk_state.g_disk_state.port_a_valid) &&
(!l_disk_state.g_disk_state.port_b_valid)) {
(void) fprintf(stdout, MSGSTR(2107, " Status:\t\t"
"No state available.\n"));
}
(void) display_disk_info(inq, l_disk_state, path_struct, pg_hdr,
mode_data_avail, (char *)local_inq.inq_box_name, verbose);
}
static int
non_encl_fc_disk_display(Path_struct *path_struct,
L_inquiry inq_struct, int verbose)
{
char phys_path[MAXPATHLEN];
uchar_t node_wwn[WWN_SIZE], port_wwn[WWN_SIZE], *pg_buf = NULL;
L_disk_state l_disk_state;
struct dlist *mlist;
int i = 0, al_pa, offset, mode_data_avail = 0, err = 0;
int path_a_found = 0, path_b_found = 0, argpwwn = 0,
argnwwn = 0, pathcnt = 1;
L_inquiry local_inq;
Mode_header_10 *mode_header_ptr;
struct mode_page *pg_hdr = NULL;
WWN_list *wwn_list, *wwn_list_ptr, *list_start;
char temppath[MAXPATHLEN], last_logical_path[MAXPATHLEN];
mp_pathlist_t pathlist;
(void) strcpy(phys_path, path_struct->p_physical_path);
if (err = g_get_wwn_list(&wwn_list, verbose)) {
return (err);
}
g_sort_wwn_list(&wwn_list);
list_start = wwn_list;
(void) strcpy(last_logical_path, phys_path);
for (wwn_list_ptr = wwn_list; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (strcasecmp(wwn_list_ptr->port_wwn_s,
path_struct->argv) == 0) {
list_start = wwn_list_ptr;
argpwwn = 1;
break;
} else if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) == 0) {
list_start = wwn_list_ptr;
argnwwn = 1;
break;
}
}
for (wwn_list_ptr = list_start; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (argpwwn) {
if (strcasecmp(wwn_list_ptr->port_wwn_s,
path_struct->argv) != 0) {
continue;
}
(void) strcpy(phys_path, wwn_list_ptr->physical_path);
path_a_found = 0;
path_b_found = 0;
mode_data_avail = 0;
} else if (argnwwn) {
if (strstr(wwn_list_ptr->logical_path,
last_logical_path) != NULL) {
continue;
}
if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) != 0) {
continue;
}
(void) strcpy(phys_path, wwn_list_ptr->physical_path);
(void) strcpy(last_logical_path,
wwn_list_ptr->logical_path);
path_a_found = 0;
path_b_found = 0;
mode_data_avail = 0;
}
(void) memset(&l_disk_state, 0, sizeof (struct l_disk_state_struct));
if ((err = g_get_multipath(phys_path,
&(l_disk_state.g_disk_state.multipath_list),
wwn_list, verbose)) != 0) {
return (err);
}
mlist = l_disk_state.g_disk_state.multipath_list;
if (mlist == NULL) {
l_disk_state.l_state_flag = L_NO_PATH_FOUND;
N_DPRINTF(" non_encl_fc_disk_display: Error finding"
" multiple paths to the disk.\n");
(void) g_free_wwn_list(&wwn_list);
return (-1);
}
if (l_get_mode_pg(phys_path, &pg_buf, verbose) == 0) {
mode_header_ptr = (struct mode_header_10_struct *)(int)pg_buf;
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)sizeof (struct mode_header_10_struct) +
(uchar_t *)(uintptr_t)(mode_header_ptr->bdesc_length)));
offset = sizeof (struct mode_header_10_struct) +
mode_header_ptr->bdesc_length;
while (offset < (mode_header_ptr->length +
sizeof (mode_header_ptr->length)) &&
!mode_data_avail) {
if (pg_hdr->code == MODEPAGE_CACHING) {
mode_data_avail++;
break;
}
offset += pg_hdr->length + sizeof (struct mode_page);
pg_hdr = ((struct mode_page *)((int)pg_buf +
(uchar_t)offset));
}
}
switch ((inq_struct.inq_dtype & DTYPE_MASK)) {
case DTYPE_DIRECT:
fprintf(stdout, MSGSTR(121, "DEVICE PROPERTIES for disk: %s\n"),
path_struct->argv);
break;
case DTYPE_SEQUENTIAL:
fprintf(stdout, MSGSTR(2249, "DEVICE PROPERTIES for tape: %s\n"),
path_struct->argv);
break;
default:
fprintf(stdout, MSGSTR(2250, "DEVICE PROPERTIES for: %s\n"),
path_struct->argv);
break;
}
while ((mlist != NULL) && (!(path_a_found && path_b_found))) {
(void) strcpy(phys_path, mlist->dev_path);
if (err = g_get_inquiry(phys_path, &local_inq)) {
(void) fprintf(stderr,
MSGSTR(2114,
"non_encl_fc_disk_display: Inquiry failed\n"));
(void) print_errString(err, phys_path);
(void) g_free_multipath(
l_disk_state.g_disk_state.multipath_list);
(void) g_free_wwn_list(&wwn_list);
return (-1);
}
if ((err = g_get_wwn(mlist->dev_path, port_wwn, node_wwn,
&al_pa, verbose)) != 0) {
(void) print_errString(err, mlist->dev_path);
(void) g_free_multipath(
l_disk_state.g_disk_state.multipath_list);
(void) g_free_wwn_list(&wwn_list);
return (-1);
}
if (strlen(l_disk_state.g_disk_state.node_wwn_s) == 0) {
(void) sprintf(l_disk_state.g_disk_state.node_wwn_s,
"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
node_wwn[0], node_wwn[1], node_wwn[2], node_wwn[3],
node_wwn[4], node_wwn[5], node_wwn[6], node_wwn[7]);
}
if ((err = l_get_disk_port_status(phys_path, &l_disk_state,
(local_inq.inq_port) ? FC_PORT_B : FC_PORT_A,
verbose)) != 0) {
(void) print_errString(err, phys_path);
(void) g_free_multipath(
l_disk_state.g_disk_state.multipath_list);
exit(-1);
}
if ((!local_inq.inq_port) && (!path_a_found)) {
(void) sprintf(l_disk_state.g_disk_state.port_a_wwn_s,
"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
port_wwn[0], port_wwn[1], port_wwn[2], port_wwn[3],
port_wwn[4], port_wwn[5], port_wwn[6], port_wwn[7]);
path_a_found = l_disk_state.g_disk_state.port_a_valid = 1;
}
if ((local_inq.inq_port) && (!path_b_found)) {
path_b_found = l_disk_state.g_disk_state.port_b_valid = 1;
(void) sprintf(l_disk_state.g_disk_state.port_b_wwn_s,
"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
port_wwn[0], port_wwn[1], port_wwn[2], port_wwn[3],
port_wwn[4], port_wwn[5], port_wwn[6], port_wwn[7]);
}
if ((strstr(mlist->dev_path, SCSI_VHCI) != NULL) &&
(!l_get_disk_port_status(phys_path, &l_disk_state,
(!local_inq.inq_port) ? FC_PORT_B : FC_PORT_A,
verbose))) {
(void) strcpy(temppath, mlist->dev_path);
if (err = g_get_pathlist(temppath, &pathlist)) {
(void) print_errString(err, NULL);
exit(-1);
}
pathcnt = pathlist.path_count;
if (pathcnt > 1) {
for (i = 0; i < pathcnt; i++) {
if ((!path_a_found) &&
(path_b_found) &&
(strstr(pathlist.path_info[i].
path_addr,
l_disk_state.g_disk_state.
port_b_wwn_s) == NULL)) {
(void) strncpy(l_disk_state.
g_disk_state.port_a_wwn_s,
pathlist.path_info[i].
path_addr, 16);
path_a_found = l_disk_state.
g_disk_state.port_a_valid = 1;
}
if ((path_a_found) &&
(!path_b_found) &&
(strstr(pathlist.path_info[i].
path_addr,
l_disk_state.g_disk_state.
port_a_wwn_s) == NULL)) {
(void) strncpy(l_disk_state.
g_disk_state.port_b_wwn_s,
pathlist.path_info[i].
path_addr, 16);
path_b_found = l_disk_state.
g_disk_state.port_b_valid = 1;
}
if ((path_a_found) && (path_b_found)) {
break;
}
}
}
free(pathlist.path_info);
}
mlist = mlist->next;
}
if (l_disk_state.g_disk_state.port_a_valid) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(141, "Status(Port A):"));
(void) fprintf(stdout, "\t");
display_port_status(l_disk_state.g_disk_state.d_state_flags[FC_PORT_A]);
}
if (l_disk_state.g_disk_state.port_b_valid) {
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(142, "Status(Port B):"));
(void) fprintf(stdout, "\t");
display_port_status(l_disk_state.g_disk_state.d_state_flags[FC_PORT_B]);
}
(void) display_disk_info(local_inq, l_disk_state, path_struct,
pg_hdr, mode_data_avail, NULL, verbose);
(void) g_free_multipath(l_disk_state.g_disk_state.multipath_list);
if (!(argpwwn || argnwwn)) {
break;
}
}
(void) g_free_wwn_list(&wwn_list);
return (0);
}
void
display_disk_info(L_inquiry inq, L_disk_state l_disk_state,
Path_struct *path_struct, struct mode_page *pg_hdr,
int mode_data_avail, char *name_buf, int options)
{
float num_blks;
struct dlist *mlist;
int port_a, port_b;
struct my_mode_caching *pg8_buf;
L_inquiry enc_inq;
char *enc_phys_path;
Path_struct *enc_path_struct;
int enc_type = 0;
L_inquiry80 inq80;
size_t serial_len;
int err;
serial_len = sizeof (inq80.inq_serial);
err = g_get_serial_number(path_struct->p_physical_path,
inq80.inq_serial, &serial_len);
if (err) {
fprintf(stderr, "\n");
print_errString(err, path_struct->p_physical_path);
fprintf(stderr, "\n");
exit(1);
}
(void) fprintf(stdout, " ");
(void) fprintf(stdout, MSGSTR(3, "Vendor:"));
(void) fprintf(stdout, "\t\t");
print_chars(inq.inq_vid, sizeof (inq.inq_vid), 0);
(void) fprintf(stdout, MSGSTR(2115, "\n Product ID:\t\t"));
print_chars(inq.inq_pid, sizeof (inq.inq_pid), 0);
(void) fprintf(stdout, MSGSTR(2116, "\n WWN(Node):\t\t%s"),
l_disk_state.g_disk_state.node_wwn_s);
if (l_disk_state.g_disk_state.port_a_valid) {
(void) fprintf(stdout, MSGSTR(2117, "\n WWN(Port A):\t\t%s"),
l_disk_state.g_disk_state.port_a_wwn_s);
}
if (l_disk_state.g_disk_state.port_b_valid) {
(void) fprintf(stdout, MSGSTR(2118, "\n WWN(Port B):\t\t%s"),
l_disk_state.g_disk_state.port_b_wwn_s);
}
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout, MSGSTR(2119, "Revision:"));
(void) fprintf(stdout, "\t\t");
print_chars(inq.inq_revision, sizeof (inq.inq_revision), 0);
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout, MSGSTR(17, "Serial Num:"));
(void) fprintf(stdout, "\t\t");
print_chars(inq80.inq_serial, serial_len, 0);
num_blks = l_disk_state.g_disk_state.num_blocks;
if (num_blks) {
num_blks /= 2048;
(void) fprintf(stdout, "\n ");
(void) fprintf(stdout,
MSGSTR(60,
"Unformatted capacity:\t%6.3f MBytes"), num_blks);
}
(void) fprintf(stdout, "\n");
if (l_disk_state.g_disk_state.persistent_reserv_flag) {
(void) fprintf(stdout,
MSGSTR(2120, " Persistent Reserve:\t"));
if (l_disk_state.g_disk_state.persistent_active) {
(void) fprintf(stdout,
MSGSTR(39, "Active"));
(void) fprintf(stdout, "\n");
}
if (l_disk_state.g_disk_state.persistent_registered) {
(void) fprintf(stdout,
MSGSTR(2121, "Found Registered Keys"));
} else {
(void) fprintf(stdout,
MSGSTR(87, "Not being used"));
}
(void) fprintf(stdout, "\n");
}
if ((mode_data_avail) && (pg_hdr->code == MODEPAGE_CACHING)) {
pg8_buf = (struct my_mode_caching *)(int)pg_hdr;
if (pg8_buf->wce) {
(void) fprintf(stdout,
MSGSTR(2122,
" Write Cache:\t\t"
"Enabled\n"));
}
if (pg8_buf->rcd == 0) {
(void) fprintf(stdout,
MSGSTR(2123,
" Read Cache:\t\t"
"Enabled\n"));
(void) fprintf(stdout,
MSGSTR(2320,
" Minimum prefetch:"
"\t0x%x\n"
" Maximum prefetch:"
"\t0x%x\n"),
pg8_buf->min_prefetch,
pg8_buf->max_prefetch);
}
}
if (name_buf != NULL) {
fprintf(stdout, MSGSTR(2125, " Location:\t\t"));
if (path_struct->slot_valid) {
if (!l_convert_name(name_buf, &enc_phys_path,
&enc_path_struct, 0)) {
if (!g_get_inquiry(enc_phys_path, &enc_inq)) {
enc_type = l_get_enc_type(enc_inq);
}
}
free(enc_phys_path);
free(enc_path_struct);
if (enc_type == DAK_ENC_TYPE) {
if (path_struct->f_flag) {
(void) fprintf(stdout, MSGSTR(2239,
"In slot %d in the enclosure named: %s\n"),
path_struct->slot, name_buf);
} else {
(void) fprintf(stdout, MSGSTR(2239,
"In slot %d in the enclosure named: %s\n"),
path_struct->slot + (MAX_DRIVES_DAK/2),
name_buf);
}
} else {
(void) fprintf(stdout, path_struct->f_flag ?
MSGSTR(2126,
"In slot %d in the Front of the enclosure named: %s\n")
: MSGSTR(2127,
"In slot %d in the Rear of the enclosure named: %s\n"),
path_struct->slot, name_buf);
}
} else {
(void) fprintf(stdout, MSGSTR(2228,
"In the enclosure named: %s\n"),
name_buf);
}
}
(void) fprintf(stdout, " %s\t\t%s\n",
MSGSTR(35, "Device Type:"),
dtype[inq.inq_dtype & DTYPE_MASK]);
mlist = l_disk_state.g_disk_state.multipath_list;
(void) fprintf(stdout, MSGSTR(2128, " Path(s):\n"));
if (strstr(mlist->dev_path, SCSI_VHCI) != NULL) {
(void) fprintf(stdout, " %s\n %s\n",
mlist->logical_path, mlist->dev_path);
(void) adm_print_pathlist(mlist->dev_path);
} else {
while (mlist) {
(void) fprintf(stdout, " %s\n %s\n",
mlist->logical_path, mlist->dev_path);
mlist = mlist->next;
}
}
if (Options & OPTION_V) {
if (path_struct->slot_valid) {
port_a = PORT_A;
port_b = PORT_B;
} else {
port_a = FC_PORT_A;
port_b = FC_PORT_B;
}
if ((l_disk_state.g_disk_state.port_a_valid) &&
(l_disk_state.g_disk_state.d_state_flags[port_a] == 0))
adm_display_verbose_disk(path_struct->p_physical_path, options);
else if ((l_disk_state.g_disk_state.port_b_valid) &&
(l_disk_state.g_disk_state.d_state_flags[port_b] == 0))
adm_display_verbose_disk(path_struct->p_physical_path, options);
}
(void) fprintf(stdout, "\n");
}
void
temp_decode(Temp_elem_st *temp)
{
if (temp->ot_fail) {
(void) fprintf(stdout, MSGSTR(2129,
": FAILURE - Over Temperature"));
}
if (temp->ut_fail) {
(void) fprintf(stdout, MSGSTR(2130,
": FAILURE - Under Temperature"));
}
if (temp->ot_warn) {
(void) fprintf(stdout, MSGSTR(2131,
": WARNING - Over Temperature"));
}
if (temp->ut_warn) {
(void) fprintf(stdout, MSGSTR(2132,
": WARNING - Under Temperature"));
}
}
void
disp_degree(Temp_elem_st *temp)
{
int t;
t = temp->degrees;
t -= 20;
(void) fprintf(stdout, ":%1.2d%cC ", t, 186);
}
void
trans_decode(Trans_elem_st *trans)
{
if (trans->disabled) {
(void) fprintf(stdout, ": ");
(void) fprintf(stdout, MSGSTR(34,
"Disabled"));
}
if (trans->lol) {
(void) fprintf(stdout, MSGSTR(2133,
": Not receiving a signal"));
}
if (trans->lsr_fail) {
(void) fprintf(stdout, MSGSTR(2134,
": Laser failed"));
}
}
void
trans_messages(struct l_state_struct *l_state, int ib_a_flag)
{
Trans_elem_st trans;
int i, j, k;
int count = 0;
int elem_index = 0;
for (i = 0; i < (int)l_state->ib_tbl.config.enc_num_elem; i++) {
elem_index++;
if (l_state->ib_tbl.config.type_hdr[i].type == ELM_TYP_FL) {
if (l_state->ib_tbl.config.type_hdr[i].text_len != 0) {
(void) fprintf(stdout, "\n\t\t%s\n",
l_state->ib_tbl.config.text[i]);
}
count = k = 0;
for (j = 0; j <
(int)l_state->ib_tbl.config.type_hdr[i].num; j++) {
if ((count < 2 && ib_a_flag) ||
(count >= 2 && !ib_a_flag)) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&trans, sizeof (trans));
if (k == 0) {
(void) fprintf(stdout, "\t\t%d ", k);
} else {
(void) fprintf(stdout, "\n\t\t%d ", k);
}
if (trans.code == S_OK) {
(void) fprintf(stdout,
MSGSTR(29, "O.K."));
revision_msg(l_state, elem_index + j);
} else if ((trans.code == S_CRITICAL) ||
(trans.code == S_NONCRITICAL)) {
(void) fprintf(stdout,
MSGSTR(2135, "Failed"));
revision_msg(l_state, elem_index + j);
trans_decode(&trans);
} else if (trans.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
} else if (trans.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
revision_msg(l_state, elem_index + j);
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
}
k++;
}
count++;
}
}
elem_index += l_state->ib_tbl.config.type_hdr[i].num;
}
(void) fprintf(stdout, "\n");
}
void
temperature_messages(struct l_state_struct *l_state, int rear_flag)
{
Temp_elem_st temp;
int i, j, last_ok = 0;
int all_ok = 1;
int elem_index = 0;
for (i = 0; i < (int)l_state->ib_tbl.config.enc_num_elem; i++) {
elem_index++;
if (l_state->ib_tbl.config.type_hdr[i].type == ELM_TYP_TS) {
if (!rear_flag) {
rear_flag = 1;
if (l_state->ib_tbl.config.type_hdr[i].text_len != 0) {
(void) fprintf(stdout, "\t %s",
l_state->ib_tbl.config.text[i]);
}
(void) bcopy((const void *)&l_state->ib_tbl.p2_s.element[i],
(void *)&temp, sizeof (temp));
for (j = 0; j <
(int)l_state->ib_tbl.config.type_hdr[i].num; j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&temp, sizeof (temp));
if ((j == 0) && (temp.code == S_OK) &&
(!(temp.ot_fail || temp.ot_warn ||
temp.ut_fail || temp.ut_warn))) {
(void) fprintf(stdout, "\n\t %d", j);
} else if ((j == 6) && (temp.code == S_OK) &&
all_ok) {
(void) fprintf(stdout, "\n\t %d", j);
} else if (last_ok && (temp.code == S_OK)) {
(void) fprintf(stdout, "%d", j);
} else {
(void) fprintf(stdout, "\n\t\t%d", j);
}
if (temp.code == S_OK) {
disp_degree(&temp);
if (temp.ot_fail || temp.ot_warn ||
temp.ut_fail || temp.ut_warn) {
temp_decode(&temp);
all_ok = 0;
last_ok = 0;
} else {
last_ok++;
}
} else if (temp.code == S_CRITICAL) {
(void) fprintf(stdout,
MSGSTR(122, "Critical failure"));
last_ok = 0;
all_ok = 0;
} else if (temp.code == S_NONCRITICAL) {
(void) fprintf(stdout,
MSGSTR(89, "Non-Critical Failure"));
last_ok = 0;
all_ok = 0;
} else if (temp.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
last_ok = 0;
all_ok = 0;
} else if (temp.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
last_ok = 0;
all_ok = 0;
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
last_ok = 0;
all_ok = 0;
}
}
if (all_ok) {
(void) fprintf(stdout,
MSGSTR(2136, " (All temperatures are "
"NORMAL.)"));
}
all_ok = 1;
(void) fprintf(stdout, "\n");
} else {
rear_flag = 0;
}
}
elem_index += l_state->ib_tbl.config.type_hdr[i].num;
}
}
void
ib_decode(Ctlr_elem_st *ctlr)
{
if (ctlr->overtemp_alart) {
(void) fprintf(stdout, MSGSTR(2137,
" - IB Over Temperature Alert "));
}
if (ctlr->ib_loop_1_fail) {
(void) fprintf(stdout, MSGSTR(2138,
" - IB Loop 1 has failed "));
}
if (ctlr->ib_loop_0_fail) {
(void) fprintf(stdout, MSGSTR(2139,
" - IB Loop 0 has failed "));
}
}
void
mb_messages(struct l_state_struct *l_state, int index, int elem_index)
{
int j;
Interconnect_st interconnect;
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&interconnect, sizeof (interconnect));
(void) fprintf(stdout, "\t");
if (interconnect.code == S_OK) {
(void) fprintf(stdout,
MSGSTR(29, "O.K."));
revision_msg(l_state, elem_index + j);
} else if (interconnect.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
} else if (interconnect.code == S_CRITICAL) {
if (interconnect.eprom_fail != 0) {
(void) fprintf(stdout, MSGSTR(2140,
"Critical Failure: EEPROM failure"));
} else {
(void) fprintf(stdout, MSGSTR(2141,
"Critical Failure: Unknown failure"));
}
revision_msg(l_state, elem_index + j);
} else if (interconnect.code == S_NONCRITICAL) {
if (interconnect.eprom_fail != 0) {
(void) fprintf(stdout, MSGSTR(2142,
"Non-Critical Failure: EEPROM failure"));
} else {
(void) fprintf(stdout, MSGSTR(2143,
"Non-Critical Failure: Unknown failure"));
}
revision_msg(l_state, elem_index + j);
} else if (interconnect.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
revision_msg(l_state, elem_index + j);
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
}
(void) fprintf(stdout, "\n");
}
}
void
back_plane_messages(struct l_state_struct *l_state, int index, int elem_index)
{
Bp_elem_st bp;
int j;
char status_string[MAXPATHLEN];
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&bp, sizeof (bp));
if (j == 0) {
(void) fprintf(stdout,
MSGSTR(2144, "\tFront Backplane: "));
} else {
(void) fprintf(stdout,
MSGSTR(2145, "\tRear Backplane: "));
}
(void) l_element_msg_string(bp.code, status_string);
(void) fprintf(stdout, "%s", status_string);
if (bp.code != S_NOT_INSTALLED) {
revision_msg(l_state, elem_index + j);
if ((bp.byp_a_enabled || bp.en_bypass_a) &&
!(bp.byp_b_enabled || bp.en_bypass_b)) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(130, "Bypass A enabled"));
(void) fprintf(stdout, ")");
} else if ((bp.byp_b_enabled || bp.en_bypass_b) &&
!(bp.byp_a_enabled || bp.en_bypass_a)) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(129, "Bypass B enabled"));
(void) fprintf(stdout, ")");
} else if (bp.byp_b_enabled || bp.en_bypass_b) {
(void) fprintf(stdout,
MSGSTR(2146, " (Bypass's A & B enabled)"));
}
(void) fprintf(stdout, "\n");
temperature_messages(l_state, j);
} else {
(void) fprintf(stdout, "\n");
}
}
}
void
dpm_SSC100_messages(struct l_state_struct *l_state, int index, int elem_index)
{
Bp_elem_st bp;
int j;
char status_string[MAXPATHLEN];
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&bp, sizeof (bp));
(void) fprintf(stdout, MSGSTR(2246, " SSC100 #%d: "), j);
(void) l_element_msg_string(bp.code, status_string);
(void) fprintf(stdout, "%s", status_string);
if (bp.code != S_NOT_INSTALLED) {
revision_msg(l_state, elem_index + j);
if ((bp.byp_a_enabled || bp.en_bypass_a) &&
!(bp.byp_b_enabled || bp.en_bypass_b)) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(130, "Bypass A enabled"));
(void) fprintf(stdout, ")");
} else if ((bp.byp_b_enabled || bp.en_bypass_b) &&
!(bp.byp_a_enabled || bp.en_bypass_a)) {
(void) fprintf(stdout, " (");
(void) fprintf(stdout,
MSGSTR(129, "Bypass B enabled"));
(void) fprintf(stdout, ")");
} else if (bp.byp_b_enabled || bp.en_bypass_b) {
(void) fprintf(stdout,
MSGSTR(2146, " (Bypass's A & B enabled)"));
}
(void) fprintf(stdout, "\n");
} else {
(void) fprintf(stdout, "\n");
}
}
temperature_messages(l_state, 0);
}
void
loop_messages(struct l_state_struct *l_state, int index, int elem_index)
{
Loop_elem_st loop;
int j;
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&loop, sizeof (loop));
(void) fprintf(stdout, "\t");
if (j == 0) {
if (loop.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(2147, "Loop A is not installed"));
} else {
if (loop.split) {
(void) fprintf(stdout, MSGSTR(2148,
"Loop A is configured as two separate loops."));
} else {
(void) fprintf(stdout, MSGSTR(2149,
"Loop A is configured as a single loop."));
}
}
} else {
if (loop.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(2150, "Loop B is not installed"));
} else {
if (loop.split) {
(void) fprintf(stdout, MSGSTR(2151,
"Loop B is configured as two separate loops."));
} else {
(void) fprintf(stdout, MSGSTR(2152,
"Loop B is configured as a single loop."));
}
}
}
(void) fprintf(stdout, "\n");
}
}
void
ctlr_messages(struct l_state_struct *l_state, int index, int elem_index)
{
Ctlr_elem_st ctlr;
int j;
int ib_a_flag = 1;
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&ctlr, sizeof (ctlr));
if (j == 0) {
(void) fprintf(stdout, MSGSTR(2153, "\tA: "));
} else {
(void) fprintf(stdout, MSGSTR(2154, "\tB: "));
ib_a_flag = 0;
}
if (ctlr.code == S_OK) {
(void) fprintf(stdout, MSGSTR(29, "O.K."));
ib_decode(&ctlr);
revision_msg(l_state, elem_index + j);
trans_messages(l_state, ib_a_flag);
} else if (ctlr.code == S_CRITICAL) {
(void) fprintf(stdout,
MSGSTR(122, "Critical failure"));
ib_decode(&ctlr);
(void) fprintf(stdout, "\n");
} else if (ctlr.code == S_NONCRITICAL) {
(void) fprintf(stdout,
MSGSTR(89, "Non-Critical Failure"));
ib_decode(&ctlr);
(void) fprintf(stdout, "\n");
} else if (ctlr.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
(void) fprintf(stdout, "\n");
} else if (ctlr.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
(void) fprintf(stdout, "\n");
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
(void) fprintf(stdout, "\n");
}
}
}
void
fan_decode(Fan_elem_st *fan)
{
if (fan->fail) {
(void) fprintf(stdout, MSGSTR(2155,
":Yellow LED is on"));
}
if (fan->speed == 0) {
(void) fprintf(stdout, MSGSTR(2156,
":Fan stopped"));
} else if (fan->speed < S_HI_SPEED) {
(void) fprintf(stdout, MSGSTR(2157,
":Fan speed Low"));
} else {
(void) fprintf(stdout, MSGSTR(2158,
":Fan speed Hi"));
}
}
void
fan_messages(struct l_state_struct *l_state, int hdr_index, int elem_index)
{
Fan_elem_st fan;
int j;
if (l_state->ib_tbl.config.type_hdr[hdr_index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[hdr_index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[hdr_index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&fan, sizeof (fan));
(void) fprintf(stdout, "\t%d ", j);
if (fan.code == S_OK) {
(void) fprintf(stdout, MSGSTR(29, "O.K."));
revision_msg(l_state, elem_index + j);
} else if (fan.code == S_CRITICAL) {
(void) fprintf(stdout,
MSGSTR(122, "Critical failure"));
fan_decode(&fan);
revision_msg(l_state, elem_index + j);
} else if (fan.code == S_NONCRITICAL) {
(void) fprintf(stdout,
MSGSTR(89, "Non-Critical Failure"));
fan_decode(&fan);
revision_msg(l_state, elem_index + j);
} else if (fan.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
} else if (fan.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
revision_msg(l_state, elem_index + j);
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
}
}
(void) fprintf(stdout, "\n");
}
void
ps_decode(Ps_elem_st *ps)
{
if (ps->dc_over) {
(void) fprintf(stdout, MSGSTR(2159,
": DC Voltage too high"));
}
if (ps->dc_under) {
(void) fprintf(stdout, MSGSTR(2160,
": DC Voltage too low"));
}
if (ps->dc_over_i) {
(void) fprintf(stdout, MSGSTR(2161,
": DC Current too high"));
}
if (ps->ovrtmp_fail || ps->temp_warn) {
(void) fprintf(stdout, MSGSTR(2162,
": Temperature too high"));
}
if (ps->ac_fail) {
(void) fprintf(stdout, MSGSTR(2163,
": AC Failed"));
}
if (ps->dc_fail) {
(void) fprintf(stdout, MSGSTR(2164,
": DC Failed"));
}
}
void
revision_msg(struct l_state_struct *l_state, int index)
{
if (strlen((const char *)
l_state->ib_tbl.p7_s.element_desc[index].desc_string)) {
(void) fprintf(stdout, "(%s)",
l_state->ib_tbl.p7_s.element_desc[index].desc_string);
}
}
void
ps_messages(struct l_state_struct *l_state, int index, int elem_index)
{
Ps_elem_st ps;
int j;
if (l_state->ib_tbl.config.type_hdr[index].text_len != 0) {
(void) fprintf(stdout, "%s\n",
l_state->ib_tbl.config.text[index]);
}
for (j = 0; j < (int)l_state->ib_tbl.config.type_hdr[index].num;
j++) {
(void) bcopy((const void *)
&l_state->ib_tbl.p2_s.element[elem_index + j],
(void *)&ps, sizeof (ps));
(void) fprintf(stdout, "\t%d ", j);
if (ps.code == S_OK) {
(void) fprintf(stdout, MSGSTR(29, "O.K."));
revision_msg(l_state, elem_index + j);
} else if (ps.code == S_CRITICAL) {
(void) fprintf(stdout,
MSGSTR(122, "Critical failure"));
ps_decode(&ps);
revision_msg(l_state, elem_index + j);
} else if (ps.code == S_NONCRITICAL) {
(void) fprintf(stdout,
MSGSTR(89, "Non-Critical Failure"));
ps_decode(&ps);
revision_msg(l_state, elem_index + j);
} else if (ps.code == S_NOT_INSTALLED) {
(void) fprintf(stdout,
MSGSTR(30, "Not Installed"));
} else if (ps.code == S_NOT_AVAILABLE) {
(void) fprintf(stdout,
MSGSTR(34, "Disabled"));
revision_msg(l_state, elem_index + j);
} else {
(void) fprintf(stdout,
MSGSTR(4, "Unknown status"));
}
}
(void) fprintf(stdout, "\n");
}
void
abnormal_condition_display(struct l_state_struct *l_state)
{
(void) fprintf(stdout, "\n");
if (l_state->ib_tbl.p2_s.ui.crit) {
(void) fprintf(stdout,
MSGSTR(2165, " "
"CRITICAL CONDITION DETECTED\n"));
}
if (l_state->ib_tbl.p2_s.ui.non_crit) {
(void) fprintf(stdout,
MSGSTR(2166, " "
"WARNING: NON-CRITICAL CONDITION DETECTED\n"));
}
if (l_state->ib_tbl.p2_s.ui.invop) {
(void) fprintf(stdout,
MSGSTR(2167, " "
"WARNING: Invalid Operation bit set.\n"
"\tThis means an Enclosure Control page"
" or an Array Control page with an invalid\n"
"\tformat has previously been transmitted to the"
" Enclosure Services card by a\n\tSend Diagnostic"
" SCSI command.\n"));
}
(void) fprintf(stdout, "\n");
}
int
adm_start(char **argv)
{
char *path_phys = NULL;
Path_struct *path_struct;
int err = 0, retval = 0;
while (*argv != NULL) {
if ((err = l_convert_name(*argv, &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr, MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
*argv);
if (err != -1) {
(void) print_errString(err, *argv);
}
(argv)++;
retval++;
continue;
}
VERBPRINT(MSGSTR(101, "Issuing start to:\n %s\n"), *argv);
if (err = g_start(path_phys)) {
(void) print_errString(err, *argv);
(argv)++;
retval++;
continue;
}
(argv)++;
}
return (retval);
}
int
adm_stop(char **argv)
{
char *path_phys = NULL;
Path_struct *path_struct;
int err = 0, retval = 0;
while (*argv != NULL) {
if ((err = l_convert_name(*argv, &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
*argv);
if (err != -1) {
(void) print_errString(err, *argv);
}
(argv)++;
retval++;
continue;
}
if (strstr(path_phys, SLSH_DRV_NAME_ST)) {
errno = ENOTSUP;
(void) print_errString(0, path_phys);
(argv)++;
continue;
}
VERBPRINT(MSGSTR(100, "Issuing stop to:\n %s\n"), *argv);
if (err = g_stop(path_phys, 1)) {
(void) print_errString(err, *argv);
(argv)++;
retval++;
continue;
}
(argv)++;
}
return (retval);
}
int
adm_port_offline_online(char *argv[], int flag)
{
int err, retval = 0;
char *path_phys = NULL;
char *nexus_path_ptr = NULL;
Path_struct *path_struct = NULL;
while (*argv != NULL) {
if ((err = l_convert_name(*argv, &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
*argv);
if (err != -1) {
(void) print_errString(err, *argv);
}
argv++;
retval++;
continue;
}
if ((err = g_get_nexus_path(path_phys, &nexus_path_ptr)) != 0) {
(void) print_errString(err, *argv);
retval++;
goto cleanup_and_go;
}
if (flag == LUX_P_OFFLINE) {
if ((err = g_port_offline(nexus_path_ptr))) {
(void) print_errString(err, nexus_path_ptr);
retval++;
goto cleanup_and_go;
}
fprintf(stdout,
MSGSTR(2223, "Port %s has been disabled\n"),
nexus_path_ptr);
} else if (flag == LUX_P_ONLINE) {
if ((err = g_port_online(nexus_path_ptr))) {
(void) print_errString(err, nexus_path_ptr);
retval++;
goto cleanup_and_go;
}
fprintf(stdout,
MSGSTR(2224, "Port %s has been enabled\n"),
nexus_path_ptr);
} else {
(void) fprintf(stderr,
MSGSTR(2225,
"Unknown action requested "
"on port - %d\nIgnoring."),
flag);
retval++;
}
cleanup_and_go:
free(path_phys);
free(path_struct);
free(nexus_path_ptr);
argv++;
}
return (retval);
}
int
adm_display_port(int verbose)
{
static char *portdrvr_list[] = {"socal",
"fp",
"ifp",
NULL};
portlist_t portlist;
int x = 0, err = 0, retval = 0;
int port_state;
portlist.hbacnt = 0;
while (portdrvr_list[x]) {
if (err = g_get_port_path(portdrvr_list[x], &portlist)) {
if (err != L_PORT_DRIVER_NOT_FOUND &&
err != L_PHYS_PATH_NOT_FOUND) {
(void) print_errString(err, portdrvr_list[x]);
retval++;
}
}
x++;
}
for (x = 0; x < portlist.hbacnt; x++) {
if (err = g_get_port_state(portlist.physpath[x],
&port_state, verbose)) {
(void) print_errString(err, portlist.physpath[x]);
retval++;
} else {
fprintf(stdout, "%-65s ", portlist.physpath[x]);
if (port_state == PORT_CONNECTED) {
(void) fprintf(stdout,
MSGSTR(2233,
"CONNECTED\n"));
} else {
(void) fprintf(stdout,
MSGSTR(2234,
"NOT CONNECTED\n"));
}
}
}
g_free_portlist(&portlist);
return (retval);
}
int
adm_port_loopback(char *portpath, int flag)
{
int err;
char *path_phys = NULL;
Path_struct *path_struct = NULL;
int cmd;
if ((err = l_convert_name(portpath, &path_phys,
&path_struct, Options & PVERBOSE)) != 0) {
(void) fprintf(stderr,
MSGSTR(33,
" Error: converting"
" %s to physical path.\n"
" Invalid pathname.\n"),
portpath);
if (err != -1) {
(void) print_errString(err, portpath);
}
return (-1);
}
switch (flag) {
case EXT_LOOPBACK:
cmd = EXT_LPBACK;
break;
case INT_LOOPBACK:
cmd = INT_LPBACK;
break;
case NO_LOOPBACK:
cmd = NO_LPBACK;
break;
default:
(void) fprintf(stderr,
MSGSTR(2225,
"Unknown action requested "
"on port - %d\nIgnoring."),
flag);
free(path_phys);
free(path_struct);
return (-1);
}
if ((err = g_loopback_mode(path_phys, cmd)) != 0) {
(void) print_errString(err, portpath);
free(path_phys);
free(path_struct);
return (-1);
} else {
switch (flag) {
case EXT_LOOPBACK:
(void) fprintf(stdout,
MSGSTR(2230,
"External loopback mode set "
"on:\n%s\n"),
portpath);
break;
case INT_LOOPBACK:
(void) fprintf(stdout,
MSGSTR(2231,
"Internal loopback mode set "
"on:\n%s\n"),
portpath);
break;
case NO_LOOPBACK:
(void) fprintf(stdout,
MSGSTR(2232,
"Loopback mode unset "
"on:\n%s\n"),
portpath);
break;
default:
fprintf(stderr,
MSGSTR(2248, "Undefined command\n"));
break;
}
}
free(path_phys);
free(path_struct);
return (0);
}
void
adm_print_pathlist(char *dev_path)
{
int i, pathcnt = 1;
mp_pathlist_t pathlist;
int retval = 0;
char temppath[MAXPATHLEN];
char wwns[(WWN_SIZE *2) +1];
uchar_t wwn_data[WWN_SIZE];
int err;
int state, ext_state = 0;
char *path_state[5];
path_state[0] = MSGSTR(2400, "INIT");
path_state[1] = MSGSTR(2401, "ONLINE");
path_state[2] = MSGSTR(2402, "STANDBY");
path_state[3] = MSGSTR(2403, "FAULT");
path_state[4] = MSGSTR(2404, "OFFLINE");
(void) strcpy(temppath, dev_path);
retval = g_get_pathlist(temppath, &pathlist);
if (retval != 0) {
(void) print_errString(retval, NULL);
exit(-1);
}
pathcnt = pathlist.path_count;
for (i = 0; i < pathcnt; i++) {
(void) fprintf(stdout,
MSGSTR(2303, " Controller \t%s\n"),
pathlist.path_info[i].path_hba);
(void) fprintf(stdout,
MSGSTR(2304, " Device Address\t\t%s\n"),
pathlist.path_info[i].path_addr);
if ((err = get_host_controller_pwwn(
pathlist.path_info[i].path_hba,
(uchar_t *)&wwn_data)) != 0) {
if (err != ENOTSUP) {
(void) print_errString(err,
pathlist.path_info[i].path_hba);
exit(1);
}
}
if (!err) {
copy_wwn_data_to_str(wwns, wwn_data);
(void) fprintf(stdout,
MSGSTR(2326, " Host controller port WWN\t%s\n"),
wwns);
}
(void) fprintf(stdout,
MSGSTR(2305, " Class\t\t\t%s\n"),
pathlist.path_info[i].path_class);
if (pathlist.path_info[i].path_state < MAXPATHSTATE) {
(void) fprintf(stdout,
MSGSTR(2306, " State\t\t\t%s\n"),
path_state[pathlist.path_info[i].path_state]);
}
if ((err = g_stms_get_path_state(dev_path,
pathlist.path_info[i].path_hba, &state,
&ext_state)) != 0) {
(void) print_errString(err,
pathlist.path_info[i].path_hba);
exit(1);
} else {
if ((ext_state & MDI_PATHINFO_STATE_USER_DISABLE)
== MDI_PATHINFO_STATE_USER_DISABLE) {
ext_state = 0;
fprintf(stdout,
MSGSTR(2327,
" I/Os disabled on this %s path\n\n"),
path_state[pathlist.path_info[i].path_state]);
}
}
}
free(pathlist.path_info);
}
int
compare_multipath(char *path, struct mplist_struct *pathlist)
{
while (pathlist != NULL) {
if (strncmp(path, pathlist->devpath, MAXPATHLEN) == 0) {
return (0);
}
pathlist = pathlist->next;
}
return (1);
}
static int
lun_display(Path_struct *path_struct, L_inquiry inq_struct, int verbose)
{
char phys_path[MAXPATHLEN], last_logical_path[MAXPATHLEN];
uchar_t *pg_buf = NULL;
L_disk_state l_disk_state;
struct dlist *mlist;
int offset, mode_data_avail, err = 0;
Mode_header_10 *mode_header_ptr;
struct mode_page *pg_hdr = NULL;
WWN_list *wwn_list, *list_start, *wwn_list_ptr;
WWN_list *wwn_list_find;
int found = 0;
int argpwwn = 0, argnwwn = 0;
struct mplist_struct *mplistp, *mpl, *mpln;
struct dlist *dlist;
strcpy(phys_path, path_struct->p_physical_path);
strcpy(last_logical_path, phys_path);
mplistp = mpl = mpln = (struct mplist_struct *)NULL;
if (strstr(path_struct->argv, "/") != NULL) {
if ((err = g_devices_get_all(&wwn_list)) != 0) {
return (err);
}
} else {
if ((err = g_get_wwn_list(&wwn_list, verbose)) != 0) {
return (err);
}
}
g_sort_wwn_list(&wwn_list);
list_start = wwn_list;
for (wwn_list_ptr = wwn_list; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (strcasecmp(wwn_list_ptr->port_wwn_s,
path_struct->argv) == 0) {
list_start = wwn_list_ptr;
argpwwn = 1;
break;
} else if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) == 0) {
list_start = wwn_list_ptr;
argnwwn = 1;
break;
}
}
for (wwn_list_ptr = list_start; wwn_list_ptr != NULL;
wwn_list_ptr = wwn_list_ptr->wwn_next) {
if (argpwwn) {
if (strcasecmp(wwn_list_ptr->port_wwn_s,
path_struct->argv) != 0) {
continue;
}
(void) strcpy(phys_path, wwn_list_ptr->physical_path);
} else if (argnwwn) {
if (strstr(wwn_list_ptr->logical_path,
last_logical_path) != NULL) {
continue;
}
if (strcasecmp(wwn_list_ptr->node_wwn_s,
path_struct->argv) != 0) {
continue;
}
(void) strcpy(phys_path, wwn_list_ptr->physical_path);
(void) strcpy(last_logical_path,
wwn_list_ptr->logical_path);
}
if (argnwwn || argpwwn) {
if (compare_multipath(wwn_list_ptr->logical_path,
mplistp) == 0) {
continue;
}
}
mode_data_avail = 0;
(void) memset(&l_disk_state, 0, sizeof (struct l_disk_state_struct));
if (strstr(phys_path, SCSI_VHCI) == NULL) {
if ((err = g_get_multipath(phys_path,
&(l_disk_state.g_disk_state.multipath_list),
wwn_list, verbose)) != 0) {
return (err);
}
mlist = l_disk_state.g_disk_state.multipath_list;
if (mlist == NULL) {
l_disk_state.l_state_flag = L_NO_PATH_FOUND;
N_DPRINTF(" lun_display: Error finding"
" multiple paths to the disk.\n");
(void) g_free_wwn_list(&wwn_list);
return (L_NO_VALID_PATH);
}
} else {
for (wwn_list_find = list_start; wwn_list_find != NULL;
wwn_list_find = wwn_list_find->wwn_next) {
if (strncmp(wwn_list_find->physical_path, phys_path,
strlen(wwn_list_find->physical_path))
== 0) {
found++;
break;
}
}
if (!found) {
return (L_NO_VALID_PATH);
} else {
found = 0;
}
if ((dlist = (struct dlist *)
calloc(1, sizeof (struct dlist))) == NULL) {
return (L_MALLOC_FAILED);
}
if ((dlist->logical_path = (char *)calloc(1,
strlen(wwn_list_find->logical_path) + 1)) == NULL) {
return (L_MALLOC_FAILED);
}
if ((dlist->dev_path = (char *)calloc(1,
strlen(phys_path) + 1)) == NULL) {
return (L_MALLOC_FAILED);
}
strncpy(dlist->logical_path, wwn_list_find->logical_path,
strlen(wwn_list_find->logical_path));
strncpy(dlist->dev_path, phys_path, strlen(phys_path));
l_disk_state.g_disk_state.multipath_list = dlist;
}
if (argnwwn || argpwwn) {
for (mlist = l_disk_state.g_disk_state.multipath_list;
mlist != NULL; mlist = mlist->next) {
if ((mpl = (struct mplist_struct *)
calloc(1, sizeof (struct mplist_struct)))
== NULL) {
adm_mplist_free(mplistp);
return (L_MALLOC_FAILED);
}
mpl->devpath = (char *)calloc(1, MAXPATHLEN+1);
if (mpl->devpath == NULL) {
adm_mplist_free(mplistp);
return (L_MALLOC_FAILED);
}
strncpy(mpl->devpath, mlist->logical_path,
strlen(mlist->logical_path));
if (mplistp == NULL) {
mplistp = mpln = mpl;
} else {
mpln->next = mpl;
mpln = mpl;
}
}
}
if (l_get_mode_pg(phys_path, &pg_buf, verbose) == 0) {
mode_header_ptr = (struct mode_header_10_struct *)
(void *)pg_buf;
offset = sizeof (struct mode_header_10_struct) +
mode_header_ptr->bdesc_length;
pg_hdr = (struct mode_page *)&pg_buf[offset];
while (offset < (mode_header_ptr->length +
sizeof (mode_header_ptr->length)) &&
!mode_data_avail) {
if (pg_hdr->code == MODEPAGE_CACHING) {
mode_data_avail++;
break;
}
offset += pg_hdr->length + sizeof (struct mode_page);
pg_hdr = (struct mode_page *)&pg_buf[offset];
}
}
switch ((inq_struct.inq_dtype & DTYPE_MASK)) {
case DTYPE_DIRECT:
fprintf(stdout, MSGSTR(121, "DEVICE PROPERTIES for disk: %s\n"),
path_struct->argv);
break;
case DTYPE_SEQUENTIAL:
fprintf(stdout, MSGSTR(2249, "DEVICE PROPERTIES for tape: %s\n"),
path_struct->argv);
break;
default:
fprintf(stdout, MSGSTR(2250, "DEVICE PROPERTIES for: %s\n"),
path_struct->argv);
break;
}
(void) display_lun_info(l_disk_state, path_struct, pg_hdr,
mode_data_avail, wwn_list, phys_path);
(void) g_free_multipath(l_disk_state.g_disk_state.multipath_list);
if (!(argpwwn || argnwwn)) {
break;
}
}
(void) g_free_wwn_list(&wwn_list);
adm_mplist_free(mplistp);
return (0);
}
void
display_lun_info(L_disk_state l_disk_state, Path_struct *path_struct,
struct mode_page *pg_hdr, int mode_data_avail, WWN_list
*wwn_list, char *phys_path)
{
float lunMbytes;
struct scsi_capacity_16 cap_data;
struct dlist *mlist;
struct my_mode_caching *pg8_buf;
int err;
L_inquiry inq;
hrtime_t start_time = 0, end_time;
char *envdb = NULL;
int peripheral_qual;
L_inquiry80 inq80;
size_t serial_len = sizeof (inq80.inq_serial);
if ((envdb = getenv("_LUX_T_DEBUG")) != NULL) {
start_time = gethrtime();
}
memset(&cap_data, 0, sizeof (cap_data));
if (err = g_get_inquiry(phys_path, &inq)) {
fprintf(stderr, "\n");
print_errString(err, phys_path);
fprintf(stderr, "\n");
exit(1);
}
if (err = g_get_serial_number(phys_path, inq80.inq_serial,
&serial_len)) {
fprintf(stderr, "\n");
print_errString(err, phys_path);
fprintf(stderr, "\n");
exit(1);
}
peripheral_qual = inq.inq_dtype & ~DTYPE_MASK;
if (peripheral_qual != DPQ_POSSIBLE) {
fprintf(stderr, MSGSTR(2254, "\n Error: Logical Unit "
"(%s) is not available.\n"), phys_path);
exit(1);
}
fprintf(stdout, " ");
fprintf(stdout, MSGSTR(3, "Vendor:"));
fprintf(stdout, "\t\t");
print_chars(inq.inq_vid, sizeof (inq.inq_vid), 0);
fprintf(stdout, MSGSTR(2115, "\n Product ID:\t\t"));
print_chars(inq.inq_pid, sizeof (inq.inq_pid), 0);
fprintf(stdout, "\n ");
fprintf(stdout, MSGSTR(2119, "Revision:"));
fprintf(stdout, "\t\t");
print_chars(inq.inq_revision, sizeof (inq.inq_revision), 0);
fprintf(stdout, "\n ");
fprintf(stdout, MSGSTR(17, "Serial Num:"));
fprintf(stdout, "\t\t");
print_chars(inq80.inq_serial, serial_len, 0);
if ((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) {
if ((err = get_lun_capacity(phys_path, &cap_data)) != 0) {
print_errString(err, phys_path);
exit(1);
}
if (cap_data.sc_capacity > 0 && cap_data.sc_lbasize > 0) {
lunMbytes = cap_data.sc_capacity + 1;
lunMbytes *= cap_data.sc_lbasize;
lunMbytes /= (float)(1024*1024);
fprintf(stdout, "\n ");
fprintf(stdout, MSGSTR(60,
"Unformatted capacity:\t%6.3f MBytes"), lunMbytes);
}
}
fprintf(stdout, "\n");
if ((mode_data_avail) && (pg_hdr->code == MODEPAGE_CACHING)) {
pg8_buf = (struct my_mode_caching *)(void *)pg_hdr;
if (pg8_buf->wce) {
fprintf(stdout, MSGSTR(2122, " Write Cache:\t\t"
"Enabled\n"));
}
if (pg8_buf->rcd == 0) {
fprintf(stdout, MSGSTR(2123, " Read Cache:\t\t"
"Enabled\n"));
fprintf(stdout, MSGSTR(2124, " Minimum prefetch:"
"\t0x%x\n Maximum prefetch:\t0x%x\n"),
pg8_buf->min_prefetch,
pg8_buf->max_prefetch);
}
}
fprintf(stdout, " %s\t\t%s\n", MSGSTR(35, "Device Type:"),
dtype[inq.inq_dtype & DTYPE_MASK]);
fprintf(stdout, MSGSTR(2128, " Path(s):\n"));
fprintf(stdout, "\n");
if ((mlist = l_disk_state.g_disk_state.multipath_list) == NULL) {
fprintf(stderr, MSGSTR(2323, "Error: No paths found (%s)"),
path_struct->argv);
exit(1);
}
if (strstr(mlist->dev_path, SCSI_VHCI) != NULL) {
fprintf(stdout, " %s\n %s\n",
mlist->logical_path, mlist->dev_path);
adm_print_pathlist(mlist->dev_path);
} else {
for (mlist = l_disk_state.g_disk_state.multipath_list;
mlist != NULL; mlist = mlist->next) {
if ((strcmp(mlist->dev_path, path_struct->p_physical_path))
== 0) {
display_path_info(mlist->dev_path, mlist->logical_path,
wwn_list);
break;
}
}
for (mlist = l_disk_state.g_disk_state.multipath_list;
mlist != NULL; mlist = mlist->next) {
if ((strcmp(mlist->dev_path, path_struct->p_physical_path))
== 0) {
continue;
}
if (err = g_get_inquiry(mlist->dev_path, &inq)) {
fprintf(stderr, "\n");
print_errString(err, mlist->dev_path);
fprintf(stderr, "\n");
exit(1);
}
display_path_info(mlist->dev_path, mlist->logical_path,
wwn_list);
}
}
fprintf(stdout, "\n");
if (envdb != NULL) {
end_time = gethrtime();
fprintf(stdout, " display_lun_info: "
"\t\tTime = %lld millisec\n",
(end_time - start_time)/1000000);
}
}
static void
display_path_info(char *devpath, char *logicalpath, WWN_list *wwn_list)
{
WWN_list *wwn_list_walk;
int err;
uchar_t wwn_data[WWN_SIZE];
char wwns[(WWN_SIZE *2) +1];
char drvr_path[MAXPATHLEN];
char *cptr;
int status;
fprintf(stdout, " %s\n", logicalpath);
fprintf(stdout, " %s\n", devpath);
fprintf(stdout, " %s\t\t", MSGSTR(2321, "LUN path port WWN:"));
for (wwn_list_walk = wwn_list; wwn_list_walk != NULL;
wwn_list_walk = wwn_list_walk->wwn_next) {
if (strcmp(wwn_list_walk->physical_path, devpath) == 0) {
fprintf(stdout, "%s", wwn_list_walk->port_wwn_s);
break;
}
}
fprintf(stdout, "\n");
drvr_path[0] = '\0';
(void) strcat(drvr_path, devpath);
if (((cptr = strstr(drvr_path, SLSH_DRV_NAME_SSD)) != NULL) ||
((cptr = strstr(drvr_path, SLSH_DRV_NAME_ST)) != NULL)) {;
*cptr = '\0';
} else {
fprintf(stderr, MSGSTR(2324, "Error: Incorrect path (%s)\n"),
drvr_path);
exit(1);
}
*cptr = '\0';
if ((err = get_host_controller_pwwn(drvr_path,
(uchar_t *)&wwn_data)) != 0) {
print_errString(err, drvr_path);
exit(1);
}
copy_wwn_data_to_str(wwns, wwn_data);
fprintf(stdout, " %s\t%s\n",
MSGSTR(2322, "Host controller port WWN:"), wwns);
if ((err = get_path_status(devpath, &status)) != 0) {
print_errString(err, devpath);
exit(1);
} else {
fprintf(stdout, " %s\t\t", MSGSTR(2329, "Path status:"));
display_port_status(status);
}
}
static int
get_lun_capacity(char *devpath, struct scsi_capacity_16 *cap_data)
{
int fd;
if (devpath == NULL || cap_data == NULL) {
return (L_INVALID_PATH);
}
if ((fd = g_object_open(devpath, O_RDONLY | O_NDELAY)) == -1) {
return (L_OPEN_PATH_FAIL);
} else {
(void) g_scsi_read_capacity_1016_cmd(fd, cap_data,
sizeof (struct scsi_capacity_16));
close(fd);
}
return (0);
}
static int
get_path_status(char *devpath, int *status)
{
int fd, mystatus = 0;
if (devpath == NULL || status == NULL) {
return (L_INVALID_PATH);
}
*status = 0;
if ((fd = g_object_open(devpath, O_RDONLY | O_NDELAY)) == -1) {
return (L_OPEN_PATH_FAIL);
} else {
if ((mystatus = g_scsi_tur(fd)) != 0) {
if ((mystatus & L_SCSI_ERROR) &&
((mystatus & ~L_SCSI_ERROR) == STATUS_CHECK)) {
*status = L_NOT_READY;
} else if ((mystatus & L_SCSI_ERROR) &&
((mystatus & ~L_SCSI_ERROR) ==
STATUS_RESERVATION_CONFLICT)) {
*status = L_RESERVED;
} else {
*status = L_SCSI_ERR;
}
}
}
close(fd);
return (0);
}
static int
get_host_controller_pwwn(char *hba_path, uchar_t *pwwn)
{
char *cptr, *portptr;
int found = 0, err, devlen;
char my_hba_path[MAXPATHLEN];
di_node_t node;
di_prom_prop_t promprop;
uchar_t *port_wwn_data = NULL;
int di_ret;
di_prom_handle_t ph;
char *promname;
uchar_t *promdata;
uint_t path_type;
fc_port_dev_t hba_port;
if (hba_path == NULL || pwwn == NULL) {
return (L_INVALID_PATH);
}
if ((path_type = g_get_path_type(hba_path)) == 0) {
return (L_INVALID_PATH);
}
if (path_type & FC4_XPORT_MASK) {
if ((err = get_FC4_host_controller_pwwn(hba_path, pwwn)) != 0) {
return (err);
} else {
return (0);
}
} else if ((path_type & FC_GEN_XPORT) &&
((path_type & FC_FCA_MASK) == FC_FCA_MASK)) {
my_hba_path[0] = '\0';
(void) strlcat(my_hba_path, hba_path, sizeof (my_hba_path));
(void) snprintf(my_hba_path, sizeof (my_hba_path), "%s%s",
hba_path, FC_CTLR);
if ((err = g_get_host_params(
my_hba_path, &hba_port, 0)) != 0) {
return (err);
} else {
(void) memcpy(pwwn, &hba_port.dev_pwwn.raw_wwn[0],
WWN_SIZE);
return (0);
}
} else if ((path_type & FC_FCA_MASK) == FC_PCI_FCA) {
my_hba_path[0] = '\0';
(void) strlcat(my_hba_path, hba_path, sizeof (my_hba_path));
if (strlen(my_hba_path) > (devlen = strlen("/devices"))) {
cptr = &my_hba_path[devlen];
} else {
return (L_INVALID_PATH);
}
if ((portptr = strstr(cptr, "/fp@")) != NULL) {
*portptr = '\0';
}
if ((node = di_init(cptr, DINFOCPYALL)) == DI_NODE_NIL) {
return (L_DEV_SNAPSHOT_FAILED);
}
if (di_nodeid(node) == DI_SID_NODEID) {
di_ret = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
"port-wwn", &port_wwn_data);
if (di_ret == -1 || port_wwn_data == NULL) {
di_fini(node);
return (L_NO_WWN_PROP_FOUND);
} else {
(void) memcpy(pwwn, port_wwn_data, WWN_SIZE);
found++;
}
} else if (di_nodeid(node) == DI_PROM_NODEID) {
if ((ph = di_prom_init()) == DI_PROM_HANDLE_NIL) {
di_fini(node);
return (L_PROM_INIT_FAILED);
}
for (promprop = di_prom_prop_next(ph, node,
DI_PROM_PROP_NIL);
promprop != DI_PROM_PROP_NIL;
promprop = di_prom_prop_next(ph, node, promprop)) {
if (((promname = di_prom_prop_name(
promprop)) != NULL) &&
(strcmp(promname, "port-wwn") == 0) &&
(di_prom_prop_data(promprop,
&promdata) == WWN_SIZE)) {
(void) memcpy(pwwn, promdata, WWN_SIZE);
found++;
break;
}
}
di_prom_fini(ph);
}
di_fini(node);
if (found) {
return (0);
} else {
return (L_INVALID_PATH);
}
} else {
return (L_INVALID_PATH_TYPE);
}
}
static int
get_FC4_host_controller_pwwn(char *hba_path, uchar_t *pwwn)
{
sf_al_map_t sf_map;
char my_hba_path[MAXPATHLEN];
int fd;
if (hba_path == NULL || pwwn == NULL) {
return (L_INVALID_PATH);
}
(void) snprintf(my_hba_path, sizeof (my_hba_path), "%s%s",
hba_path, FC_CTLR);
if ((fd = g_object_open(my_hba_path, O_NDELAY | O_RDONLY)) == -1) {
return (errno);
}
memset(&sf_map, 0, sizeof (sf_al_map_t));
if (ioctl(fd, SFIOCGMAP, &sf_map) != 0) {
close(fd);
return (L_SFIOCGMAP_IOCTL_FAIL);
}
close(fd);
if (sf_map.sf_count == 0) {
close(fd);
return (L_SFIOCGMAP_IOCTL_FAIL);
}
(void) memcpy(pwwn, &sf_map.sf_hba_addr.sf_port_wwn[0], WWN_SIZE);
return (0);
}
void
copy_wwn_data_to_str(char *to_ptr, const uchar_t *from_ptr)
{
if ((to_ptr == NULL) || (from_ptr == NULL))
return;
sprintf(to_ptr, "%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
from_ptr[0], from_ptr[1], from_ptr[2], from_ptr[3],
from_ptr[4], from_ptr[5], from_ptr[6], from_ptr[7]);
}
void
adm_mplist_free(struct mplist_struct *mplistp)
{
struct mplist_struct *mplistn;
while (mplistp != NULL) {
mplistn = mplistp->next;
if (mplistp->devpath != NULL) {
free(mplistp->devpath);
mplistp->devpath = NULL;
}
free(mplistp);
mplistp = mplistn;
}
}
int
adm_reserve(char *path)
{
char *path_phys = NULL;
int err;
if ((path_phys =
g_get_physical_name(path)) == NULL) {
(void) fprintf(stderr, "%s: ", whoami);
(void) fprintf(stderr,
MSGSTR(112, "Error: Invalid pathname (%s)"),
path);
(void) fprintf(stderr, "\n");
return (1);
}
if ((err = g_reserve(path_phys)) != 0) {
(void) print_errString(err, path);
return (1);
}
return (0);
}
int
adm_release(char *path)
{
char *path_phys = NULL;
int err;
if ((path_phys =
g_get_physical_name(path)) == NULL) {
(void) fprintf(stderr, "%s: ", whoami);
(void) fprintf(stderr,
MSGSTR(112, "Error: Invalid pathname (%s)"),
path);
(void) fprintf(stderr, "\n");
return (1);
}
if ((err = g_release(path_phys)) != 0) {
(void) print_errString(err, path);
return (1);
}
return (0);
}
void
i18n_catopen() {
(void) g_i18n_catopen();
}
int adm_check_file(char **path, int flag) {
int err;
if (err = l_check_file(*path, flag)) {
(void) print_errString(err, *path);
return (-1);
}
(void) fprintf(stdout, MSGSTR(2212, "Download file O.K. \n\n"));
return (0);
}
void
print_private_loop_dtype_prop(uchar_t *hba_port_wwn, uchar_t *port_wwn,
uchar_t dtype_prop)
{
if ((dtype_prop & DTYPE_MASK) < 0x10) {
(void) fprintf(stdout, " 0x%-2x (%s",
(dtype_prop & DTYPE_MASK), dtype[(dtype_prop & DTYPE_MASK)]);
} else if ((dtype_prop & DTYPE_MASK) < 0x1f) {
(void) fprintf(stdout,
MSGSTR(2243, " 0x%-2x (Reserved"),
(dtype_prop & DTYPE_MASK));
} else {
(void) fprintf(stdout, MSGSTR(2245,
" 0x%-2x (Unknown Type"), (dtype_prop & DTYPE_MASK));
}
if (wwnConversion(hba_port_wwn) == wwnConversion(port_wwn)) {
(void) fprintf(stdout, MSGSTR(2244,
",Host Bus Adapter)\n"));
} else {
(void) fprintf(stdout, ")\n");
}
}
