sg3_utils/src/sg_rtpg.c - backupdr - Git at Google

 /*
  * Copyright (c) 2004-2015 Christophe Varoqui and Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
  */

 #include <unistd.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <getopt.h>

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include "sg_lib.h"
 #include "sg_cmds_basic.h"
 #include "sg_cmds_extra.h"
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"

 /* A utility program for the Linux OS SCSI subsystem.
  *
  *
  * This program issues the SCSI command REPORT TARGET PORT GROUPS
  * to the given SCSI device.
  */

 static const char * version_str = "1.20 20151219";

 #define REPORT_TGT_GRP_BUFF_LEN 1024

 #define TPGS_STATE_OPTIMIZED 0x0
 #define TPGS_STATE_NONOPTIMIZED 0x1
 #define TPGS_STATE_STANDBY 0x2
 #define TPGS_STATE_UNAVAILABLE 0x3
 #define TPGS_STATE_LB_DEPENDENT 0x4
 #define TPGS_STATE_OFFLINE 0xe          /* SPC-4 rev 9 */
 #define TPGS_STATE_TRANSITIONING 0xf

 #define STATUS_CODE_NOSTATUS 0x0
 #define STATUS_CODE_CHANGED_BY_SET 0x1
 #define STATUS_CODE_CHANGED_BY_IMPLICIT 0x2

 static struct option long_options[] = {
         {"decode", 0, 0, 'd'},
         {"extended", 0, 0, 'e'},
         {"help", 0, 0, 'h'},
         {"hex", 0, 0, 'H'},
         {"raw", 0, 0, 'r'},
         {"readonly", 0, 0, 'R'},
         {"verbose", 0, 0, 'v'},
         {"version", 0, 0, 'V'},
         {0, 0, 0, 0},
 };

 static void usage()
 {
     pr2serr("Usage: sg_rtpg   [--decode] [--extended] [--help] [--hex] "
             "[--raw] [--readonly]\n"
             "                 [--verbose] [--version] DEVICE\n"
             "  where:\n"
             "    --decode|-d        decode status and asym. access state\n"
             "    --extended|-e      use extended header parameter data "
             "format\n"
             "    --help|-h          print out usage message\n"
             "    --hex|-H           print out response in hex\n"
             "    --raw|-r           output response in binary to stdout\n"
             "    --readonly|-R      open DEVICE read-only (def: read-write)\n"
             "    --verbose|-v       increase verbosity\n"
             "    --version|-V       print version string and exit\n\n"
             "Performs a SCSI REPORT TARGET PORT GROUPS command\n");

 }

 static void dStrRaw(const char* str, int len)
 {
     int k;

     for (k = 0 ; k < len; ++k)
         printf("%c", str[k]);
 }

 static void decode_status(const int st)
 {
     switch (st) {
     case STATUS_CODE_NOSTATUS:
         printf(" (no status available)");
         break;
     case STATUS_CODE_CHANGED_BY_SET:
         printf(" (target port asym. state changed by SET TARGET PORT "
                "GROUPS command)");
         break;
     case STATUS_CODE_CHANGED_BY_IMPLICIT:
         printf(" (target port asym. state changed by implicit lu "
                "behaviour)");
         break;
     default:
         printf(" (unknown status code)");
         break;
     }
 }

 static void decode_tpgs_state(const int st)
 {
     switch (st) {
     case TPGS_STATE_OPTIMIZED:
         printf(" (active/optimized)");
         break;
     case TPGS_STATE_NONOPTIMIZED:
         printf(" (active/non optimized)");
         break;
     case TPGS_STATE_STANDBY:
         printf(" (standby)");
         break;
     case TPGS_STATE_UNAVAILABLE:
         printf(" (unavailable)");
         break;
     case TPGS_STATE_LB_DEPENDENT:
         printf(" (logical block dependent)");
         break;
     case TPGS_STATE_OFFLINE:
         printf(" (offline)");
         break;
     case TPGS_STATE_TRANSITIONING:
         printf(" (transitioning between states)");
         break;
     default:
         printf(" (unknown)");
         break;
     }
 }

 int main(int argc, char * argv[])
 {
     int sg_fd, k, j, off, res, c, report_len, tgt_port_count;
     unsigned char reportTgtGrpBuff[REPORT_TGT_GRP_BUFF_LEN];
     unsigned char * ucp;
     int decode = 0;
     int hex = 0;
     int raw = 0;
     int o_readonly = 0;
     int verbose = 0;
     int extended = 0;
     const char * device_name = NULL;
     int ret = 0;

     while (1) {
         int option_index = 0;

         c = getopt_long(argc, argv, "dehHrRvV", long_options,
                         &option_index);
         if (c == -1)
             break;

         switch (c) {
         case 'd':
             decode = 1;
             break;
         case 'e':
              extended = 1;
              break;
         case 'h':
         case '?':
             usage();
             return 0;
         case 'H':
             hex = 1;
             break;
         case 'r':
             raw = 1;
             break;
         case 'R':
             ++o_readonly;
             break;
         case 'v':
             ++verbose;
             break;
         case 'V':
             pr2serr("Version: %s\n", version_str);
             return 0;
         default:
             pr2serr("unrecognised option code 0x%x ??\n", c);
             usage();
             return SG_LIB_SYNTAX_ERROR;
         }
     }
     if (optind < argc) {
         if (NULL == device_name) {
             device_name = argv[optind];
             ++optind;
         }
         if (optind < argc) {
             for (; optind < argc; ++optind)
                 pr2serr("Unexpected extra argument: %s\n", argv[optind]);
             usage();
             return SG_LIB_SYNTAX_ERROR;
         }
     }

     if (NULL == device_name) {
         pr2serr("missing device name!\n");
         usage();
         return SG_LIB_SYNTAX_ERROR;
     }
     if (raw) {
         if (sg_set_binary_mode(STDOUT_FILENO) < 0) {
             perror("sg_set_binary_mode");
             return SG_LIB_FILE_ERROR;
         }
     }

     sg_fd = sg_cmds_open_device(device_name, o_readonly, verbose);
     if (sg_fd < 0) {
         pr2serr("open error: %s: %s\n", device_name, safe_strerror(-sg_fd));
         return SG_LIB_FILE_ERROR;
     }

     memset(reportTgtGrpBuff, 0x0, sizeof(reportTgtGrpBuff));
     /* trunc = 0; */

     res = sg_ll_report_tgt_prt_grp2(sg_fd, reportTgtGrpBuff,
                                     sizeof(reportTgtGrpBuff),
                                     extended, 1, verbose);
     ret = res;
     if (0 == res) {
         report_len = sg_get_unaligned_be32(reportTgtGrpBuff + 0) + 4;
         if (report_len > (int)sizeof(reportTgtGrpBuff)) {
             /* trunc = 1; */
             pr2serr("  <<report too long for internal buffer, output "
                     "truncated\n");
             report_len = (int)sizeof(reportTgtGrpBuff);
         }
         if (raw) {
             dStrRaw((const char *)reportTgtGrpBuff, report_len);
             goto err_out;
         }
         if (verbose)
             printf("Report list length = %d\n", report_len);
         if (hex) {
             if (verbose)
                 printf("\nOutput response in hex:\n");
             dStrHex((const char *)reportTgtGrpBuff, report_len, 1);
             goto err_out;
         }
         printf("Report target port groups:\n");
         ucp = reportTgtGrpBuff + 4;
         if (extended) {
              if (0x10 != (ucp[0] & 0x70)) {
                   pr2serr("   <<invalid extended header format\n");
                   goto err_out;
              }
              printf("  Implicit transition time: %d\n", ucp[1]);
              ucp += 4;
         }
         for (k = ucp - reportTgtGrpBuff; k < report_len;
              k += off, ucp += off) {

             printf("  target port group id : 0x%x , Pref=%d, Rtpg_fmt=%d\n",
                    sg_get_unaligned_be16(ucp + 2), !!(ucp[0] & 0x80),
                    (ucp[0] >> 4) & 0x07);
             printf("    target port group asymmetric access state : ");
             printf("0x%02x", ucp[0] & 0x0f);
             if (decode)
                 decode_tpgs_state(ucp[0] & 0x0f);
             printf("\n");

             printf("    T_SUP : %d, ", !!(ucp[1] & 0x80));
             printf("O_SUP : %d, ", !!(ucp[1] & 0x40));
             printf("LBD_SUP : %d, ", !!(ucp[1] & 0x10));
             printf("U_SUP : %d, ", !!(ucp[1] & 0x08));
             printf("S_SUP : %d, ", !!(ucp[1] & 0x04));
             printf("AN_SUP : %d, ", !!(ucp[1] & 0x02));
             printf("AO_SUP : %d\n", !!(ucp[1] & 0x01));

             printf("    status code : ");
             printf("0x%02x", ucp[5]);
             if (decode)
                 decode_status(ucp[5]);
             printf("\n");

             printf("    vendor unique status : ");
             printf("0x%02x\n", ucp[6]);

             printf("    target port count : ");
             tgt_port_count = ucp[7];
             printf("%02x\n", tgt_port_count);

             for (j = 0; j < tgt_port_count * 4; j += 4) {
                 if (0 == j)
                     printf("    Relative target port ids:\n");
                 printf("      0x%02x\n",
                        sg_get_unaligned_be16(ucp + 8 + j + 2));
             }
             off = 8 + j;
         }
     } else if (SG_LIB_CAT_INVALID_OP == res)
         pr2serr("Report Target Port Groups command not supported\n");
     else if (SG_LIB_CAT_ILLEGAL_REQ == res)
         pr2serr("bad field in Report Target Port Groups cdb including "
                 "unsupported service action\n");
     else {
         char b[80];

         sg_get_category_sense_str(res, sizeof(b), b, verbose);
         pr2serr("Report Target Port Groups: %s\n", b);
     }

 err_out:
     res = sg_cmds_close_device(sg_fd);
     if (res < 0) {
         pr2serr("close error: %s\n", safe_strerror(-res));
         if (0 == ret)
             return SG_LIB_FILE_ERROR;
     }
     return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
 }
	/*
	* Copyright (c) 2004-2015 Christophe Varoqui and Douglas Gilbert.
	* All rights reserved.
	* Use of this source code is governed by a BSD-style
	* license that can be found in the BSD_LICENSE file.
	*/

	#include <unistd.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <getopt.h>

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif
	#include "sg_lib.h"
	#include "sg_cmds_basic.h"
	#include "sg_cmds_extra.h"
	#include "sg_unaligned.h"
	#include "sg_pr2serr.h"

	/* A utility program for the Linux OS SCSI subsystem.
	*
	*
	* This program issues the SCSI command REPORT TARGET PORT GROUPS
	* to the given SCSI device.
	*/

	static const char * version_str = "1.20 20151219";

	#define REPORT_TGT_GRP_BUFF_LEN 1024

	#define TPGS_STATE_OPTIMIZED 0x0
	#define TPGS_STATE_NONOPTIMIZED 0x1
	#define TPGS_STATE_STANDBY 0x2
	#define TPGS_STATE_UNAVAILABLE 0x3
	#define TPGS_STATE_LB_DEPENDENT 0x4
	#define TPGS_STATE_OFFLINE 0xe /* SPC-4 rev 9 */
	#define TPGS_STATE_TRANSITIONING 0xf

	#define STATUS_CODE_NOSTATUS 0x0
	#define STATUS_CODE_CHANGED_BY_SET 0x1
	#define STATUS_CODE_CHANGED_BY_IMPLICIT 0x2

	static struct option long_options[] = {
	{"decode", 0, 0, 'd'},
	{"extended", 0, 0, 'e'},
	{"help", 0, 0, 'h'},
	{"hex", 0, 0, 'H'},
	{"raw", 0, 0, 'r'},
	{"readonly", 0, 0, 'R'},
	{"verbose", 0, 0, 'v'},
	{"version", 0, 0, 'V'},
	{0, 0, 0, 0},
	};

	static void usage()
	{
	pr2serr("Usage: sg_rtpg [--decode] [--extended] [--help] [--hex] "
	"[--raw] [--readonly]\n"
	" [--verbose] [--version] DEVICE\n"
	" where:\n"
	" --decode\|-d decode status and asym. access state\n"
	" --extended\|-e use extended header parameter data "
	"format\n"
	" --help\|-h print out usage message\n"
	" --hex\|-H print out response in hex\n"
	" --raw\|-r output response in binary to stdout\n"
	" --readonly\|-R open DEVICE read-only (def: read-write)\n"
	" --verbose\|-v increase verbosity\n"
	" --version\|-V print version string and exit\n\n"
	"Performs a SCSI REPORT TARGET PORT GROUPS command\n");

	}

	static void dStrRaw(const char* str, int len)
	{
	int k;

	for (k = 0 ; k < len; ++k)
	printf("%c", str[k]);
	}

	static void decode_status(const int st)
	{
	switch (st) {
	case STATUS_CODE_NOSTATUS:
	printf(" (no status available)");
	break;
	case STATUS_CODE_CHANGED_BY_SET:
	printf(" (target port asym. state changed by SET TARGET PORT "
	"GROUPS command)");
	break;
	case STATUS_CODE_CHANGED_BY_IMPLICIT:
	printf(" (target port asym. state changed by implicit lu "
	"behaviour)");
	break;
	default:
	printf(" (unknown status code)");
	break;
	}
	}

	static void decode_tpgs_state(const int st)
	{
	switch (st) {
	case TPGS_STATE_OPTIMIZED:
	printf(" (active/optimized)");
	break;
	case TPGS_STATE_NONOPTIMIZED:
	printf(" (active/non optimized)");
	break;
	case TPGS_STATE_STANDBY:
	printf(" (standby)");
	break;
	case TPGS_STATE_UNAVAILABLE:
	printf(" (unavailable)");
	break;
	case TPGS_STATE_LB_DEPENDENT:
	printf(" (logical block dependent)");
	break;
	case TPGS_STATE_OFFLINE:
	printf(" (offline)");
	break;
	case TPGS_STATE_TRANSITIONING:
	printf(" (transitioning between states)");
	break;
	default:
	printf(" (unknown)");
	break;
	}
	}

	int main(int argc, char * argv[])
	{
	int sg_fd, k, j, off, res, c, report_len, tgt_port_count;
	unsigned char reportTgtGrpBuff[REPORT_TGT_GRP_BUFF_LEN];
	unsigned char * ucp;
	int decode = 0;
	int hex = 0;
	int raw = 0;
	int o_readonly = 0;
	int verbose = 0;
	int extended = 0;
	const char * device_name = NULL;
	int ret = 0;

	while (1) {
	int option_index = 0;

	c = getopt_long(argc, argv, "dehHrRvV", long_options,
	&option_index);
	if (c == -1)
	break;

	switch (c) {
	case 'd':
	decode = 1;
	break;
	case 'e':
	extended = 1;
	break;
	case 'h':
	case '?':
	usage();
	return 0;
	case 'H':
	hex = 1;
	break;
	case 'r':
	raw = 1;
	break;
	case 'R':
	++o_readonly;
	break;
	case 'v':
	++verbose;
	break;
	case 'V':
	pr2serr("Version: %s\n", version_str);
	return 0;
	default:
	pr2serr("unrecognised option code 0x%x ??\n", c);
	usage();
	return SG_LIB_SYNTAX_ERROR;
	}
	}
	if (optind < argc) {
	if (NULL == device_name) {
	device_name = argv[optind];
	++optind;
	}
	if (optind < argc) {
	for (; optind < argc; ++optind)
	pr2serr("Unexpected extra argument: %s\n", argv[optind]);
	usage();
	return SG_LIB_SYNTAX_ERROR;
	}
	}

	if (NULL == device_name) {
	pr2serr("missing device name!\n");
	usage();
	return SG_LIB_SYNTAX_ERROR;
	}
	if (raw) {
	if (sg_set_binary_mode(STDOUT_FILENO) < 0) {
	perror("sg_set_binary_mode");
	return SG_LIB_FILE_ERROR;
	}
	}

	sg_fd = sg_cmds_open_device(device_name, o_readonly, verbose);
	if (sg_fd < 0) {
	pr2serr("open error: %s: %s\n", device_name, safe_strerror(-sg_fd));
	return SG_LIB_FILE_ERROR;
	}

	memset(reportTgtGrpBuff, 0x0, sizeof(reportTgtGrpBuff));
	/* trunc = 0; */

	res = sg_ll_report_tgt_prt_grp2(sg_fd, reportTgtGrpBuff,
	sizeof(reportTgtGrpBuff),
	extended, 1, verbose);
	ret = res;
	if (0 == res) {
	report_len = sg_get_unaligned_be32(reportTgtGrpBuff + 0) + 4;
	if (report_len > (int)sizeof(reportTgtGrpBuff)) {
	/* trunc = 1; */
	pr2serr(" <<report too long for internal buffer, output "
	"truncated\n");
	report_len = (int)sizeof(reportTgtGrpBuff);
	}
	if (raw) {
	dStrRaw((const char *)reportTgtGrpBuff, report_len);
	goto err_out;
	}
	if (verbose)
	printf("Report list length = %d\n", report_len);
	if (hex) {
	if (verbose)
	printf("\nOutput response in hex:\n");
	dStrHex((const char *)reportTgtGrpBuff, report_len, 1);
	goto err_out;
	}
	printf("Report target port groups:\n");
	ucp = reportTgtGrpBuff + 4;
	if (extended) {
	if (0x10 != (ucp[0] & 0x70)) {
	pr2serr(" <<invalid extended header format\n");
	goto err_out;
	}
	printf(" Implicit transition time: %d\n", ucp[1]);
	ucp += 4;
	}
	for (k = ucp - reportTgtGrpBuff; k < report_len;
	k += off, ucp += off) {

	printf(" target port group id : 0x%x , Pref=%d, Rtpg_fmt=%d\n",
	sg_get_unaligned_be16(ucp + 2), !!(ucp[0] & 0x80),
	(ucp[0] >> 4) & 0x07);
	printf(" target port group asymmetric access state : ");
	printf("0x%02x", ucp[0] & 0x0f);
	if (decode)
	decode_tpgs_state(ucp[0] & 0x0f);
	printf("\n");

	printf(" T_SUP : %d, ", !!(ucp[1] & 0x80));
	printf("O_SUP : %d, ", !!(ucp[1] & 0x40));
	printf("LBD_SUP : %d, ", !!(ucp[1] & 0x10));
	printf("U_SUP : %d, ", !!(ucp[1] & 0x08));
	printf("S_SUP : %d, ", !!(ucp[1] & 0x04));
	printf("AN_SUP : %d, ", !!(ucp[1] & 0x02));
	printf("AO_SUP : %d\n", !!(ucp[1] & 0x01));

	printf(" status code : ");
	printf("0x%02x", ucp[5]);
	if (decode)
	decode_status(ucp[5]);
	printf("\n");

	printf(" vendor unique status : ");
	printf("0x%02x\n", ucp[6]);

	printf(" target port count : ");
	tgt_port_count = ucp[7];
	printf("%02x\n", tgt_port_count);

	for (j = 0; j < tgt_port_count * 4; j += 4) {
	if (0 == j)
	printf(" Relative target port ids:\n");
	printf(" 0x%02x\n",
	sg_get_unaligned_be16(ucp + 8 + j + 2));
	}
	off = 8 + j;
	}
	} else if (SG_LIB_CAT_INVALID_OP == res)
	pr2serr("Report Target Port Groups command not supported\n");
	else if (SG_LIB_CAT_ILLEGAL_REQ == res)
	pr2serr("bad field in Report Target Port Groups cdb including "
	"unsupported service action\n");
	else {
	char b[80];

	sg_get_category_sense_str(res, sizeof(b), b, verbose);
	pr2serr("Report Target Port Groups: %s\n", b);
	}

	err_out:
	res = sg_cmds_close_device(sg_fd);
	if (res < 0) {
	pr2serr("close error: %s\n", safe_strerror(-res));
	if (0 == ret)
	return SG_LIB_FILE_ERROR;
	}
	return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
	}