/**
* IBM IPR dump formatting utility
*
* (C) Copyright 2015
* International Business Machines Corporation and others.
* All Rights Reserved. This program and the accompanying
* materials are made available under the terms of the
* Common Public License v1.0 which accompanies this distribution.
**/
#include <endian.h>
#include <getopt.h>
#include "iprlib.h"
#define EYE_CATCHER_BE 0xC5D4E3F2
#define EYE_CATCHER_LE 0xF2E3D4C5
#define OS_LINUX 0x4C4E5558
#define DRV_IPR2 0x49505232
#define TYPE_ASCII 0x41534349
#define TYPE_BIN 0x42494E41
#define TYPE_MR32 0x4D523332
#define TYPE_MR64 0x4D523634
#define ID_IOA_DUMP 0x494F4131
#define ID_IOA_LOC 0x4C4F4341
#define ID_DRV_TRACE 0x54524143
#define ID_DRV_VER 0x44525652
#define ID_DRV_TYPE 0x54595045
#define ID_DRV_CTRL_BLK 0x494F4342
#define ID_DRV_PEND_OPS 0x414F5053
#define IPR_DUMP_STATUS_SUCCESS 0
#define IPR_DUMP_STATUS_QUAL_SUCCESS 2
#define IPR_DUMP_STATUS_FAILED 0xFFFFFFFF
static const struct {
const u8 op;
const char *name;
} scsi_cmnds[] = {
{ 0xc1, "IPR_CANCEL_REQUEST" },
{ 0xc2, "IPR_QUERY_RSRC_STATE" },
{ 0xc3, "IPR_RESET_DEVICE" },
{ 0xc4, "IPR_ID_HOST_RR_Q" },
{ 0xc5, "IPR_QUERY_IOA_CONFIG" },
{ 0xce, "IPR_CANCEL_ALL_REQUESTS" },
{ 0xcf, "IPR_HOST_CONTROLLED_ASYNC" },
{ 0xfb, "IPR_SET_SUPPORTED_DEVICES" },
{ 0xf7, "IPR_IOA_SHUTDOWN" },
{ 0x00, "TEST_UNIT_READY" },
{ 0x01, "REZERO_UNIT" },
{ 0x03, "REQUEST_SENSE" },
{ 0x04, "FORMAT_UNIT" },
{ 0x05, "READ_BLOCK_LIMITS" },
{ 0x07, "REASSIGN_BLOCKS" },
{ 0x07, "INITIALIZE_ELEMENT_STATUS" },
{ 0x08, "READ_6" },
{ 0x0a, "WRITE_6" },
{ 0x0b, "SEEK_6" },
{ 0x0f, "READ_REVERSE" },
{ 0x10, "WRITE_FILEMARKS" },
{ 0x11, "SPACE" },
{ 0x12, "INQUIRY" },
{ 0x14, "RECOVER_BUFFERED_DATA" },
{ 0x15, "MODE_SELECT" },
{ 0x16, "RESERVE" },
{ 0x17, "RELEASE" },
{ 0x18, "COPY" },
{ 0x19, "ERASE" },
{ 0x1a, "MODE_SENSE" },
{ 0x1b, "START_STOP" },
{ 0x1c, "RECEIVE_DIAGNOSTIC" },
{ 0x1d, "SEND_DIAGNOSTIC" },
{ 0x1e, "ALLOW_MEDIUM_REMOVAL" },
{ 0x23, "READ_FORMAT_CAPACITIES" },
{ 0x24, "SET_WINDOW" },
{ 0x25, "READ_CAPACITY" },
{ 0x28, "READ_10" },
{ 0x2a, "WRITE_10" },
{ 0x2b, "SEEK_10" },
{ 0x2b, "POSITION_TO_ELEMENT" },
{ 0x2e, "WRITE_VERIFY" },
{ 0x2f, "VERIFY" },
{ 0x30, "SEARCH_HIGH" },
{ 0x31, "SEARCH_EQUAL" },
{ 0x32, "SEARCH_LOW" },
{ 0x33, "SET_LIMITS" },
{ 0x34, "PRE_FETCH" },
{ 0x34, "READ_POSITION" },
{ 0x35, "SYNCHRONIZE_CACHE" },
{ 0x36, "LOCK_UNLOCK_CACHE" },
{ 0x37, "READ_DEFECT_DATA" },
{ 0x38, "MEDIUM_SCAN" },
{ 0x39, "COMPARE" },
{ 0x3a, "COPY_VERIFY" },
{ 0x3b, "WRITE_BUFFER" },
{ 0x3c, "READ_BUFFER" },
{ 0x3d, "UPDATE_BLOCK" },
{ 0x3e, "READ_LONG" },
{ 0x3f, "WRITE_LONG" },
{ 0x40, "CHANGE_DEFINITION" },
{ 0x41, "WRITE_SAME" },
{ 0x42, "UNMAP" },
{ 0x43, "READ_TOC" },
{ 0x44, "READ_HEADER" },
{ 0x4a, "GET_EVENT_STATUS_NOTIFICATION" },
{ 0x4c, "LOG_SELECT" },
{ 0x4d, "LOG_SENSE" },
{ 0x53, "XDWRITEREAD_10" },
{ 0x55, "MODE_SELECT_10" },
{ 0x56, "RESERVE_10" },
{ 0x57, "RELEASE_10" },
{ 0x5a, "MODE_SENSE_10" },
{ 0x5e, "PERSISTENT_RESERVE_IN" },
{ 0x5f, "PERSISTENT_RESERVE_OUT" },
{ 0x7f, "VARIABLE_LENGTH_CMD" },
{ 0xa0, "REPORT_LUNS" },
{ 0xa2, "SECURITY_PROTOCOL_IN" },
{ 0xa3, "MAINTENANCE_IN" },
{ 0xa4, "MAINTENANCE_OUT" },
{ 0xa5, "MOVE_MEDIUM" },
{ 0xa6, "EXCHANGE_MEDIUM" },
{ 0xa8, "READ_12" },
{ 0xa9, "SERVICE_ACTION_OUT_12" },
{ 0xaa, "WRITE_12" },
{ 0xab, "SERVICE_ACTION_IN_12" },
{ 0xae, "WRITE_VERIFY_12" },
{ 0xaf, "VERIFY_12" },
{ 0xb0, "SEARCH_HIGH_12" },
{ 0xb1, "SEARCH_EQUAL_12" },
{ 0xb2, "SEARCH_LOW_12" },
{ 0xb5, "SECURITY_PROTOCOL_OUT" },
{ 0xb8, "READ_ELEMENT_STATUS" },
{ 0xb6, "SEND_VOLUME_TAG" },
{ 0xea, "WRITE_LONG_2" },
{ 0x83, "EXTENDED_COPY" },
{ 0x84, "RECEIVE_COPY_RESULTS" },
{ 0x86, "ACCESS_CONTROL_IN" },
{ 0x87, "ACCESS_CONTROL_OUT" },
{ 0x88, "READ_16" },
{ 0x89, "COMPARE_AND_WRITE" },
{ 0x8a, "WRITE_16" },
{ 0x8c, "READ_ATTRIBUTE" },
{ 0x8d, "WRITE_ATTRIBUTE" },
{ 0x8f, "VERIFY_16" },
{ 0x91, "SYNCHRONIZE_CACHE_16" },
{ 0x93, "WRITE_SAME_16" },
{ 0x9d, "SERVICE_ACTION_BIDIRECTIONAL" },
{ 0x9e, "SERVICE_ACTION_IN_16" },
{ 0x9f, "SERVICE_ACTION_OUT_16" }
};
struct ipr_dump_header {
u32 eye_catcher;
u32 len;
u32 num_entries;
u32 first_entry_offset;
u32 status;
u32 os;
u32 driver_name;
};
struct ipr_dump_entry_header {
u32 eye_catcher;
u32 len; /* does not include entry header */
u32 num_elems;
u32 offset; /* offset to data from beginning of dump file */
u32 data_type;
u32 id;
u32 status;
};
struct ipr_trace_entry {
u32 time;
u8 op_code; /* SCSI opcode */
u8 ata_op_code;
u8 type;
#define IPR_TRACE_START 0x00
#define IPR_TRACE_FINISH 0xff
u8 cmd_index;
u32 res_handle; /* stored as BE */
union {
u32 ioasc;
u32 add_data;
u32 res_addr;
} u;
};
static void *dump_map; /* ipr dump memory map */
static FILE *out_fp; /* output report file pointer */
static int verbose_trace; /* flag for verbose trace printing */
#define TARGET_TO_HOST32(value, eye_catcher) \
(eye_catcher == EYE_CATCHER_BE ? \
be32toh(value) : \
le32toh(value))
/**
* get_scsi_command_literal -
* @value: SCSI opcode
*
* Returns:
* SCSI command string
**/
static const char* get_scsi_command_literal(u32 value)
{
u32 i = 0;
for (i = 0; i < ARRAY_SIZE(scsi_cmnds); ++i) {
if (value == scsi_cmnds[i].op)
return scsi_cmnds[i].name;
}
return NULL;
}
/**
* read_dump_header -
* @hdr: ipr dump header pointer
*
* Returns:
* nothing
**/
static void read_dump_header(struct ipr_dump_header *hdr)
{
struct ipr_dump_header *raw_hdr = dump_map;
hdr->eye_catcher = htobe32(raw_hdr->eye_catcher);
/* convert to correct endianness */
hdr->len = TARGET_TO_HOST32(raw_hdr->len, hdr->eye_catcher);
hdr->num_entries = TARGET_TO_HOST32(raw_hdr->num_entries,
hdr->eye_catcher);
hdr->first_entry_offset = TARGET_TO_HOST32(raw_hdr->first_entry_offset,
hdr->eye_catcher);
hdr->status = TARGET_TO_HOST32(raw_hdr->status, hdr->eye_catcher);
hdr->os = TARGET_TO_HOST32(raw_hdr->os, hdr->eye_catcher);
hdr->driver_name = TARGET_TO_HOST32(raw_hdr->driver_name,
hdr->eye_catcher);
}
/**
* print_dump_header -
* @hdr: ipr dump header pointer
*
* Returns:
* nothing
**/
static void print_dump_header(struct ipr_dump_header *hdr)
{
fprintf(out_fp, "IPR Adapter Dump Report\n\n");
switch (hdr->eye_catcher) {
case EYE_CATCHER_BE:
fprintf(out_fp, "Big Endian format: ");
break;
case EYE_CATCHER_LE:
fprintf(out_fp, "Little Endian format: ");
break;
default:
fprintf(out_fp, "Unknown dump format: ");
}
fprintf(out_fp, "Eye Catcher is 0x%08X\n", hdr->eye_catcher);
fprintf(out_fp, "Total length: %d bytes\n", hdr->len);
fprintf(out_fp, "Number of dump entries: %d\n", hdr->num_entries);
fprintf(out_fp, "Offset to first entry: 0x%08X bytes\n",
hdr->first_entry_offset);
fprintf(out_fp, "Dump status: 0x%08X ", hdr->status);
switch (hdr->status) {
case IPR_DUMP_STATUS_SUCCESS:
fprintf(out_fp, "(SUCCESS)\n");
break;
case IPR_DUMP_STATUS_QUAL_SUCCESS:
fprintf(out_fp, "(QUAL_SUCCESS)\n");
break;
case IPR_DUMP_STATUS_FAILED:
fprintf(out_fp, "(FAILED)\n");
break;
default:
fprintf(out_fp, "(UNKNOWN)\n");
}
fprintf(out_fp, "Operating System: ");
switch (hdr->os) {
case OS_LINUX:
fprintf(out_fp, "Linux\n");
break;
default:
fprintf(out_fp, "unknown\n");
}
fprintf(out_fp, "Driver: ");
switch (hdr->driver_name) {
case DRV_IPR2:
fprintf(out_fp, "ipr2\n");
break;
default:
fprintf(out_fp, "unknown\n");
}
}
/**
* read_entry_header -
* @hdr: ipr dump entry header pointer
* @offset: offset to entry data
*
* Returns:
* offset to next entry header
**/
static u32 read_entry_header(struct ipr_dump_entry_header *hdr, u32 offset)
{
struct ipr_dump_entry_header *raw_hdr = dump_map+offset;
hdr->eye_catcher = htobe32(raw_hdr->eye_catcher);
/* convert to correct endianness */
hdr->len = TARGET_TO_HOST32(raw_hdr->len, hdr->eye_catcher);
hdr->num_elems = TARGET_TO_HOST32(raw_hdr->num_elems, hdr->eye_catcher);
hdr->offset = TARGET_TO_HOST32(raw_hdr->offset, hdr->eye_catcher);
hdr->data_type = TARGET_TO_HOST32(raw_hdr->data_type, hdr->eye_catcher);
hdr->id = TARGET_TO_HOST32(raw_hdr->id, hdr->eye_catcher);
hdr->status = TARGET_TO_HOST32(raw_hdr->status, hdr->eye_catcher);
hdr->offset += offset;
return (hdr->offset + hdr->len);
}
/**
* read_trace_data -
* @offset: offset to entry data
* @eye_catcher: ipr entry eye catcher
*
* Returns:
* ipr trace entry structure
**/
static struct ipr_trace_entry read_trace_data(u32 offset, u32 eye_catcher)
{
struct ipr_trace_entry trace;
struct ipr_trace_entry *raw_trace = dump_map+offset;
/* always stored as BE */
trace.res_handle = htobe32(raw_trace->res_handle);
/* convert to correct endianness */
trace.time = TARGET_TO_HOST32(raw_trace->time, eye_catcher);
trace.u.add_data = TARGET_TO_HOST32(raw_trace->u.add_data, eye_catcher);
/* copy remaining trace fields */
trace.op_code = raw_trace->op_code;
trace.ata_op_code = raw_trace->ata_op_code;
trace.type = raw_trace->type;
trace.cmd_index = raw_trace->cmd_index;
return trace;
}
#define JIFF_TO_USEC(x) x * 1000 * 1000 / sysconf(_SC_CLK_TCK)
/**
* print_trace -
* @hdr: ipr entry header pointer
*
* Returns:
* nothing
**/
static void print_trace(struct ipr_dump_entry_header *hdr)
{
u32 i, min_pos, min_time, num_entries, offset;
struct ipr_trace_entry *raw_trace;
struct ipr_trace_entry t;
const char *cmnd;
num_entries = hdr->len / sizeof(*raw_trace);
raw_trace = dump_map + hdr->offset;
min_pos = 0;
min_time = TARGET_TO_HOST32(raw_trace->time, hdr->eye_catcher);
fprintf(out_fp, "\t entries found: %d\n\n", num_entries);
for (i = 1; i < num_entries; ++i) {
raw_trace = dump_map + hdr->offset + i*sizeof(*raw_trace);
if (TARGET_TO_HOST32(raw_trace->time, hdr->eye_catcher) <
min_time) {
min_time = TARGET_TO_HOST32(raw_trace->time,
hdr->eye_catcher);
min_pos = i;
}
}
for (i = 0; i < num_entries; ++i) {
offset = hdr->offset +
((min_pos+i)%num_entries) * sizeof(*raw_trace);
t = read_trace_data(offset, hdr->eye_catcher);
fprintf(out_fp, "\t %08X %02X%02X%02X%02X %08X %08X",
t.time, t.op_code, t.ata_op_code, t.type, t.cmd_index,
t.res_handle, t.u.add_data);
if (verbose_trace) {
t.time -= min_time;
fprintf(out_fp, "\t|\t%+10lld\xC2\xB5s\t",
(long long unsigned)JIFF_TO_USEC(t.time));
switch(t.type) {
case IPR_TRACE_START:
fprintf(out_fp, "START\t");
break;
case IPR_TRACE_FINISH:
fprintf(out_fp, "FINISH\t");
break;
default:
fprintf(out_fp, "\t");
}
cmnd = get_scsi_command_literal(t.op_code);
if (cmnd)
fprintf(out_fp, "%s", cmnd);
}
fprintf(out_fp, "\n");
}
}
/**
* dump_entry_data -
* @hdr: ipr dump entry header pointer
*
* Returns:
* nothing
**/
static void dump_entry_data(struct ipr_dump_entry_header *hdr)
{
u32 i;
char *s;
switch (hdr->id) {
case ID_IOA_LOC:
fprintf(out_fp, "IOA Location:\n");
s = dump_map+hdr->offset;
fprintf(out_fp, "\t %.*s\n\n", hdr->len, s);
break;
case ID_DRV_VER:
fprintf(out_fp, "Driver Version:\n");
s = dump_map+hdr->offset;
fprintf(out_fp, "\t %.*s\n\n", hdr->len, s);
break;
case ID_DRV_TRACE:
fprintf(out_fp, "Driver Trace Entries:\n");
print_trace(hdr);
fprintf(out_fp, "\n");
break;
case ID_DRV_TYPE:
fprintf(out_fp, "Driver Type:\n");
i = TARGET_TO_HOST32(*(int*)(dump_map+hdr->offset),
hdr->eye_catcher);
fprintf(out_fp, "\t CCIN: 0x%04X\n", i);
i = TARGET_TO_HOST32(*(int*)(dump_map+hdr->offset+sizeof(i)),
hdr->eye_catcher);
fprintf(out_fp,"\t Adapter firmware Version: "
" %02X%02X%02X%02X\n\n",
i >> 24, /* major release */
(i & 0x00FF0000) >> 16, /* card type */
(i & 0x0000FF00) >> 8, /* minor release 0 */
i & 0x000000FF); /* minor release 1 */
break;
case ID_IOA_DUMP:
/* skip this one, not very useful for driver debugging */
break;
case ID_DRV_CTRL_BLK:
case ID_DRV_PEND_OPS:
/* not implemented yet */
fprintf(stderr,
"Warning: found IPR Control Block or IPR Pending Ops!\n"
"These are not implemented yet. Skipping...\n");
break;
default:
fprintf(stderr,
"Warning: did not recognize data identification "
"(id 0x%08X). Skipping...\n\n", hdr->id);
}
}
/**
* fsize -
* @filename: ipr dump file name
*
* Returns:
* ipr dump file size
**/
off_t fsize(const char *filename)
{
struct stat st;
if (stat(filename, &st) == 0)
return st.st_size;
return -1;
}
/**
* print_usage -
*
* Returns:
* nothing
**/
static void print_usage()
{
fprintf(stdout,
"Usage: iprdumpfmt [options] dump_file\n"
" Options:\n"
"\t-h --help\tPrint this message\n"
"\t-o --output\tSpecify an output file\n"
"\t-v --verbose\tPrint verbose trace data\n");
}
static struct option long_options[] = {
{"output", required_argument, 0, 'o'},
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, &verbose_trace, 1},
{0, 0, 0, 0}
};
int main(int argc, char *argv[])
{
u32 i, offset;
int in_fd, filesize;
struct ipr_dump_header hdr;
struct ipr_dump_entry_header entry_hdr;
int c, option_index = 0;
char out_filename[512] = {'\0'};
while ((c = getopt_long(argc, argv, "hvo:", long_options,
&option_index)) != -1) {
switch (c) {
case 0:
break;
case 'o':
strncpy(out_filename, optarg, sizeof(out_filename) - 1);
break;
case '?':
case 'h':
print_usage();
return 0;
case 'v':
verbose_trace = 1;
break;
default:
return -1;
}
}
if (argc - optind < 1) {
/* needs at least a dump file */
print_usage();
return -1;
}
in_fd = open(argv[optind], O_RDONLY);
if (in_fd < 0) {
int rc = errno;
fprintf(stderr, "Could not open dump file %s: %s\n",
argv[optind], strerror(errno));
return rc;
}
if (out_filename[0] == '\0')
snprintf(out_filename, sizeof(out_filename), "%s.report",
argv[optind]);
out_fp = fopen(out_filename, "w");
if (out_fp == NULL) {
int rc = errno;
fprintf(stderr, "Could not open output file %s: %s\n",
out_filename, strerror(errno));
return rc;
}
filesize = fsize(argv[optind]);
if (filesize < 0) {
int rc = errno;
fprintf(stderr, "Could not determine size of %s: %s\n",
argv[optind], strerror(errno));
return rc;
}
dump_map = mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, in_fd, 0);
if (dump_map == MAP_FAILED) {
int rc = errno;
fprintf(stderr, "Could not map dump file to memory: %s\n",
strerror(errno));
return rc;
}
read_dump_header(&hdr);
print_dump_header(&hdr);
fprintf(out_fp, "\n");
offset = hdr.first_entry_offset;
for (i = 0; i < hdr.num_entries; ++i) {
offset = read_entry_header(&entry_hdr, offset);
dump_entry_data(&entry_hdr);
}
return 0;
}