Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sbin/iscsictl/iscsic_test.c

1146 lines
26 KiB
C
Raw Blame History

/* $NetBSD: iscsic_test.c,v 1.1 2011/10/23 21:11:23 agc Exp $ */
/*-
* Copyright (c) 2006,2011 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Wasabi Systems, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef ISCSI_TEST_MODE
#include <ctype.h>
#include <err.h>
#include <fcntl.h>
#include "iscsic_globals.h"
#include "iscsi_test.h"
#define WRITE_BUFFER_SIZE (64 * 1024)
#define hexdig(c) ((c & 0x40) ? (c & 0x07) + 9 : c & 0x0f)
typedef struct {
char *name;
int offset;
int size;
} off_sel_t;
typedef struct {
char *name;
int opt;
} str_sel_t;
typedef struct {
char *name;
int opt;
int type;
} mlopt_sel_t;
off_sel_t offtab[] = {
{"op", 0, 1}, /* Opcode */
{"dsl", 5, 3}, /* Data Segment Length */
{"lun", 8, 8}, /* SCSI,LUN */
{"itt", 16, 4}, /* Initiator Task Tag */
{"ttt", 20, 4}, /* Target Transfer Tag */
{"cmdsn", 24, 4}, /* Command Sequence Number (tx) */
{"statsn", 24, 4}, /* Status Sequence Number (rx) */
{"expstatsn", 28, 4}, /* Expected StatSN (tx) */
{"expcmdsn", 28, 4}, /* Expected CmdSN (rx) */
{"maxcmdsn", 32, 4}, /* Maximum CmdSN (rx) */
{"datasn", 36, 4}, /* Data Sequence Number */
{"expdatasn", 36, 4}, /* Expected DataSN */
{"boff", 40, 4}, /* Buffer Offset */
{"rescnt", 44, 4}, /* Residual Count */
{"hdigest", ISCSITEST_OFFSET_HEADERDIGEST, 4}, /* Header Digest */
{"data", ISCSITEST_OFFSET_DATA, 0}, /* Data Segment */
{"ddigest", ISCSITEST_OFFSET_DATADIGEST, 4}, /* Data Digest */
{"drvcmdsn", ISCSITEST_OFFSET_DRV_CMDSN, 4}, /* Driver CmdSN */
{NULL, 0, 0}
};
str_sel_t pdutab[] = {
{"any", ANY_PDU},
{"command", COMMAND_PDU},
{"response", RESPONSE_PDU},
{"taskreq", TASK_REQ_PDU},
{"taskrsp", TASK_RSP_PDU},
{"dataout", DATA_OUT_PDU},
{"datain", DATA_IN_PDU},
{"r2t", R2T_PDU},
{"asynch", ASYNCH_PDU},
{"textreq", TEXT_REQ_PDU},
{"textrsp", TEXT_RSP_PDU},
{"loginreq", LOGIN_REQ_PDU},
{"loginrsp", LOGIN_RSP_PDU},
{"logoutreq", LOGOUT_REQ_PDU},
{"logoutrsp", LOGOUT_RSP_PDU},
{"snack", SNACK_PDU},
{"reject", REJECT_PDU},
{"nopout", NOP_OUT_PDU},
{"nopin", NOP_IN_PDU},
{"invalid", INVALID_PDU},
{NULL, 0}
};
str_sel_t authtab[] = {
{"secneg", NEG_SECURITY}, /* First security negotiation PDU */
{"chapalg", NEG_CHAP_ALG}, /* CHAP authentication: algorithm specification. */
{"chapnr", NEG_CHAP_NAME_RESPONSE}, /* CHAP: Name and Response. */
{"opneg", NEG_OP_NEG}, /* First operational negotiation PDU. */
{NULL, 0}
};
str_sel_t offkindtab[] = {
{"aa", ABSOLUTE_ANY}, /* Absolute to start of connection, any kind */
{"ra", RELATIVE_ANY}, /* Relative to last processed PDU, any kind */
{"ar", ABSOLUTE_RX}, /* Absolute to start of connection, any kind, rx */
{"rr", RELATIVE_RX}, /* Relative to last processed PDU, any kind, rx */
{"at", ABSOLUTE_TX}, /* Absolute to start of connection, any kind, tx */
{"rt", RELATIVE_TX}, /* Relative to last processed PDU, any kind, tx */
{"ak", ABSOLUTE_PDUKIND}, /* Absolute to start of connection, same PDU kind */
{"ra", RELATIVE_PDUKIND}, /* Relative to last processed PDU, same PDU kind */
{NULL, 0}
};
/*
* get_hexbyte:
* Get a hex byte from argument.
*
* Parameter:
* arg argument
*
* Returns: value of byte, or -1 if not a hex byte.
*/
STATIC int
get_hexbyte(char *arg)
{
if (isxdigit(arg[0]) && !arg[1]) {
return hexdig(arg[0]);
}
if (isxdigit(arg[1]) && !arg[2]) {
return hexdig(arg[0]) << 4 | hexdig(arg[1]);
}
return -1;
}
/*
* get_connid:
* Get connection ID. Queries Daemon for numeric ID if the user specifies
* a symbolic connection name.
*
* Parameter:
* argc, argv (shifted)
* session
*
* Returns: connection ID or 0 if OK - else it doesn't return at all.
*/
STATIC uint32_t
get_connid(int argc, char **argv, uint32_t session)
{
iscsid_sym_id_t sid;
iscsid_get_connection_info_req_t req;
iscsid_response_t *rsp;
if (!cl_get_id('C', &sid, argc, argv)) {
return 0;
}
if (!sid.id) {
req.session_id.name[0] = '\0';
req.session_id.id = session;
strlcpy(req.connection_id.name, sid.name,
sizeof(req.connection_id.name));
req.connection_id.id = 0;
send_request(ISCSID_GET_CONNECTION_INFO, sizeof(req), &req);
rsp = get_response(FALSE);
if (rsp->status) {
status_error(rsp->status);
} else {
sid.id = ((iscsid_get_connection_info_rsp_t *) &rsp->parameter)
->connection_id.id;
}
free_response(rsp);
}
return sid.id;
}
/*
* get_offset:
* Get a PDU modification record
*
* Parameter:
* argc, argv program parameters (shifted)
* modp pointer to PDU modification record
*
* Returns: 1 if parameter present, 0 if not.
* Aborts app on bad parameter.
*/
STATIC int
get_pdumod(int argc, char **argv, iscsi_pdu_mod_t * modp)
{
int i, j, found;
char *sp;
int off = 0, size = 4, flags = 0;
for (i = 0, found = FALSE; i < argc; i++) {
if (argv[i] && argv[i][0] == '-' && argv[i][1] == 'o') {
found = TRUE;
break;
}
}
if (!found) {
return 0;
}
sp = (argv[i][2]) ? &argv[i][2] : ((i + 1 < argc) ? argv[i + 1] : NULL);
if (!sp || !*sp) {
arg_error(argv[i], "Offset value missing");
}
if (isdigit(*sp)) {
if (!sscanf(sp, "%i", &off)) {
arg_error(argv[i], "Numeric value expected");
}
} else {
for (j = 0; offtab[j].name != NULL; j++) {
if (strcmp(sp, offtab[j].name) == 0) {
break;
}
}
if (offtab[j].name == NULL) {
arg_error(argv[i], "Invalid offset '%s'", sp);
}
off = offtab[j].offset;
size = offtab[j].size;
}
if (!argv[i][2]) {
argv[i] = argv[i + 1] = NULL;
i += 2;
} else
argv[i++] = NULL;
if (i >= argc)
arg_missing("Modification Value");
if (argv[i] && argv[i][0] == '-' && argv[i][1] == 's') {
sp = (argv[i][2]) ? &argv[i][2] : ((i + 1 < argc) ? argv[i + 1] : NULL);
if (!sp || !*sp)
arg_error(argv[i], "Size value missing");
if (sscanf(sp, "%i", &size) == 0)
arg_error(argv[i], "Numeric value expected");
if (size <= 0 || size > 8)
arg_error(argv[i], "Invalid size %d", size);
if (!argv[i][2]) {
argv[i] = argv[i + 1] = NULL;
i += 2;
} else
argv[i++] = NULL;
if (i >= argc)
arg_missing("Modification Value");
}
if (argv[i] && argv[i][0] == '-' && argv[i][1] == 'a') {
flags |= ISCSITEST_MOD_FLAG_ADD_VAL;
argv[i++] = NULL;
if (i >= argc)
arg_missing("Modification Value");
}
sp = argv[i];
if (!sp || (!isxdigit(*sp) && *sp != '-' && *sp != '+'))
arg_missing("Modification Value");
if (i + 1 < argc && argv[i + 1] && isxdigit(argv[i + 1][0])) {
char *dp = modp->value;
int val, n = size;
do {
if (0 > (val = get_hexbyte(sp)))
arg_error(argv[i], "Hex byte expected");
if (n) {
*dp++ = (uint8_t) val;
n--;
}
argv[i++] = NULL;
sp = (i < argc) ? argv[i] : NULL;
} while (sp && isxdigit(*sp));
} else {
int64_t val;
if (!sscanf(sp, "%qi", &val))
arg_error(argv[i], "Numeric value expected");
*((int64_t *) modp->value) = val;
argv[i] = NULL;
modp->flags |= ISCSITEST_MOD_FLAG_REORDER;
}
modp->offset = (uint32_t) off;
modp->size = (uint16_t) size;
modp->flags = (uint16_t) flags;
DEB(9, ("get_pdumod offset %d, size %d, flags %x, val %qd\n", off, size,
flags, *((uint64_t *) modp->value)));
return 1;
}
/*
* get_updopt:
* Get PDU update options for send_pdu
*
* Parameter:
* argc, argv program parameters (shifted)
*
* Returns: Value of option, 0 if not present.
* Aborts app on bad parameter.
*/
STATIC int
get_updopt(int argc, char **argv, int send)
{
int i;
char *sp;
int val = ISCSITEST_SFLAG_UPDATE_FIELDS;
for (i = 0;
i < argc && (!argv[i] || argv[i][0] != '-' || argv[i][1] != 'u');
i++) {
}
if (i >= argc) {
return 0;
}
sp = (argv[i][2]) ? &argv[i][2] : ((i + 1 < argc) ? argv[i + 1] : NULL);
if (!sp || !*sp || *sp == '-') {
argv[i] = NULL;
return val;
}
while (*sp) {
switch (*sp) {
case 'h':
val |= ISCSITEST_SFLAG_NO_HEADER_DIGEST;
break;
case 'i':
val |= ISCSITEST_SFLAG_NO_DATA_DIGEST;
break;
case 'p':
if (send) {
val |= ISCSITEST_SFLAG_NO_PADDING;
break;
}
/* FALLTHROUGH */
default:
arg_error(argv[i], "Invalid update option '%c'", *sp);
}
sp++;
}
if (!argv[i][2]) {
argv[i + 1] = NULL;
}
argv[i] = NULL;
return val;
}
/*
* get_stropt:
* Get an option specified by a string
*
* Parameter:
* argc, argv program parameters (shifted)
* flagp pointer to flags result
*
* Returns: Value of string, -1 if not present.
* Aborts app on bad parameter.
*/
STATIC int
get_stropt(int argc, char **argv, char selc, str_sel_t * table)
{
int i, j;
char *sp;
int val = -1;
for (i = 0; i < argc; i++) {
if (!argv[i] || argv[i][0] != '-') {
continue;
}
if (argv[i][1] == selc) {
sp = (argv[i][2]) ? &argv[i][2]
: ((i + 1 < argc) ? argv[i + 1] : NULL);
if (!sp || !*sp) {
arg_error(argv[i], "Option missing");
}
for (j = 0; table[j].name != NULL; j++) {
if (strcmp(sp, table[j].name) == 0) {
break;
}
}
if (table[j].name == NULL) {
arg_error(argv[i], "Invalid option '%s'", sp);
}
val = table[j].opt;
if (!argv[i][2]) {
argv[i + 1] = NULL;
}
argv[i] = NULL;
break;
}
}
DEB(10, ("get_stropt -%c returns %d\n", selc, val));
return val;
}
/*
* get_mlint:
* Get a multiletter integer option
*
* Parameter:
* argc, argv program parameters (shifted)
*
* Returns: Value of option, -1 if not present.
* Aborts app on bad parameter.
*/
STATIC int
get_mlint(int argc, char **argv, char *opt)
{
int i;
char *sp;
int val = -1;
for (i = 0; i < argc; i++) {
if (!argv[i] || argv[i][0] != '-') {
continue;
}
if (strcmp(&argv[i][1], opt) == 0) {
sp = (i + 1 < argc) ? argv[i + 1] : NULL;
if (!sp || !*sp) {
arg_error(argv[i], "Missing numeric value");
}
if (sscanf(sp, "%i", &val) == 0) {
arg_error(argv[i], "Invalid number");
}
argv[i] = argv[i + 1] = NULL;
break;
}
}
DEB(10, ("get_mlint returns %d\n", val));
return val;
}
/*
* get_mlbool:
* Get a multiletter boolean option
*
* Parameter:
* argc, argv program parameters (shifted)
*
* Returns: Value of option (0 or 1), -1 if not present.
* Aborts app on bad parameter.
*/
STATIC int
get_mlbool(int argc, char **argv, char *opt)
{
int i;
char *sp;
int val = -1;
for (i = 0; i < argc; i++) {
if (!argv[i] || argv[i][0] != '-') {
continue;
}
if (strcmp(&argv[i][1], opt) == 0) {
sp = (i + 1 < argc) ? argv[i + 1] : NULL;
if (!sp || !*sp) {
arg_error(argv[i], "Missing truth value");
}
if (sp[1]) {
arg_error(argv[i], "Invalid truth value '%s'", sp);
}
switch (*sp) {
case 't':
case 'T':
case '1':
val = 1;
break;
case 'f':
case 'F':
case '0':
val = 0;
break;
default:
arg_error(argv[i], "Bad truth value '%c'", *sp);
}
argv[i] = argv[i + 1] = NULL;
break;
}
}
DEB(10, ("get_mlbool returns %d\n", val));
return val;
}
/*
* get_blob:
* Get a large binary value.
*
* Parameter:
* argc, argv program parameters (shifted)
* dp destination
* maxlen maximum size
* name name of parameter for error message if missing
*
* Returns: Size of value in bytes.
* Aborts app on bad parameter.
*/
STATIC int
get_blob(char ident, int argc, char **argv, uint8_t * dp, int maxlen, char *name)
{
int i, l;
char *arg;
int size = 0;
for (i = 0;
i < argc && (!argv[i] || argv[i][0] != '-' || argv[i][1] != ident);
i++) {
}
if (i >= argc) {
arg_missing(name);
}
arg = (argv[i][2]) ? &argv[i][2] : ((i + 1 < argc) ? argv[i + 1] : NULL);
if (!arg || !*arg) {
arg_missing(name);
}
if (!argv[i][2]) {
argv[i++] = NULL;
}
while (arg && *arg != '-') {
if (0 <= (l = get_hexbyte(arg))) {
if (!maxlen) {
arg_error(argv[i], "Buffer size exceeded");
}
*dp++ = (uint8_t) l;
size++;
maxlen--;
} else {
if (arg[0] == '.') {
arg++;
}
if (!arg[0]) {
arg_error(argv[i], "Leading dot removed, nothing left");
}
l = strlen(arg);
if (l >= maxlen) {
arg_error(argv[i], "String exceeds buffer size");
}
strlcpy(dp, arg, maxlen);
dp += l;
size += l;
maxlen -= l;
}
argv[i++] = NULL;
if (i >= argc) {
break;
}
arg = argv[i];
}
if (!size) {
arg_missing(name);
}
DEB(10, ("get_blob returns %d\n", size));
return size;
}
/*
* get_file:
* Get a large binary value from file, or, if no file parameter is present,
* allocate buffer for blob.
*
* Parameter:
* argc, argv program parameters (shifted)
* pbufp pointer to buffer pointer
* plen pointer to size of buffer. The initial size contained
* in this parameter is used as an offset into the target
* buffer and is added to the allocation size.
* psize pointer to int to receive size option.
* rd TRUE if read, FALSE if write
*
* Returns: handle of file if file parameter present, -1 if not.
* Aborts app on bad parameter.
*/
STATIC int
get_file(int argc, char **argv, caddr_t *pbufp, uint32_t *plen, int *psize,
int rd)
{
char fname[ISCSI_STRING_LENGTH];
int hnd = -1, size;
off_t fsize = 0;
uint8_t *bp = buf;
size = *psize = cl_get_int('s', argc, argv);
if (cl_get_string('f', fname, argc, argv)) {
hnd = open(fname, (rd) ? O_RDONLY : (O_WRONLY | O_CREAT | O_TRUNC),
0x666);
if (hnd < 0) {
io_error("Opening file '%s'", fname);
}
if (rd) {
fsize = lseek(hnd, 0, SEEK_END);
lseek(hnd, 0, SEEK_SET);
if (!fsize) {
gen_error("File '%s' is empty", fname);
}
}
}
if (!size) {
if (hnd >= 0) {
size = (rd) ? fsize : WRITE_BUFFER_SIZE;
} else {
size = BUF_SIZE - *plen;
}
}
if (size < fsize) {
fsize = size;
}
size += *plen;
if (size > BUF_SIZE && (bp = calloc(1, size)) == NULL) {
gen_error("Can't allocate %d bytes for buffer", size);
}
(void) memset(bp, 0x0, size);
*pbufp = (caddr_t) bp;
bp += *plen;
*plen = size;
if (rd && hnd >= 0) {
if (read(hnd, bp, fsize) != fsize) {
io_error("Reading file '%s'", fname);
}
close(hnd);
}
return hnd;
}
/*
* t_define:
* Handle the test define command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
STATIC int
t_define(int argc, char **argv)
{
iscsi_test_define_parameters_t def = { 0 };
int rc;
if ((def.test_id = cl_get_int('T', argc, argv)) == 0) {
arg_missing("define: Test ID");
}
if ((def.session_id = get_sessid(argc, argv, TRUE)) != 0) {
def.connection_id = get_connid(argc, argv, def.session_id);
}
if ((rc = get_mlint(argc, argv, "mr2t")) != -1) {
def.r2t_val = (uint32_t) rc;
def.options |= ISCSITEST_NEGOTIATE_R2T;
}
if ((rc = get_mlint(argc, argv, "mbl")) != -1) {
def.maxburst_val = (uint32_t) rc;
def.options |= ISCSITEST_NEGOTIATE_MAXBURST;
}
if ((rc = get_mlint(argc, argv, "fbl")) != -1) {
def.firstburst_val = (uint32_t) rc;
def.options |= ISCSITEST_NEGOTIATE_FIRSTBURST;
}
if (get_mlbool(argc, argv, "ir2t") > 0) {
def.options |= ISCSITEST_OVERRIDE_INITIALR2T;
}
if (get_mlbool(argc, argv, "imm") == 0) {
def.options |= ISCSITEST_OVERRIDE_IMMDATA;
}
if ((rc = get_mlbool(argc, argv, "tcmd")) != -1) {
def.options |= (rc) ? ISCSITEST_OPT_ENABLE_CCB_TIMEOUT
: ISCSITEST_OPT_DISABLE_CCB_TIMEOUT;
}
if ((rc = get_mlbool(argc, argv, "tconn")) != -1) {
def.options |= (rc) ? ISCSITEST_OPT_ENABLE_CONN_TIMEOUT
: ISCSITEST_OPT_DISABLE_CONN_TIMEOUT;
}
if ((rc = get_mlint(argc, argv, "rlrx")) != -1) {
def.options |= ISCSITEST_OPT_USE_RANDOM_RX;
def.lose_random_rx = (uint8_t) rc;
}
if ((rc = get_mlint(argc, argv, "rltx")) != -1) {
def.options |= ISCSITEST_OPT_USE_RANDOM_TX;
def.lose_random_tx = (uint8_t) rc;
}
check_extra_args(argc, argv);
DEB(1, ("DefTest: tid=%d, opt=%x, lrtx=%d, lrrx=%d, sid=%d, cid=%d\n",
def.test_id, def.options, def.lose_random_tx, def.lose_random_rx,
def.session_id, def.connection_id));
DEB(1, (" r2t=%d, mbl=%d, fbl=%d, erl=%d\n",
def.r2t_val, def.maxburst_val, def.firstburst_val, def.erl_val));
rc = ioctl(driver, ISCSI_TEST_DEFINE, &def);
if (def.status) {
status_error(def.status);
}
if (rc) {
io_error("define: I/O command");
}
return rc;
}
/*
* t_add_pdumod:
* Handle the test add_pdumod command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
STATIC int
t_add_pdumod(int argc, char **argv)
{
iscsi_test_add_modification_parameters_t def = { 0 };
int rc, rd, hnd = -1;
if ((def.test_id = cl_get_int('T', argc, argv)) == 0) {
arg_missing("add_pdumod: Test ID");
}
if ((def.pdu_offset = cl_get_uint('p', argc, argv)) == (uint32_t) -1) {
arg_missing("add_pdumod: PDU Number");
}
if ((rc = get_stropt(argc, argv, 'b', offkindtab)) != -1) {
def.which_offset = rc;
}
if ((rc = get_stropt(argc, argv, 'k', pdutab)) != -1) {
def.which_pdu = rc;
}
def.options = get_updopt(argc, argv, FALSE);
if (cl_get_opt('w', argc, argv)) {
def.options |= ISCSITEST_OPT_WAIT_FOR_COMPLETION;
}
if (cl_get_opt('n', argc, argv)) {
def.options |= ISCSITEST_OPT_NO_RESPONSE_PDU;
}
if ((rc = get_mlbool(argc, argv, "tcmd")) != -1) {
def.options |= (rc) ? ISCSITEST_OPT_ENABLE_CCB_TIMEOUT
: ISCSITEST_OPT_DISABLE_CCB_TIMEOUT;
}
if ((rc = get_mlbool(argc, argv, "tconn")) != -1) {
def.options |= (rc) ? ISCSITEST_OPT_ENABLE_CONN_TIMEOUT
: ISCSITEST_OPT_DISABLE_CONN_TIMEOUT;
}
if ((rc = get_mlint(argc, argv, "rlrx")) != -1) {
def.options |= ISCSITEST_OPT_USE_RANDOM_RX;
def.lose_random_rx = (uint8_t) rc;
}
if ((rc = get_mlint(argc, argv, "rltx")) != -1) {
def.options |= ISCSITEST_OPT_USE_RANDOM_TX;
def.lose_random_tx = (uint8_t) rc;
}
if ((rd = cl_get_opt('r', argc, argv)) != 0)
hnd = get_file(argc, argv, &def.pdu_ptr, &def.pdu_size, &rc, FALSE);
if (cl_get_opt('D', argc, argv))
def.options |= ISCSITEST_OPT_DISCARD_PDU;
if (cl_get_opt('K', argc, argv))
def.options |= ISCSITEST_KILL_CONNECTION;
if (!(def.options & (ISCSITEST_OPT_DISCARD_PDU |
ISCSITEST_KILL_CONNECTION))) {
iscsi_pdu_mod_t *modp = def.mod_ptr = (iscsi_pdu_mod_t *) buf;
while (get_pdumod(argc, argv, modp)) {
if (modp->offset == ISCSITEST_OFFSET_HEADERDIGEST)
def.options |= ISCSITEST_SFLAG_NO_HEADER_DIGEST;
else if (modp->offset == ISCSITEST_OFFSET_DATADIGEST)
def.options |= ISCSITEST_SFLAG_NO_DATA_DIGEST;
modp++;
def.num_pdu_mods++;
}
if (!rd && !def.num_pdu_mods)
arg_missing("add_pdumod: PDU Modification");
}
check_extra_args(argc, argv);
DEB(1, ("AddMod: tid=%d, opt=%x, offs=%d, which=%d, pdukind=%d, "
"num=%d, rd_size=%d\n",
def.test_id, def.options, def.pdu_offset, def.which_offset,
def.which_pdu, def.num_pdu_mods, def.pdu_size));
#ifdef ISCSI_DEBUG
if (def.num_pdu_mods)
DEB(1, (" 0: offset=%d, size=%d, flags=%d, val=%qx\n",
def.mod_ptr[0].offset, def.mod_ptr[0].size,
def.mod_ptr[0].flags, *((uint64_t *) def.mod_ptr[0].value)));
#endif
rc = ioctl(driver, ISCSI_TEST_ADD_MODIFICATION, &def);
if (def.status)
status_error(def.status);
if (rc)
io_error("add_pdumod: I/O command");
if (!rd)
return 0;
if (!def.pdu_actual_size)
gen_error("add_pdumod: No data read");
if (hnd >= 0) {
rc = def.pdu_actual_size;
rc -= write(hnd, def.pdu_ptr, def.pdu_actual_size);
close(hnd);
if (rc) {
io_error("add_pdumod: Writing file");
}
} else {
dump_data("PDU Data", def.pdu_ptr, def.pdu_actual_size);
}
return rc;
}
/*
* t_add_negmod:
* Handle the test add_negmod command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
STATIC int
t_add_negmod(int argc, char **argv)
{
iscsi_test_add_negotiation_parameters_t def = { 0 };
iscsi_test_negotiation_descriptor_t *neg;
int hnd, rc, size;
if ((def.test_id = cl_get_int('T', argc, argv)) == 0) {
arg_missing("add_negmond: Test ID");
}
def.neg_descriptor_size = sizeof(iscsi_test_negotiation_descriptor_t);
hnd = get_file(argc, argv, &def.neg_descriptor_ptr,
&def.neg_descriptor_size, &size, TRUE);
neg = (iscsi_test_negotiation_descriptor_t *) def.neg_descriptor_ptr;
neg->size = def.neg_descriptor_size
- sizeof(iscsi_test_negotiation_descriptor_t);
if (hnd < 0) {
neg->size = get_blob('d', argc, argv, neg->value, neg->size,
"Negotiation Value");
if (size) {
neg->size = size;
}
def.neg_descriptor_size = neg->size
+ sizeof(iscsi_test_negotiation_descriptor_t);
}
/* XXX - agc */
if (0 > (neg->state = get_stropt(argc, argv, 'p', authtab)))
arg_missing("add_negmod: Negotiation Phase");
if (cl_get_opt('r', argc, argv))
neg->flags |= ISCSITEST_NEGOPT_REPLACE;
check_extra_args(argc, argv);
DEB(1, ("AddNeg: tid=%d, phase=%d, flags=%x, hnd=%d, size=%d, "
"ptr=%x, data=%s\n",
def.test_id, neg->state, neg->flags, hnd, def.neg_descriptor_size,
(int) def.neg_descriptor_ptr, neg->value));
rc = ioctl(driver, ISCSI_TEST_ADD_NEGOTIATION, &def);
if (def.status) {
status_error(def.status);
}
if (rc) {
io_error("add_negmod: I/O command");
}
return rc;
}
/*
* t_send_pdu:
* Handle the test send_pdu command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
STATIC int
t_send_pdu(int argc, char **argv)
{
iscsi_test_send_pdu_parameters_t def = { 0 };
int rc, size;
if ((def.test_id = cl_get_int('T', argc, argv)) == 0) {
arg_missing("send_pdu: Test ID");
}
def.options = get_updopt(argc, argv, TRUE);
if (cl_get_opt('K', argc, argv)) {
def.options |= ISCSITEST_KILL_CONNECTION;
}
/* weird */
if (0 > get_file(argc, argv, &def.pdu_ptr, &def.pdu_size, &size, TRUE)) {
def.pdu_size = get_blob('d', argc, argv, buf, def.pdu_size, "PDU Data");
if (size) {
def.pdu_size = size;
}
}
check_extra_args(argc, argv);
rc = ioctl(driver, ISCSI_TEST_SEND_PDU, &def);
if (def.status) {
status_error(def.status);
}
if (rc) {
io_error("send_pdu: I/O command");
}
return rc;
}
/*
* t_iocommand:
* Handle the test iocommand command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK - else it doesn't return at all.
*/
STATIC int
t_iocommand(int argc, char **argv)
{
iscsi_iocommand_parameters_t io = { 0 };
int nodata, rd, rc, size, hnd = -1;
if ((io.session_id = get_sessid(argc, argv, FALSE)) == 0) {
return 1;
}
io.connection_id = get_connid(argc, argv, io.session_id);
io.lun = cl_get_longlong('l', argc, argv);
if (cl_get_opt('i', argc, argv)) {
io.options.immediate = 1;
}
rd = cl_get_opt('r', argc, argv);
nodata = cl_get_opt('n', argc, argv);
if (rd && nodata) {
gen_error("iocommand: Conflicting options -r -n\n");
}
io.req.cmdlen = get_blob('c', argc, argv, io.req.cmd, sizeof(io.req.cmd),
"CCB");
if ((rc = cl_get_int('S', argc, argv)) != 0) {
if (rc < 0 || rc > 16) {
gen_error("Iocommand: Invalid CCB size %d", rc);
}
io.req.cmdlen = rc;
}
if (!nodata) {
/* weird */
if (0 > (hnd = get_file(argc, argv, &io.req.databuf,
(uint32_t *) &io.req.datalen, &size, !rd)) && !rd) {
io.req.datalen = get_blob('d', argc, argv, io.req.databuf,
io.req.datalen, "Command Data");
if (size) {
io.req.datalen = size;
}
}
}
check_extra_args(argc, argv);
DEB(1, ("IoCmd: sid=%d, rd=%d, cmdlen=%d, cmd=%02x %02x %02x.., "
"len=%d, ptr=%x\n",
io.session_id, rd, io.req.cmdlen, io.req.cmd[0], io.req.cmd[1],
io.req.cmd[2], (int) io.req.datalen, (int) io.req.databuf));
if ((rc = do_ioctl(&io, rd)) != 0) {
return rc;
}
if (rd) {
if (!io.req.datalen_used) {
gen_error("iocommand: No Data!");
}
if (hnd >= 0) {
rc = io.req.datalen_used;
rc -= write(hnd, io.req.databuf, io.req.datalen_used);
close(hnd);
if (rc) {
io_error("iocommand: Writing file");
}
} else {
dump_data("Command Data", io.req.databuf, io.req.datalen_used);
}
}
return rc;
}
/*
* t_cancel:
* Handle the test cancel command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
STATIC int
t_cancel(int argc, char **argv)
{
iscsi_test_cancel_parameters_t def = { 0 };
int rc;
if ((def.test_id = cl_get_int('T', argc, argv)) == 0) {
arg_missing("cancel: Test ID");
}
check_extra_args(argc, argv);
DEB(1, ("Cancel Test: tid=%d\n", def.test_id));
rc = ioctl(driver, ISCSI_TEST_CANCEL, &def);
if (def.status) {
status_error(def.status);
}
if (rc) {
io_error("cancel: I/O command");
}
return rc;
}
/*------------------------------------------------------------------------ */
static command_t tests[] = {
{"define", t_define},
{"add_pdumod", t_add_pdumod},
{"add_negmod", t_add_negmod},
{"send_pdu", t_send_pdu},
{"iocommand", t_iocommand},
{"cancel", t_cancel},
{NULL, NULL}
};
/*
* test:
* Handle the test command.
*
* Parameter: argc, argv (shifted)
*
* Returns: 0 if OK.
*/
int
test(int argc, char **argv)
{
command_t *c;
if (argv[0] == NULL || argv[0][1] == '-') {
arg_missing("Test command");
}
for (c = tests; c->cmd != NULL; c++) {
if (strcmp(c->cmd, argv[0]) == 0) {
break;
}
}
if (c->cmd == NULL) {
gen_error("Unkown test command %s", argv[0]);
}
return c->proc(argc - 1, &argv[1]);
}
#endif
Reference in New Issue View Git Blame Copy Permalink